package love.distributedrebirth.bassboon;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import love.distributedrebirth.bassboon.clazz.BãßBȍőnAuthor注;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnPirateLoader;
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ȍőnCoffin;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinDuytschenᵗˣᵗ;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinGhost;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinGhostSpell;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinGhostSpellLock;
import love.distributedrebirth.bassboon.death.spider.BãßBȍőnSpider;

/**
 * Runtime for static bass noise.
 */
@BãßBȍőnAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface Bãß {
	
	/**
	 * Sarcophagus aggregates Y-Dimensions.
	 */
	public static final class 石棺ʸᴰ {
		private static final Map<Object, BȍőnGrave> GRAVE_YARD = new WeakHashMap<>();
		private static final ReadWriteLock FUNERAL = new ReentrantReadWriteLock();
		private static final Lock FUNERAL_BIBLE = FUNERAL.readLock();
		private static final Lock FUNERAL_SHEMIRA = FUNERAL.writeLock();
		
		/**
		 * Sarcophagus is closed for humans.
		 */
		private 石棺ʸᴰ() {
		}
		
		/**
		 * Mononoke Init
		 */
		public static final <T extends BãßBȍőnʸᴰ<T>> void 魎ᴵⁿᶦᵗ(BãßBȍőnʸᴰ<T> boon) {
			挖ᵀᵒ(boon).init(boon);
		}
		
		/**
		 * Grave Lock
		 */
		public static final <T extends BãßBȍőnʸᴰ<T>> void 墳ᴸᵒᶜᵏ(BãßBȍőnʸᴰ<T> boon) {
			挖ᵀᵒ(boon).lock(boon);
		}
		
		/**
		 * Coffin Of
		 */
		protected static final <T extends BãßBȍőnʸᴰ<T>> BãßBȍőnCoffin 棺ᴼᶠ(BãßBȍőnʸᴰ<T> boon) {
			return 挖ᵀᵒ(boon);
		}
		protected static final <T extends BãßBȍőnʸᴰ<T>, G extends BãßBȍőnCoffinDuytschenᵗˣᵗ> G 棺ᴼᶠ(BãßBȍőnʸᴰ<T> boon, Class<G> duytschen) {
			return 挖ᵀᵒ(boon).ₜₒI18Nᵗˣᵗ(duytschen);
		}
		
		/**
		 * Dig To
		 */
		private static final <T extends BãßBȍőnʸᴰ<T>> BȍőnGrave 挖ᵀᵒ(BãßBȍőnʸᴰ<T> boon) {
			BȍőnGrave boonGrave = null;
			FUNERAL_BIBLE.lock();
			try {
				boonGrave = GRAVE_YARD.get(boon);
			} finally {
				FUNERAL_BIBLE.unlock();
			}
			if (boonGrave == null) {
				FUNERAL_SHEMIRA.lock();
				try {
					boonGrave = new BȍőnGrave();
					GRAVE_YARD.put(boon, boonGrave);
				} finally {
					FUNERAL_SHEMIRA.unlock();
				}
			}
			return boonGrave;
		}
		/*
		public static <T> BeanWrapper<T> 豆ᴺᴱᵂ(Class<T> seedling) { // bean-new
			try {
				T bean = seedling.getConstructor().newInstance();
				if (bean instanceof BãßBȍőnʸᴰ) {
					BãßBȍőnʸᴰ<?> boon = (BãßBȍőnʸᴰ<?>) bean;
					BȍőnGrave grave = 墳ᴼᶠ(boon);
					if (!grave.inited) {
						魎ᴵᴺᴵᵀ(boon);
					}
					return new BeanWrapper<>(bean);
				}
				return new BeanWrapper<>(bean);
			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
					| InvocationTargetException | NoSuchMethodException | SecurityException e) {
				throw new RuntimeException(e);
			}
		}
		
		public static final class BeanWrapper<T> implements DefaultBãßBȍőnʸᴰ<T>, BãßBȍőnSpiderCloak<T> {
			private final T bean;
			
			private BeanWrapper(T bean) {
				魎ᴵᴺᴵᵀ(this);
				this.bean = bean;
			}
			
			@Override
			public T getBean() {
				return bean;
			}
		}
		*/
		private static final class BȍőnGrave implements BãßBȍőnCoffin {
			private final Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> duytschenCoffins = new HashMap<>();
			private final Map<Class<?>,BãßBȍőnCoffinGhost> ghosts = new HashMap<>();
			private final BãßBȍőnSpider spider = new BãßBȍőnSpider();
			private boolean inited = false;
			private boolean locked = false;
			
			private BȍőnGrave() {
				BãßBȍőnCoffinDuytschenᵗˣᵗ.ײₚᵤₜI18Nᵗˣᵗײ(duytschenCoffins, this);
			}
			
			private <T extends BãßBȍőnʸᴰ<T>> void init(BãßBȍőnʸᴰ<T> boon) {
				if (inited) {
					return;
				}
				BãßBȍőnPirateLoader.INIT_BONE_MAGIC(boon, spider, duytschenCoffins);
				inited = true;
			}
			
			private <T extends BãßBȍőnʸᴰ<T>> void lock(BãßBȍőnʸᴰ<T> boon) {
				if (locked) {
					return;
				}
				BãßBȍőnPirateLoader.LOCK_BONE_MAGIC(boon, spider);
				for (Class<?> familyName:new ArrayList<>(ghosts.keySet())) {
					BãßBȍőnCoffinGhost ghost = ghosts.get(familyName);
					ghosts.put(familyName, BãßBȍőnCoffinGhostSpellLock.castᴼᶠ(ghost).LOCK());
				}
				locked = true;
			}
			
			@Override
			public BãßBȍőnCoffinGhost UNHOLY(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ<?>> familyName) {
				BãßBȍőnCoffinGhost ghost = ghosts.get(familyName);
				if (ghost == null) {
					if (locked) {
						throw new RuntimeException("Coffin locked");
					}
					ghost = BãßBȍőnCoffinGhostSpellLock.instanceᴺᵉʷ();
					ghosts.put(familyName, ghost);
				}
				return ghost;
			}
			
			@Override
			public BãßBȍőnCoffinGhostSpell UNHOLY_SPELL(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ<?>> familyName) {
				return BãßBȍőnCoffinGhostSpell.castᴼᶠ(UNHOLY(familyName));
			}
			
			@SuppressWarnings("unchecked")
			@Override
			public <T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T NOISE_OF(Class<T> noiseName) {
				try {
					return (T) spider.silkRoad(noiseName).senseWire(null, null, null); // rm args...
				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
					throw new RuntimeException(e);
				}
			}
			
			@SuppressWarnings("unchecked")
			private <G extends BãßBȍőnCoffinDuytschenᵗˣᵗ> G ₜₒI18Nᵗˣᵗ(Class<G> duytschen) {
				G result = (G) duytschenCoffins.get(duytschen);
				if (result == null) {
					throw new IllegalArgumentException("Unknown duytschen: "+duytschen);
				}
				return result;
			}
		}
	}
	
	//member static final class ℭỗᶇṧⱦᶏꬼȶʂ { // todo: jvm add death to "import static" name space pollution.
	public static final class ℭỗᶇṧⱦᶏꬼȶʂ {
		// 4 is magnetic consent and 3 is forced stable outcome
		public static final char CHAR_ZERO = '0';  // nothing
		public static final char CHAR_ONE = '1';   // all
		public static final char CHAR_SPACE = ' '; // eatherspace
		public static final char CHAR_ATARI = 'a'; // corner stone of creation 𐦠𐦴𐦫𐦢
		// the nether
		public static final String STR_ZERO = "0";  //String.valueOf(CHAR_ZERO);
		public static final String STR_ONE = "1";   //String.valueOf(CHAR_ONE);
		public static final String STR_EMPTY = "";  //STR_ONE.substring(Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE);
		public static final String STR_SPACE = " "; //String.valueOf(CHAR_SPACE);
		// red
		public static final int INT_ZERO = 0; //Integer.valueOf(STR_ZERO);
		public static final int INT_ONE = 1;  //Integer.valueOf(STR_ONE);
		public static final int INT_TEN = 10; //Integer.valueOf(STR_ONE+STR_ZERO);
		// white
		public static final long LONG_ZERO = 0l; //Long.valueOf(STR_ZERO);
		public static final long LONG_ONE = 1l;  //Long.valueOf(STR_ONE);
		public static final long LONG_TEN = 10l; //Long.valueOf(STR_ONE+STR_ZERO);
		// blue
		public static final float FLOAT_ZERO = 0f; //Float.valueOf(STR_ZERO);
		public static final float FLOAT_ONE = 1f;  //Float.valueOf(STR_ONE);
		public static final float FLOAT_TEN = 10f; //Float.valueOf(STR_ONE+STR_ZERO);
		// orange on top
		public static final double DOUBLE_ZERO = 0d; //Double.valueOf(STR_ZERO);
		public static final double DOUBLE_ONE = 1f;  //Double.valueOf(STR_ONE);
		public static final double DOUBLE_TEN = 10f; //Double.valueOf(STR_ONE+STR_ZERO);
		// and a bipolar flag pole
		public static final Object PTR_VOID = null;
		public static final Object PTR_OBJECT = new ℭỗᶇṧⱦᶏꬼȶʂ();
		// private is public ^^^
		private ℭỗᶇṧⱦᶏꬼȶʂ() {
		}
	}
}