package foundation.object.reader;

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

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public abstract class EntityReader implements IEntityReader {

	protected static Logger logger;
	protected static Set<String> excludeMethods;
	private static Map<Class<?>, ObjectReader> objectReadercontainer;
	private static Map<Class<?>, MapReader> mapReaderContainer;
	private static Map<Class<?>, CollectionReader> collectionReaderContainer;
	protected Class<?> clazz;

	
	static {
		logger = LogManager.getLogger(ObjectReader.class);
		createExcludeMethodSet();
		
		objectReadercontainer = new HashMap<Class<?>, ObjectReader>();
		mapReaderContainer = new HashMap<Class<?>, MapReader>();
		collectionReaderContainer = new HashMap<Class<?>, CollectionReader>();
	}

	protected EntityReader(Class<?> clazz) {
		this.clazz = clazz;
	}

	public static IEntityReader getInstance(Class<?> clazz) throws Exception {
		if (Collection.class.isAssignableFrom(clazz)) {
			return getCollectionInstance(clazz);
		} 
		else if (Map.class.isAssignableFrom(clazz)) {
			return getMapInstance(clazz);
		} 
		else {
			return getObjectInstance(clazz);
		}
	}

	public static ObjectReader getObjectInstance(Class<?> clazz) throws Exception {
		ObjectReader result = objectReadercontainer.get(clazz);
		
		if (result == null) {
			synchronized (objectReadercontainer) {
				result = objectReadercontainer.get(clazz);
				
				if (result == null) {
					result = new ObjectReader(clazz);
					objectReadercontainer.put(clazz, result);
				}
			}
		}
		
		return result;
	}
	
	public static MapReader getMapInstance(Class<?> clazz) throws Exception {
		MapReader result = mapReaderContainer.get(clazz);
		
		if (result == null) {
			synchronized (mapReaderContainer) {
				result = mapReaderContainer.get(clazz);
				
				if (result == null) {
					result = new MapReader(clazz);
					mapReaderContainer.put(clazz, result);
				}
			}
		}
		
		return result;
	}
	
	public static CollectionReader getCollectionInstance(Class<?> clazz) throws Exception {
		CollectionReader result = collectionReaderContainer.get(clazz);
		
		if (result == null) {
			synchronized (collectionReaderContainer) {
				result = collectionReaderContainer.get(clazz);
				
				if (result == null) {
					result = new CollectionReader(clazz);
					collectionReaderContainer.put(clazz, result);
				}
			}
		}
		
		return result;
	}

	protected abstract void initValueReader(Class<?> dataType) throws Exception;

	public abstract String getString(Object entity);

	public abstract String getJSONString(Object entity) throws Exception;

	public Class<?> getEntityClass() {
		return clazz;
	}

	private static void createExcludeMethodSet() {
		excludeMethods = new HashSet<String>();
		excludeMethods.add("getclass");
		excludeMethods.add("getnames");
		excludeMethods.add("getsize");
		excludeMethods.add("containsproperty");
		excludeMethods.add("loaddata");
		excludeMethods.add("setdata");
		excludeMethods.add("setdataString");
		excludeMethods.add("getdata");
		excludeMethods.add("getString");
		excludeMethods.add("getjsonString");
		excludeMethods.add("getsqlString");
		excludeMethods.add("getvalue");
		excludeMethods.add("getdynamicdata");
		excludeMethods.add("iterator");
		excludeMethods.add("toString");
		excludeMethods.add("finalize");
		excludeMethods.add("wait");
		excludeMethods.add("hashcode");
		excludeMethods.add("clone");
		excludeMethods.add("registernatives");
		excludeMethods.add("equals");
		excludeMethods.add("notify");
		excludeMethods.add("notifyall");
		excludeMethods.add("getinstance");
	}

}