package foundation.data.entity;

import java.math.BigDecimal;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

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

import foundation.data.meta.field.Field;
import foundation.data.meta.field.FieldWriter;
import foundation.data.meta.field.FieldsRuntime;
import foundation.json.IJSONProvider;
import foundation.json.IJSONWriter;
import foundation.server.config.DBaseType;
import foundation.translator.ITranslator;
import foundation.translator.StringTranslator;
import foundation.translator.Translator;
import foundation.translator.ValueType;
import foundation.util.ContentBuilder;
import foundation.util.IEntity;
import foundation.util.Util;
import foundation.variant.provider.DataEvent;
import foundation.variant.provider.IVariantsConsumer;
import foundation.variant.provider.IVariantsProvider;
import foundation.variant.provider.VariantLink;
import foundation.variant.provider.VariantProviderType;


public class Entity implements IEntity, IVariantsConsumer, IVariantsProvider, IJSONProvider {

	protected static Logger logger; 
	public static String ProviderName = "entity";
	protected boolean deleted = false;
	protected FieldsRuntime fieldsMeta;
	protected Object[] dataArray;
	protected LineOperator operator;
	public SelectState selectState;

	static {
		logger = LogManager.getLogger(Entity.class);
	}
	
	public Entity(FieldsRuntime fieldsMeta) {
		this.fieldsMeta = fieldsMeta;
		dataArray = new Object[fieldsMeta.getFieldCount()];
		this.operator = LineOperator.None;
		this.selectState = SelectState.Unselect;
	}
 
	public void load(DataEvent dataEvent, IVariantsProvider entity) throws Exception {
		VariantLink.overWriteOnConsumer(dataEvent, this, entity);		
	}

	public void copyFrom(Entity from) {
		if (from == null) {
			return;
		}
		
		Object[] source = from.dataArray;
		int max = source.length;
		
		for (int i = 0; i < max; i++) {
			Object value = source[i];
			
			if (value == null) {
				continue;
			}
			
			dataArray[i] = source[i];
		}
	}

	public EntityChange getChange(Entity original) {
		Entity change = new Entity(fieldsMeta);
		EntityChange result = new EntityChange(change);
		
		boolean changed = false;
		int max = fieldsMeta.size();
		
		//1. 如果 original 为空，返回当前 entity 所有数据
		if (original == null) {
			for (int i = 0; i < max; i++) {
				Object value = getValue(i);
				
				if (value == null) {
					continue;
				}
				
				change.set(i, value);
			}
			
			result.setChangeType(ChangeType.Inserted);
			return result;
		}
		
		//2. 如果 original 不为空，对比 entity
		for (int i = 0; i < max; i++) {
			Object value = getFieldTypeValue(i);
			Object anotherValue = original.getFieldTypeValue(i);
			
			if (value == null) {
				if (anotherValue == null) {
					continue;
				}
				else {
					changed = true;
					change.set(i, anotherValue);
				}
			}
			else {
				if (value.equals(anotherValue)) {
					continue;
				}
				
				changed = true;
				change.set(i, anotherValue);
			}
		}
		
		//3. 如果结果是有变化，就设置 Changed
		if (changed) {
			result.setChangeType(ChangeType.Changed);
		}
		
		//4. 如果结果是没有变化，就复制原数据，设置 NoChanged
		else {
			change.copyFrom(this);
			result.setChangeType(ChangeType.NoChanged);
		}
		
		change.set("id", getString("id"));
		
		return result;
	}

	public void set(int i, Object object) {
		dataArray[i] = object;
	}

	public Entity set(String name, Object value) {
		try {
			Integer idx = fieldsMeta.getIndex(name);
			
			if (idx == null) {
				return this;
			}
			
			if (value == null) {
				dataArray[idx] = null;
			}
			else {
				ITranslator translator = fieldsMeta.getTranslator(idx);
				Object obj = Translator.toTranslatorTypeValue(value, translator.getDataClass());
				dataArray[idx] = obj;
			}
		}
		catch (Exception e) {
			e.printStackTrace();
		}
		
		return this;
	}

	public Object[] getDataArray() {
		return dataArray;
	}

	public String getId() {
		return getString("id");
	}
	
	public void setId(String id) throws Exception {
		set("id", id);
	}

	public String getParentId() {
		return getString("parent_id");
	}
	
	public Object getVarinatValue(String field) {
		int idx = fieldsMeta.getIndex(field);
		return dataArray[idx];
	}
	
	public ValueType getValueType(int idx) {
		return fieldsMeta.getValueType(idx);
	}
	
	public Object getValue(int idx) {
		return dataArray[idx];
	}
	
