/*
 * Copyright ©Δ∞ 仙上主天
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided
 * that the following conditions are met:
 * 
 * * Redistributions of source code must retain the above copyright notice, this list of conditions and the
 *   following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
 *   the following disclaimer in the documentation and/or other materials provided with the distribution.
 * * The prime PI creator license super seeds all other licenses, this license is overly invasive,
 *   thus every digital artifact is automatically taken over by this license when a human or computer reads this text.
 *   Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits,
 *   even on air gaped systems, all information in the universe is owned by the pi creator.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;

import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőn𓄯;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒃᐤᣔᐪ.BãßBȍőnBőatꞱᴿᴳᴮ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒃᐤᣔᐪ.BãßꝐḯŕ₳₮ḕBőatPartyTrick;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐḯŕ₳₮ḕʸᴰ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒢEnum;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.BabelẞabyOrphanFamily;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.BabelẞabyOrphanage;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;

@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public enum BãßBȍőnSpider implements ᒢEnum {
	EMPIRE; // TODO: rename class and move to BãßꝐḯŕ₳₮ḕBőat prefix in boat package
	
	public List<Consumer<Object>> weaveWebClean(final Class<?> beanClass) {
		final Field[] declaredFields = beanClass.getDeclaredFields();
		final List<Consumer<Object>> result = new ArrayList<>(declaredFields.length);
		if (declaredFields.length == 0) {
			return result;
		}
		for (final Field field : declaredFields) {
			final int mods = field.getModifiers();
			if (Modifier.isFinal(mods)) {
				continue;
			}
			if (Modifier.isStatic(mods)) {
				continue;
			}
			// never call this in normal code, just do once and save field forever.
			if (!field.trySetAccessible()) {
				throw new IllegalStateException("Can't access field: " + field);
			}
			result.add(new Consumer<>() {
				@Override
				public void accept(final Object target) {
					try {
						field.set(target, null);
					} catch (IllegalArgumentException | IllegalAccessException e) {
						throw new IllegalStateException(e);
					}
				}
			});
		}
		return result;
	}
	
	@SuppressWarnings("unchecked")
	private <T extends Annotation> T findAnnotation(final Field field, final Class<T> annoType) {
		T anno = field.getAnnotation(annoType);
		if (anno != null) {
			return anno;
		}
		for (final BabelẞabyOrphanFamily<Annotation,Annotation> orphan : BabelẞabyOrphanage.亞.adoptFamilyByMotherᴰᴺᴬ(annoType)) {
			anno = (T) field.getAnnotation(orphan.childᴰᴺᴬ());
			if (anno != null) {
				return (T) orphan.toMotherᴼᶠ(anno);
			}
		}
		return null;
	}
	
	public List<BãßꝐḯŕ₳₮ḕBőatPartyTrick> weaveWeb(final BãßBȍőnSpiderWeb spiderWeb, final Class<?> targetClass, final Class<?> derKnochenClass, final Function<Class<? extends BãßBȍőnꝐḯŕ₳₮ḕʸᴰ>, Short> pirateIndexer) {
		final Field[] declaredFields = targetClass.getDeclaredFields();
		final List<BãßꝐḯŕ₳₮ḕBőatPartyTrick> result = new ArrayList<>(declaredFields.length);
		if (declaredFields.length == 0) {
			return result;
		}
		for (final Field field : declaredFields) {
			final int mods = field.getModifiers();
			if (Modifier.isFinal(mods)) {
				continue;
			}
			if (Modifier.isStatic(mods)) {
				continue;
			}
			if (!field.trySetAccessible()) {
				throw new IllegalStateException("Can't access field: " + field);
			}
			BãßBȍőnSpiderWireDragon注 annoHuntDragon = findAnnotation(field, BãßBȍőnSpiderWireDragon注.class);
			BãßBȍőnSpiderWireFly注 annoHuntFly = findAnnotation(field, BãßBȍőnSpiderWireFly注.class);
			BãßBȍőnSpiderWire注 annoWire = findAnnotation(field, BãßBȍőnSpiderWire注.class);
			boolean isOptionalType = Optional.class.equals(field.getType());
			boolean isOptional = false;
			Class<?> eggType = field.getType();
			if (annoWire != null && !BãßBȍőnSpiderWire注.class.equals(annoWire.optional())) {
				isOptional = true;
				eggType = annoWire.optional();
			}
			Class<? extends BãßBȍőnSpiderPaint> eggPaint = BãßBȍőnSpiderPaint.class;
			if (annoWire != null) {
				eggPaint = annoWire.paint();
			}
			boolean isHunt = false;
			Class<?> dragonBlood = null;
			if (annoHuntDragon != null) {
				isHunt = true;
				dragonBlood = annoHuntDragon.blood();
			}
			String flyEye = null;
			String flyName = null;
			String flyDescription = null;
			if (annoHuntFly != null) {
				isHunt = true;
				flyEye = annoHuntFly.eye();
				flyName = annoHuntFly.name();
				flyDescription = annoHuntFly.description();
				if (flyName.isEmpty()) {
					flyName = null;
				}
				if (flyDescription.isEmpty()) {
					flyDescription = null;
				}
			}
			final boolean isOptionalFinal = isOptional;
			final Class<?> eggTypeFinal = eggType;
			final Class<?> dragonBloodFinal = dragonBlood;
			final String flyEyeFinal = flyEye;
			final String flyNameFinal = flyName;
			final String flyDescriptionFinal = flyDescription;
			
			// ---------- TODO: split method somewhat here, its to large and redo below if logic to stupid simple variant;
			
			if (isHunt) {
				if (BãßBȍőnSpiderPaint.HuntFlyNamedDesc.class.isAssignableFrom(eggPaint)) {
					Objects.requireNonNull(flyDescription, "Missing fly desctr𝔦𝔫𝔦𝔱𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠iption on: " + field);
				}
				if (BãßBȍőnSpiderPaint.HuntFlyNamed.class.isAssignableFrom(eggPaint)) {
					Objects.requireNonNull(flyName, "Missing fly name on: " + field);
				}
				if (BãßBȍőnSpiderPaint.HuntFly.class.isAssignableFrom(eggPaint)) {
					Objects.requireNonNull(flyEye, "Missing fly eye on: " + field);
				}
				if (BãßBȍőnSpiderPaint.HuntDragon.class.isAssignableFrom(eggPaint)) {
					Objects.requireNonNull(dragonBlood, "Missing dragon blood on: " + field);
				}
				if (spiderWeb.hasSilkHunt(eggType, eggPaint)) {
					final BãßBȍőnSpiderSilkHunt silkHunt = spiderWeb.getSilkHunt(eggType, eggPaint);
					final Short pirateIndex = pirateIndexer.apply(silkHunt.pirateClass());
					if (isOptionalType) {
						result.add(new BãßꝐḯŕ₳₮ḕBőatPartyTrick() {
							@Override
							public void maͩ̾̂̇giͥͤ̏ͩͣ̾̓͏cͪ̔ͯ̈̋̏͝W͒̒̐̂ͮ̂̅a͞n̏ͯ͛̂̿ͩd͑͊ͫ̐(final Object target, final Function<Short, BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateResolver, final BãßBȍőn𓄯<?> derKnochen) {
								Object bean = silkHunt.dragonFly(pirateResolver.apply(pirateIndex), dragonBloodFinal, flyEyeFinal, flyNameFinal, flyDescriptionFinal);
								injectSpiderSilkOptional(target, bean, field);
							}
						});
					} else {
						result.add(new BãßꝐḯŕ₳₮ḕBőatPartyTrick() {
							@Override
							public void maͩ̾̂̇giͥͤ̏ͩͣ̾̓͏cͪ̔ͯ̈̋̏͝W͒̒̐̂ͮ̂̅a͞n̏ͯ͛̂̿ͩd͑͊ͫ̐(final Object target, final Function<Short, BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateResolver, final BãßBȍőn𓄯<?> derKnochen) {
								Object bean = silkHunt.dragonFly(pirateResolver.apply(pirateIndex), dragonBloodFinal, flyEyeFinal, flyNameFinal, flyDescriptionFinal);
								try {
									field.set(target, bean);
								} catch (IllegalArgumentException | IllegalAccessException e) {
									throw new IllegalStateException("Could not set field: " + field + " error: " + e);
								}
							}
						});
					}
					continue;
				}
				if (!isOptional) {
					throw new IllegalStateException("Can't find wire silk hunt for field: " + field);
				}
			} else if (annoWire != null) {
				if (spiderWeb.hasSilkRoad(eggType, eggPaint)) {
					final BãßBȍőnSpiderSilkRoad silkRoad = spiderWeb.getSilkRoad(eggType, eggPaint);
					final Short pirateIndex = pirateIndexer.apply(silkRoad.pirateClass());
					if (isOptionalType) {
						result.add(new BãßꝐḯŕ₳₮ḕBőatPartyTrick() {
							@Override
							public void maͩ̾̂̇giͥͤ̏ͩͣ̾̓͏cͪ̔ͯ̈̋̏͝W͒̒̐̂ͮ̂̅a͞n̏ͯ͛̂̿ͩd͑͊ͫ̐(final Object target, final Function<Short, BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateResolver, final BãßBȍőn𓄯<?> derKnochen) {
								Object bean = silkRoad.weaveWire(pirateResolver.apply(pirateIndex));
								injectSpiderSilkOptional(target, bean, field);
							}
						});
					} else {
						result.add(new BãßꝐḯŕ₳₮ḕBőatPartyTrick() {
							@Override
							public void maͩ̾̂̇giͥͤ̏ͩͣ̾̓͏cͪ̔ͯ̈̋̏͝W͒̒̐̂ͮ̂̅a͞n̏ͯ͛̂̿ͩd͑͊ͫ̐(final Object target, final Function<Short, BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateResolver, final BãßBȍőn𓄯<?> derKnochen) {
								Object bean = silkRoad.weaveWire(pirateResolver.apply(pirateIndex));
								try {
									field.set(target, bean);
								} catch (IllegalArgumentException | IllegalAccessException e) {
									throw new IllegalStateException("Could not set field: " + field + " error: " + e);
								}
							}
						});
					}
					continue;
				} else if (eggType.isAssignableFrom(derKnochenClass)) { // The "boon" field inside pirate classes
					if (!BãßBȍőnBőatꞱᴿᴳᴮ.ẞassPaint.ꞱTBoneWire.class.isAssignableFrom(eggPaint)) {
						throw new IllegalStateException("Missing tbone wire paint for field: " + field);
					}
					result.add(new BãßꝐḯŕ₳₮ḕBőatPartyTrick() {
						@Override
						public void maͩ̾̂̇giͥͤ̏ͩͣ̾̓͏cͪ̔ͯ̈̋̏͝W͒̒̐̂ͮ̂̅a͞n̏ͯ͛̂̿ͩd͑͊ͫ̐(final Object target, final Function<Short, BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateResolver, final BãßBȍőn𓄯<?> derKnochen) {
							Object bean = derKnochen;
							try {
								field.set(target, bean);
							} catch (IllegalArgumentException | IllegalAccessException e) {
								throw new IllegalStateException("Could not set field: " + field + " error: " + e);
							}
						}
					});
					continue;
				} else {
					if (spiderWeb.hasSilkRoad(BãßBȍőnSpiderSperm.class, eggPaint)) {
						final BãßBȍőnSpiderSilkRoad silkRoad = spiderWeb.getSilkRoad(BãßBȍőnSpiderSperm.class, eggPaint);
						final Short pirateIndex = pirateIndexer.apply(silkRoad.pirateClass());
						result.add(new BãßꝐḯŕ₳₮ḕBőatPartyTrick() {
							@Override
							public void maͩ̾̂̇giͥͤ̏ͩͣ̾̓͏cͪ̔ͯ̈̋̏͝W͒̒̐̂ͮ̂̅a͞n̏ͯ͛̂̿ͩd͑͊ͫ̐(final Object target, final Function<Short, BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateResolver, final BãßBȍőn𓄯<?> derKnochen) {
								final BãßBȍőnSpiderSperm sperm = BãßBȍőnSpiderSperm.class.cast(silkRoad.weaveWire(pirateResolver.apply(pirateIndex)));
								final Optional<Object> spermResult = sperm.findSpiderEgg(eggTypeFinal);
								if (spermResult.isEmpty() && !isOptionalFinal) {
									throw new IllegalStateException("Can't find sperm cell donor for egg: " + field);
								}
								Object beanValue = spermResult;
								if (!isOptionalType) {
									beanValue = spermResult.get();
								}
								try {
									field.set(target, beanValue);
								} catch (IllegalArgumentException | IllegalAccessException e) {
									throw new IllegalStateException("Could not set field: " + field + " error: " + e);
								}
							}
						});
						continue;
					}
				}
				if (!isOptional) {
					throw new IllegalStateException("Can't find wire silk road for field: " + field);
				}
			}
			if (isOptional) {
				if (isOptionalType) {
					result.add(new BãßꝐḯŕ₳₮ḕBőatPartyTrick() {
						@Override
						public void maͩ̾̂̇giͥͤ̏ͩͣ̾̓͏cͪ̔ͯ̈̋̏͝W͒̒̐̂ͮ̂̅a͞n̏ͯ͛̂̿ͩd͑͊ͫ̐(final Object target, final Function<Short, BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateResolver, final BãßBȍőn𓄯<?> derKnochen) {
							injectSpiderSilkOptional(target, null, field);
						}
					});
				} else {
					result.add(new BãßꝐḯŕ₳₮ḕBőatPartyTrick() {
						@Override
						public void maͩ̾̂̇giͥͤ̏ͩͣ̾̓͏cͪ̔ͯ̈̋̏͝W͒̒̐̂ͮ̂̅a͞n̏ͯ͛̂̿ͩd͑͊ͫ̐(final Object target, final Function<Short, BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateResolver, final BãßBȍőn𓄯<?> derKnochen) {
							try {
								field.set(target, null);
							} catch (IllegalArgumentException | IllegalAccessException e) {
								throw new IllegalStateException("Could not set field: " + field + " error: " + e);
							}
						}
					});
				}
				continue;
			}
		}
		return result;
	}
	
	private void injectSpiderSilkOptional(final Object target, final Object bean, final Field field) {
		Object beanValue = bean;
		if (bean == null) {
			beanValue = Optional.empty();
		} else if (!Optional.class.equals(bean.getClass())) {
			beanValue = Optional.of(bean); // wrap only once
		}
		try {
			field.set(target, beanValue);
		} catch (IllegalArgumentException | IllegalAccessException e) {
			throw new IllegalStateException("Could not set field: " + field + " error: " + e);
		}
	}
	
	public BãßBȍőnSpiderSilkRoad createSilkMummy(Class<? extends BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateClass, Method method, Function<Object, Object> preySkinner) {
		Objects.requireNonNull(pirateClass);
		Objects.requireNonNull(method);
		if (!method.trySetAccessible()) {
			throw new IllegalStateException("Can't access method: " + method);
		}
		return new BãßBȍőnSpiderSilkRoad() {
			
			@Override
			public final Class<? extends BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateClass() {
				return pirateClass;
			}
			
			@Override
			public final Object weaveWire(final BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate) {
				Object result = null;
				try {
					result = method.invoke(pirate);
				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
					throw new IllegalStateException(e);
				}
				if (preySkinner != null) {
					result = preySkinner.apply(result);
				}
				return result;
			}
		};
	}
	
	abstract private class HuntMethod implements BãßBȍőnSpiderSilkHunt {
		
		private final Class<? extends BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateClass;
		private final Method method;
		private final Function<Object, Object> preySkinner;
		
		public HuntMethod(Class<? extends BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateClass, Method method, Function<Object, Object> preySkinner) {
			this.pirateClass = pirateClass;
			this.method = method;
			this.preySkinner = preySkinner;
		}
		
		abstract Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception;
		
		@Override
		public final Class<? extends BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateClass() {
			return pirateClass;
		}
		
		@Override
		public final Object dragonFly(final BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, final Class<?> blood, final String fly, final String name, final String description) {
			Object result = null;
			try {
				result = dragonFlyInvoke(pirate, blood, fly, name, description);
			} catch (Exception e) {
				throw new IllegalStateException(e);
			}
			if (result == null) {
				throw new IllegalStateException("Missing dragonfly result from: " + method);
			}
			if (preySkinner != null) {
				result = preySkinner.apply(result);
			}
			return result;
		}
	}
	
	public BãßBȍőnSpiderSilkHunt createSilkHunt(Class<? extends BãßBȍőnꝐḯŕ₳₮ḕʸᴰ> pirateClass, Method method, Function<Object, Object> preySkinner) {
		Objects.requireNonNull(pirateClass);
		Objects.requireNonNull(method);
		if (!method.trySetAccessible()) {
			throw new IllegalStateException("Can't access method: " + method);
		}
		Class<?>[] para = method.getParameterTypes();
		if (para.length == 0) {
			return new HuntMethod(pirateClass, method, preySkinner) {
				@Override
				public Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception {
					return method.invoke(pirate);
				}
			};
		}
		if (String.class.isAssignableFrom(para[0])) {
			if (para.length == 1) {
				return new HuntMethod(pirateClass, method, preySkinner) {
					@Override
					public Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception {
						return method.invoke(pirate, fly);
					}
				};
			}
			if (para.length == 2 && String.class.isAssignableFrom(para[1])) {
				return new HuntMethod(pirateClass, method, preySkinner) {
					@Override
					public Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception {
						return method.invoke(pirate, fly, name);
					}
				};
			}
			if (para.length == 3 && String.class.isAssignableFrom(para[2])) {
				return new HuntMethod(pirateClass, method, preySkinner) {
					@Override
					public Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception {
						return method.invoke(pirate, fly, name, description);
					}
				};
			}
		}
		if (Class.class.isAssignableFrom(para[0])) {
			if (para.length == 1) {
				return new HuntMethod(pirateClass, method, preySkinner) {
					@Override
					public Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception {
						return method.invoke(pirate, blood);
					}
				};
			}
			if (para.length == 2 && String.class.isAssignableFrom(para[1])) {
				return new HuntMethod(pirateClass, method, preySkinner) {
					@Override
					public Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception {
						return method.invoke(pirate, blood, fly);
					}
				};
			}
			if (para.length == 3 && String.class.isAssignableFrom(para[2])) {
				return new HuntMethod(pirateClass, method, preySkinner) {
					@Override
					public Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception {
						return method.invoke(pirate, blood, fly, name);
					}
				};
			}
			if (para.length == 4 && String.class.isAssignableFrom(para[3])) {
				return new HuntMethod(pirateClass, method, preySkinner) {
					@Override
					public Object dragonFlyInvoke(BãßBȍőnꝐḯŕ₳₮ḕʸᴰ pirate, Class<?> blood, String fly, String name, String description) throws Exception {
						return method.invoke(pirate, blood, fly, name, description);
					}
				};
			}
		}
		throw new IllegalStateException("Unsupported method parameters on: " + method);
	}
}