package com.framsticks.params;

import org.apache.log4j.Logger;

import com.framsticks.params.annotations.FramsClassAnnotation;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * Author: Piotr Śniegowski
 */
public class Registry {
	private static final Logger log = Logger.getLogger(Registry.class.getName());

	public static class DoubleSet<K1, K2, V> {
		protected final Map<K1, V> byId = new HashMap<>();
		protected final Map<K2, V> byName = new HashMap<>();
		protected final Set<V> values = new HashSet<>();

		public int size() {
			return values.size();
		}

		public void put(K1 id, K2 name, V value) {
			values.add(value);
			if (id != null) {
				byId.put(id, value);
			}
			if (name != null) {
				byName.put(name, value);
			}
		}

		public boolean containsValue(V value) {
			return values.contains(value);

		}

		public boolean containsKey(String identifier) {
			return byId.containsKey(identifier) || byName.containsKey(identifier);
		}

		public V get(String identifier) {
			if (byId.containsKey(identifier)) {
				return byId.get(identifier);
			}
			if (byName.containsKey(identifier)) {
				return byName.get(identifier);
			}
			return null;
		}

		public Set<V> getValues() {
			return Collections.unmodifiableSet(values);
		}
	}

	// protected void internalRegisterClass(FramsClass framsClass, @Nullable Class<?> javaClass) {
	// 	assert framsClass.getName() != null;
	// 	assert framsClass.getId() != null;
	// 	infoCacheByName.put(framsClass.getName(), framsClass);
	// 	infoCacheById.put(framsClass.getId(), framsClass);

	// 	if (javaClass != null) {
	// 		reflectedClasses.put(framsClass, javaClass);
	// 		infoCacheByJavaName.put(javaClass.getCanonicalName(), framsClass);
	// 	}
	// }
	protected final DoubleSet<String, String, Class<?>> javaClasses = new DoubleSet<>();
	protected final DoubleSet<String, String, FramsClass> framsClasses = new DoubleSet<>();

	public void registerReflectedClass(String name, String id, Class<?> reflectedClass) {
		javaClasses.put(id, name, reflectedClass);
	}

	public Registry register(Class<?> reflectedClass) {
		FramsClassAnnotation a = reflectedClass.getAnnotation(FramsClassAnnotation.class);
		if (a == null) {
			log.error("class is not annotated: " + reflectedClass);
			return this;
		}

		registerReflectedClass(FramsClassBuilder.getName(a, reflectedClass), FramsClassBuilder.getId(a, reflectedClass), reflectedClass);

		return this;
	}

	public AccessInterface createAccess(String name, FramsClass framsClass) throws ConstructionException {
		assert framsClasses.containsValue(framsClass);
		if (javaClasses.containsKey(name)) {
			return new ReflectionAccess(javaClasses.get(name), framsClass);
		}
		return new PropertiesAccess(framsClass);
	}

	public void putInfoIntoCache(FramsClass framsClass) {
		log.debug("caching info for " + framsClass);
		framsClasses.put(framsClass.getId(), framsClass.getName(), framsClass);
	}

	public FramsClass getInfoFromCache(String identifier) {
		if (identifier == null) {
			return null;
		}
		return framsClasses.get(identifier);
	}

	public static AccessInterface wrapAccessWithListIfNeeded(CompositeParam param, AccessInterface access) {
		if (access == null) {
			return null;
		}
		return param.prepareAccessInterface(access);
	}

	public AccessInterface prepareAccess(CompositeParam param) throws ConstructionException {
		return wrapAccessWithListIfNeeded(param, createAccess(param.getContainedTypeName()));
	}

	public AccessInterface createAccess(String name) throws ConstructionException {
		if (name == null) {
			return null;
		}
		FramsClass framsClass = getInfoFromCache(name);
		if (framsClass == null) {
			return null;
		}

		return createAccess(name, framsClass);
	}

	public Set<Class<?>> getReflectedClasses() {
		return javaClasses.getValues();
	}

	public Set<FramsClass> getInfoCache() {
		return framsClasses.getValues();
	}

}