	public Object getValue(String fieldName) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return null;
		}
		
		return dataArray[idx];
	}
	
	public Object getFieldTypeValue(int idx) {
		Object result = null;
		
		try {
			Object value = dataArray[idx];
			ITranslator translator = fieldsMeta.getTranslator(idx);
			result = translator.toTranslatorTypeValue(value);
		}
		catch (Exception e) {
		}
		
		return result;
	}

	public String getString(String fieldName) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return null;
		}
		
		return getString(idx, null);
	}
	
	public String getString(int idx) {
		try {
			Object value = dataArray[idx];
			ITranslator translator = fieldsMeta.getTranslator(idx);
			String result = translator.toString(value);
			
			if (Util.isEmpty(result)) {
				result = null;
			}
			
			return result;
		}
		catch (Exception e) {
			return null;
		}
	}

	public String getString(String fieldName, String defaultValue) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) { 
			return defaultValue;
		}
		
		return getString(idx, defaultValue);
	}

	public String getString(int idx, String defaultValue) {
		try {
			Object value = dataArray[idx];
			ITranslator translator = fieldsMeta.getTranslator(idx);
			String result = translator.toString(value);
			
			if (Util.isEmpty(result)) {
				result = defaultValue;
			}
			
			return result;
		}
		catch (Exception e) {
			return defaultValue;
		}
	}
	
	public String getQuotedString(String fieldName) {
		int idx = fieldsMeta.getIndex(fieldName);
		return getQuotedString(idx, null);
	}

	public String getQuotedString(String fieldName, String defaultValue) {
		int idx = fieldsMeta.getIndex(fieldName);
		return getQuotedString(idx, defaultValue);
	}
	
	public String getQuotedString(int idx, String defaultValue) {
		String result = getString(idx, defaultValue);
		return Util.quotedStr(result);
	}
	
	public String getJSONString(String fieldName) throws Exception {
		int idx = fieldsMeta.getIndex(fieldName);
		return getJSONString(idx);
	}
	
	public String getJSONString(String fieldName, String defaultValue) {
		int idx = fieldsMeta.getIndex(fieldName);
		return getJSONString(idx, defaultValue);
	}
	
	public String getJSONString(int idx, String defaultValue) {
		try {
			return getJSONString(idx);
		}
		catch (Exception e) {
			e.printStackTrace();
			return "\"error\"";
		}
	}
	
	public String getJSONString(int idx) throws Exception {
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		
		if (translator == null) {
			translator = new StringTranslator();
		}
		
		return translator.toJSONString(value);
	}
	
	public String getSQLString(DBaseType dbaseType, String fieldName) throws Exception {
		return getSQLString(dbaseType, fieldName, "");
	}
	
	public String getSQLString(DBaseType dbaseType, String fieldName, String defaultValue) throws Exception {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return defaultValue;
		}
		
		try {
			String result = getSQLString(dbaseType, idx);
			return result;
		}
		catch(Exception e) {
			return defaultValue;
		}
	}
	
	public String getSQLString(DBaseType dbaseType, int idx) throws Exception {
		Object value = dataArray[idx];
		
		if ((ValueType.Null == value) || (value == null)) {
			return "null";
		}
		
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toSqlString(dbaseType, value);
	}
	
	public String getSQLString(DBaseType dbaseType, int idx, String defaultValue) {
		try {
			String result = getSQLString(dbaseType, idx);
			return result;
		}
		catch(Exception e) {
			return defaultValue;
		}
	}
	
	public String getSchemaString(String fieldName) throws Exception {
		int idx = fieldsMeta.getIndex(fieldName);
		return getSchemaString(idx);
	}
	
	public String getSchemaString(int idx) throws Exception {
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toSchemaString(value);
	}

	public boolean getBoolean(String fieldName) throws Exception {
		int idx = fieldsMeta.getIndex(fieldName);
		return getBoolean(idx, false);
	}
	
	public boolean getBoolean(String fieldName, boolean defaultValue) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return defaultValue;
		}
		
		return getBoolean(idx, defaultValue);
	}	
	
	public boolean getBoolean(int idx, boolean defaultValue) {
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toBoolean(value, defaultValue);
	}
	
	public Date getDate(String fieldName) throws Exception {
		int idx = fieldsMeta.getIndex(fieldName);
		return getDate(idx, null);
	}
	
	public Date getDate(String fieldName, Date defaultValue) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return defaultValue;
		}
		
		try {
			return getDate(idx, defaultValue);
		}
		catch (Exception e) {
			return defaultValue;
		}
	}	
	
	public Date getDate(int idx, Date defaultValue) throws Exception {
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toDate(value, defaultValue);
	}
	
	public Date getDateTime(int idx, Date defaultValue) throws Exception {
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toDate(value, defaultValue);
	}

	public int getInt(String fieldName) throws Exception {
		int idx = fieldsMeta.getIndex(fieldName);
		return getInt(idx, 0);
	}
	
	public Integer getInteger(String fieldName, Integer defaultValue) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return defaultValue;
		}
		
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toInteger(value, defaultValue);	
	}
	
	public Integer getInt(int idx, Integer defaultValue) {
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toInteger(value, defaultValue);
	}
	
	public BigDecimal getBigDecimal(String fieldName) throws Exception {
		int idx = fieldsMeta.getIndex(fieldName);
		return getBigDecimal(idx, BigDecimal.ZERO);
	}
	
	public BigDecimal getBigDecimal(String fieldName, BigDecimal defaultValue) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return defaultValue;
		}
		
		return getBigDecimal(idx, defaultValue);
	}
	
	public BigDecimal getBigDecimal(int idx, BigDecimal defaultValue) {
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toBigDecimal(value, defaultValue);
	}
	
	public double getDouble(String fieldName) throws Exception {
		int idx = fieldsMeta.getIndex(fieldName);
		return getDouble(idx, 0);
	}
	
	public double getDouble(String fieldName, double defaultValue) {
		int idx = fieldsMeta.getIndex(fieldName);
		return getDouble(idx, defaultValue);
	}
	
	public double getDouble(int idx, double defaultValue) {
		Object value = dataArray[idx];
		ITranslator translator = fieldsMeta.getTranslator(idx);
		return translator.toDouble(value, defaultValue);
	}

	public String getSQLTypeCode(String typeField, String lengthField) {
		Object type = getValue(typeField);
		Object length = getValue(lengthField);
		
		return Translator.toSQLTypeCode(type, length);
	}

	public String getSQLNullCode(String fieldName) {
		Object nullable = getValue(fieldName);
		return Translator.toSQLNullCode(nullable);
	}

	public int getFieldCount() {
		return fieldsMeta.getFieldCount();
	}

	public String[] getLowerNames() {
		return fieldsMeta.getLowerNames();
	}

	public FieldsRuntime getFieldsMeta() {
		return fieldsMeta;
	}
	
	public boolean isAbsentValue(String fieldName) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return true;
		}
		
		return isAbsentValue(idx);
	}

	public boolean existsEmptyValue(String... fieldNames) {
		for (String fieldName: fieldNames) {
			if (isEmptyValue(fieldName)) {
				return true;
			}
		}
		
		return false;
	}
	
	public boolean isEmptyValue(String fieldName) {
		Integer idx = fieldsMeta.getIndex(fieldName);
		
		if (idx == null) {
			return true;
		}
		
		return isEmptyValue(idx);
	}
	
	public boolean isAbsentValue(int idx) {
		Object value = dataArray[idx];
		return value == null;
	}
	
	public boolean isEmptyValue(int idx) {
		Object value = dataArray[idx];
		
		if (ValueType.Null == value) {
			return true;
		}
		
		return Util.isEmpty(value);
	}

	@Override
	public Set<String> getVariantNames() {
		Set<String> result = new HashSet<String>();
		
		String[] lowerNames = fieldsMeta.getLowerNames();
		
		for (String name: lowerNames) {
			result.add(name);
		}
		
		return result;
	}

	@Override
	public boolean containsVariant(String name) {
		return fieldsMeta.contains(name);
	}

	public void setVariant(DataEvent dataEvent, String name, Object value) throws Exception {
		set(name, value);
	}
	
	public boolean valueEquals(String field, Object anotherValue) {
		Object value = getVarinatValue(field);
		
		if (value == null) {
			if (anotherValue == null) {
				return true;
			}
			
			return false;
		}
		
		if (anotherValue == null) {
			return false;
		}
		
		String valueStr = Translator.toString(value, "");
		String anotherStr = Translator.toString(anotherValue, "");
		return valueStr.equalsIgnoreCase(anotherStr);
	}

	public boolean isEmpty() {
		for (int i = 0; i < dataArray.length; i++) {
			if (dataArray[i] != null) {
				return false;
			}
		}
		
		return true;
	}

	public void setDeleted() {
		deleted = true;
	}

	public boolean isDeleted() {
		return deleted;
	}
	
	@Override
	public void setVariants(DataEvent dataEvent, IVariantsProvider... providers) throws Exception {
		VariantLink.overWriteOnConsumer(dataEvent, this, providers);
	}

	@Override
	public Object getVariantValue(DataEvent dataEvent, String name) {
		return getValue(name);
	}

	@Override
	public boolean isVariantNull(String name) {
		return isEmptyValue(name);
	}

	public boolean contains(String fieldName) {
		return fieldsMeta.contains(fieldName);
	}

	@Override
	public String getProviderName() {
		return "entity";
	}

	@Override
	public VariantProviderType getProviderType() {
		return VariantProviderType.Transiant;
	}
	
	public void setOperator(LineOperator operator) {
		this.operator = operator;
	}

	public LineOperator getOperator() {
		return operator;
	}
	
	@Override
	public String toString() {
		ContentBuilder result = new ContentBuilder(", ");
		
		int max = dataArray.length;
		
		for (int i = 0; i < max; i++) {
			result.append(dataArray[i]);
		}
		
		return result.toString();
	}

	@Override
	public void writeJSON(IJSONWriter writer) {
		writer.beginObject();
		writeJSONBody(writer);
		writer.endObject();		
	}
	
	public void writeJSONBody(IJSONWriter writer) {
		FieldWriter fieldWriter;
		
		for (Field field: fieldsMeta) {
			fieldWriter = field.getWriter();
			fieldWriter.write(dataArray, writer, true);
		}
	}

}