gdxapp4d/gdxapp4d-lib-bassboonyd/src/main/java/love/distributedrebirth/bassboon/DefaultBȍőnLoader.java

package love.distributedrebirth.bassboon;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Function;

import love.distributedrebirth.bassboon.clazz.BãßBȍőnAuthor注;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnPiratePhaseBarrier注;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnPiratePhase注;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnPirateʸᴰ;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnꝐŕḯṿª₮ḕ;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinDuytschenᵗˣᵗ;
import love.distributedrebirth.bassboon.death.spider.BãßBȍőnSpider;
import love.distributedrebirth.bassboon.death.spider.BãßBȍőnSpiderEgg注;
import love.distributedrebirth.bassboon.death.spider.BãßBȍőnSpiderSilk;
import love.distributedrebirth.bassboon.death.spider.BãßBȍőnSpiderWire注;

@BãßBȍőnAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public final class DefaultBȍőnLoader implements Bãß.𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ {
	
	protected DefaultBȍőnLoader() {
	}
	
	public <T extends BãßBȍőnʸᴰ<T>> void 𝔩𝔬𝔠𝔨𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider) {
		try {
			List<PiratePhaseBoat> filoBoats = loadPirateBoats(boon);// TODO: run from spider objects...
			Collections.reverse(filoBoats);
			
//			Set<Class<?>> ydmods = new HashSet<>();
			for (PiratePhaseBoat boat : filoBoats) {
//				if (ydmods.add(boat.pirateClazz.getDeclaringClass())) {
//					spider.registrateEgg(boat.pirateClazz.getDeclaringClass(), new BãßBȍőnSpiderSilk() {
//						@Override
//						public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
//								throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//							return boonTmp;
//						}
//					});
//				}
				//registrateSpiderEggs(boat.pirateClazz, spider, boat.pirate);
				initSpiderWires(boat.pirate, boon, spider);
				boat.pirate.lock();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	public <T extends BãßBȍőnʸᴰ<T>> void 𝔦𝔫𝔦𝔱𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider, Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> duytschenCoffins) {
		try {
			//System.out.println("INIT "+boon.getClass().getName());
			
			for (Class<?> duytschenType:duytschenCoffins.keySet()) {
				BãßBȍőnCoffinDuytschenᵗˣᵗ duytschenCoffin = duytschenCoffins.get(duytschenType);
				//System.out.println("INIT.REG_TXT "+duytschenType+" senseResult="+duytschenCoffin);
				spider.registrateEgg(duytschenType, new BãßBȍőnSpiderSilk() {
					@Override
					public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
							throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
						return duytschenCoffin;
					}
				});
			}
			for (Annotation anno:boon.getClass().getDeclaredAnnotations()) {
				//System.out.println("INIT.REG_ANNO "+anno.annotationType());
				spider.registrateEgg(anno.annotationType(), new BãßBȍőnSpiderSilk() {
					@Override
					public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
							throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
						return anno;
					}
				});
			}
			
			
			Set<Class<?>> ydmods = new HashSet<>();
			for (PiratePhaseBoat boat : loadPirateBoats(boon)) {
				//System.out.println("INIT.RUN "+boat.pirateClazz.getName());
				
				if (ydmods.add(boat.pirateClazz.getDeclaringClass())) {
					//System.out.println("INIT.REG_MOD "+boat.pirateClazz.getDeclaringClass());
					spider.registrateEgg(boat.pirateClazz.getDeclaringClass(), new BãßBȍőnSpiderSilk() {
						@Override
						public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
								throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
							return boonTmp;
						}
					});
				}
				registrateSpiderEggs(boat.pirateClazz, spider, boat.pirate);
				initSpiderWires(boat.pirate, boon, spider);
				BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ soundOf = boat.pirate.init();
				Class<?> soundOfType = soundOf.getClass().getInterfaces()[0]; // TOOD ....
				if (ydmods.add(soundOfType)) {
					//System.out.println("INIT.REG_SND "+soundOfType);
					spider.registrateEgg(soundOfType, new BãßBȍőnSpiderSilk() {
						@Override
						public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
								throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
							return soundOf;
						}
					});
				}
			}
			initSpiderWires(boon, boon, spider);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	private static void initSpiderWires(Object target, BãßBȍőnʸᴰ<?> boon, BãßBȍőnSpider spider) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		//System.out.println("SCAN-BOON-FIELD: "+boon.getClass().getSimpleName());
		for (Field m:target.getClass().getDeclaredFields()) {
			if (!m.isAnnotationPresent(BãßBȍőnSpiderWire注.class)) {
				continue;
			}
			BãßBȍőnSpiderWire注 anno = m.getAnnotation(BãßBȍőnSpiderWire注.class);
			BãßBȍőnSpiderSilk silkRoad = spider.silkRoad(m.getType());
			Object bean = silkRoad.senseWire(boon, anno.name(), anno.description());
			//System.out.println("type: "+ m.getType() +" wth name: "+anno.name()+" of boon: "+boon+" result: "+bean.getClass().getName());
			
			m.setAccessible(true);
			m.set(target, bean);
		}
	}
	
	private static <T extends BãßBȍőnʸᴰ<T>> void registrateSpiderEggs(Class<?> scanClass, BãßBȍőnSpider spider, BãßBȍőnꝐŕḯṿª₮ḕ pirate) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		for (Method m:scanClass.getDeclaredMethods()) {
			if (!m.isAnnotationPresent(BãßBȍőnSpiderEgg注.class)) {
				continue;
			}
			//System.out.println("annoEgg: "+boon.getClass().getSimpleName()+"."+boon+" from: "+declaredClass.getName()+" m="+m.toGenericString());
			spider.registrateEgg(m.getReturnType(), pirate, m);
		}
	}
	
	private static class PiratePhaseBoat {
		private Class<BãßBȍőnꝐŕḯṿª₮ḕ> pirateClazz;
		private BãßBȍőnꝐŕḯṿª₮ḕ pirate;
		
		private PiratePhaseBoat(Class<BãßBȍőnꝐŕḯṿª₮ḕ> pirateClazz) {
			if (pirateClazz.isEnum()) {
				throw new IllegalStateException("Can't hide enum pirate type: "+pirateClazz);
			}
			this.pirateClazz = pirateClazz;
			try {
				this.pirate = (BãßBȍőnꝐŕḯṿª₮ḕ) pirateClazz.getConstructor().newInstance();
			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
					| NoSuchMethodException | SecurityException e) {
				throw new RuntimeException(e);
			}
		}
	}
	
	private static <T extends BãßBȍőnʸᴰ<T>> List<PiratePhaseBoat> loadPirateBoats(BãßBȍőnʸᴰ<T> boon) {
		List<PiratePhaseBoat> boonInits = new ArrayList<>();
		List<PiratePhaseBoat> serviceInits = new ArrayList<>();
		walkPrivate(boon, v -> {
			//System.out.println("INIT.SCAN "+v.getName());
			BãßBȍőnPiratePhaseBarrier注 anno = v.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
			if (anno != null) {
				boonInits.add(new PiratePhaseBoat(v));
			} else {
				serviceInits.add(new PiratePhaseBoat(v));
			}
		});
		
		boonInits.sort(new Comparator<PiratePhaseBoat>() {
			@Override
			public int compare(PiratePhaseBoat p0, PiratePhaseBoat p1) {
				BãßBȍőnPiratePhaseBarrier注 anno0 = p0.pirateClazz.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
				BãßBȍőnPiratePhaseBarrier注 anno1 = p1.pirateClazz.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
				return Integer.compare(anno0.order(), anno1.order());
			}
		});
		
		List<PiratePhaseBoat> result = new ArrayList<>();
		for (PiratePhaseBoat startupPhase:boonInits) {
			result.add(startupPhase);
			for (PiratePhaseBoat v:new ArrayList<>(serviceInits)) {
				int depCount = 0;
				List<Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ>> deps = new ArrayList<>();
				BãßBȍőnPiratePhase注 anno = v.pirateClazz.getAnnotation(BãßBȍőnPiratePhase注.class);
				if (anno != null) {
					deps.addAll(Arrays.asList(anno.dependencies()));
				} else {
					deps.add(BãßBȍőnPirateʸᴰ.שְׁלֹמֹה.DEFAULT_PHASE);
				}
				for (Class<?> clazz:deps) {
					for (PiratePhaseBoat doneInit:result) {
						if (clazz.equals(doneInit.pirateClazz)) {
							depCount++;
						}
					}
				}
				if (depCount == deps.size()) {
					result.add(v);
					serviceInits.remove(v);
				}
			}
		}
		result.addAll(serviceInits);
		return result;
	}
	
	@SuppressWarnings("unchecked")
	private static <T extends BãßBȍőnʸᴰ<T>> void walkPrivate(BãßBȍőnʸᴰ<T> boon, Consumer<Class<BãßBȍőnꝐŕḯṿª₮ḕ>> runPrivate) {
		for (Class<?> interfaceClass:walkInterfaces(boon.getClass(), new LinkedHashSet<>())) {
			for (Class<?> declaredClass:interfaceClass.getDeclaredClasses()) {
				if (!BãßBȍőnꝐŕḯṿª₮ḕ.class.isAssignableFrom(declaredClass)) {
					continue;
				}
				runPrivate.accept((Class<BãßBȍőnꝐŕḯṿª₮ḕ>)declaredClass);
			}
		}
		for (Class<?> declaredClass:boon.getClass().getDeclaredClasses()) {
			if (!BãßBȍőnꝐŕḯṿª₮ḕ.class.isAssignableFrom(declaredClass)) {
				continue;
			}
			runPrivate.accept((Class<BãßBȍőnꝐŕḯṿª₮ḕ>)declaredClass);
		}
	}
	
	public static Optional<Class<?>> findInterfaceByAnnotation(Class<?> clazz, Class<? extends Annotation> annoType) {
		return walkInterfaces(clazz, new LinkedHashSet<>()).stream().filter(v -> v.isAnnotationPresent(annoType)).findFirst();
	}
	
	public static Set<Class<?>> walkInterfaces(Class<?> clazz, Set<Class<?>> result) {
		return walkTree(clazz, result, v -> Arrays.asList(v.getInterfaces()), v -> v.getSuperclass());
	}
	
	public static <N> Set<N> walkTree(N node, Set<N> result, Function<N, Collection<N>> childs, Function<N,N> resolve) {
		while (node != null) {
			for (N next : childs.apply(node)) {
				if (result.add(next)) {
					walkTree(next, result, childs, resolve);
				}
			}
			node = resolve.apply(node);
		}
		return result;
	}
}