package foundation.dao;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

import foundation.data.entity.Entity;
import foundation.data.entity.EntitySet;
import foundation.data.meta.field.FieldsRuntime;
import foundation.data.object.DataObject;
import foundation.util.ContentBuilder;
import foundation.util.Util;

public class PackageStringMap implements Map<String, String> {
	
	protected static Logger logger;
	public static String Spliter = "__";
	private DataPackage dataPackage;
	private String nullResult;
	private DataSource dataSource;
	private Map<String, String> aliasMap;
	private List<ReplaceObject> replaceList;

	
	static {
		logger = LogManager.getLogger(PackageStringMap.class);
	}
	
	public PackageStringMap(DataPackage dataPackage) {
		this.dataPackage = dataPackage;
		this.nullResult = null;
		this.dataSource = DataSource.DB;
	}
	
	public void setNullResult(String nullResult) {
		this.nullResult = nullResult;
	}
	
	public String onNullResult(String key) {
		if (nullResult == null) {
			return null;
		}
		
		logger.debug("get 【{}】, result is null", key);
		return nullResult;
	}

	@Override
	public int size() {
		return dataPackage.allItems.size();
	}

	@Override
	public boolean isEmpty() {
		return dataPackage.isEmpty(DataSource.DB);
	}

	@Override
	public boolean containsKey(Object key) {
		if (key == null) {
			return nullResult != null;
		}
		
		ValueName valueName = new ValueName(String.valueOf(key));
		PackageItem item = getPackageItem(valueName.itemName);
		
		if (item == null) {
			return nullResult != null;
		}
		
		try {
			DataObject dataObject = item.getDataObject();
			FieldsRuntime fields = dataObject.getTableFieldMetas();
			return fields.contains(valueName.fieldName) || (nullResult != null);
		}
		catch (Exception e) {
			return false;
		}
	}

	@Override
	public boolean containsValue(Object value) {
		return false;
	}

	@Override
	public String get(Object key) {
		if (key == null) {
			return nullResult;
		}
		
		String name = String.valueOf(key);
		ValueName valueName = new ValueName(name);
		PackageItem item = getPackageItem(valueName.itemName);
		
		if (item == null) {
			return onNullResult(name);
		}
		
		String result = null;
		
		if (item.isEntity(dataSource)) {
			Entity entity = item.getEntity(dataSource);
			result = getStringValue(entity, valueName.fieldName);
		}
		else if (item.isEntitySet(dataSource)) {
			ContentBuilder builder = new ContentBuilder("，");
			EntitySet entitySet = item.getEntitySet(dataSource);
			
			for (Entity entity: entitySet) {
				String value = entity.getString(valueName.fieldName);
				if (value == null) {
					value = onNullResult(name);
				}
				
				builder.append(value);
			}
			
			result = builder.toString();
		}
		
		if (result == null) {
			result = onNullResult(name);
		}
		
		return result;
	}
	
	private PackageItem getPackageItem(String itemName) {
		if (aliasMap != null) {
			String original = aliasMap.get(itemName);
			
			if (!Util.isEmpty(original)) {
				itemName = original; 
			}
		}
		
		PackageItem result = dataPackage.getItem(itemName);
		return result;
	}

	private String getStringValue(Entity entity, String fieldName) {
		if (Util.isEmpty(fieldName)) {
			return null;
		}
		
		if (replaceList != null) {
			for (ReplaceObject replace: replaceList) {
				fieldName = fieldName.replace(replace.original, replace.to);
			}
		}
		
		String result = entity.getString(fieldName);
		return result;
	}

	public void addAlias(String original, String alias) {
		if (Util.isEmpty(original) || Util.isEmpty(alias)) {
			return;
		}
		
		if (aliasMap == null) {
			synchronized (this) {
				if (aliasMap == null) {
					aliasMap = new HashMap<String, String>();
				}
			}
		}
		
		original = original.toLowerCase();
		aliasMap.put(alias, original);
	}

	public void addReplace(String original, String replace) {
		if (Util.isEmpty(original)) {
			return;
		}
		
		if (replaceList == null) {
			synchronized (this) {
				if (replaceList == null) {
					replaceList = new ArrayList<ReplaceObject>();
				}
			}
		}
		
		ReplaceObject object = new ReplaceObject(original, replace);
		replaceList.add(object);		
	}

	@Override
	public String put(String key, String value) {
		return value;
	}

	@Override
	public String remove(Object key) {
		return null;
	}

	@Override
	public void putAll(Map<? extends String, ? extends String> m) {
		
	}

	@Override
	public void clear() {
		
	}

	@Override
	public Set<String> keySet() {
		return null;
	}

	@Override
	public Collection<String> values() {
		return null;
	}

	@Override
	public Set<Entry<String, String>> entrySet() {
		return null;
	}
	
	public static class ValueName {
		
		private String itemName;
		private String fieldName;
		
		public ValueName(String name) {
			int pos = name.indexOf(Spliter);
			if (pos > 0) {
				itemName = name.substring(0, pos);
				fieldName = name.substring(pos + Spliter.length());
			}
		}
		
		public boolean isValid() {
			return !Util.isEmpty(itemName) && !Util.isEmpty(fieldName);
		}
	}
	
	public static class ReplaceObject {
		
		private String original;
		private String to;
		
		public ReplaceObject(String original, String to) {
			this.original = original;
			this.to = to;
		}
	}

}