package foundation.dao;

import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.json.JSONArray;

import foundation.data.meta.field.Field;
import foundation.data.meta.field.FieldsRuntime;
import foundation.json.JArrayReader;
import foundation.json.JSONReader;
import foundation.json.JType;
import foundation.server.config.DBaseType;
import foundation.translator.ITranslator;
import foundation.translator.Translator;
import foundation.translator.ValueType;
import foundation.util.ContentBuilder;
import foundation.util.ID;
import foundation.util.MapList;
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 Filter implements IVariantsConsumer, IVariantsProvider, Iterable<FilterItem> {

	public static final Filter All = new Filter();
	public static String ProviderName = "filter";
	private DBaseType dbaseType;
	private Set<String> VariantNames;
	private FieldsRuntime entityMeta;
	private MapList<String, FilterItem> items;
	private String rawFilter;
	private boolean raw = false;
	private boolean empty;
	private Set<Object> marks;

	
	public Filter() {
		this(DBaseType.getMain());
	}
	
	public Filter(DBaseType dbaseType) {
		this.dbaseType = dbaseType;
		items = new MapList<String, FilterItem>();
    	VariantNames = new HashSet<String>();
    	VariantNames.add("filter");
	}
	
	public Filter(String filter) {
		this(DBaseType.getMain(), filter);
	}
	
	public Filter(DBaseType dbaseType, String filter) {
		this.dbaseType = dbaseType;
		items = new MapList<String, FilterItem>();
    	VariantNames = new HashSet<String>();
    	VariantNames.add("filter");
		rawFilter = filter;
		raw = true;
	}
	
	public Filter(String fieldName, String value) {
		this();
		add(fieldName, "=", Util.quotedStr(value));
	}
	
	public Filter(DBaseType dbaseType, String fieldName, String value) {
		this(dbaseType);
		add(fieldName, "=", Util.quotedStr(value));
	}
	
	public Filter(String fieldName, int value) {
		this();
		add(fieldName, "=", String.valueOf(value));
	}
	
	public Filter(DBaseType dbaseType, String fieldName, int value) {
		this(dbaseType);
		add(fieldName, "=", String.valueOf(value));
	}
	
	public Filter(String fieldName, Date date) throws Exception {
		this(DBaseType.getMain(), fieldName, date);
	}
	
	public Filter(DBaseType dbaseType, String fieldName, Date date) throws Exception {
		this(dbaseType);
		add(fieldName, "=", Translator.toSqlString(dbaseType, date));
	}
	
	public Filter(String fieldName, String operator, String value) {
		this();
		add(fieldName, operator, value);
	}
	
	public Filter(DBaseType dbaseType, String fieldName, String operator, String value) throws Exception {
		this(dbaseType);
		add(fieldName, operator, value);
	}

	public Filter addAll(FieldsRuntime entityMeta, Set<String> excludeNames, IVariantsProvider...valueProviders) throws Exception {
		this.entityMeta = entityMeta;
		
		for (int i = 0; i < valueProviders.length; i++) {
			IVariantsProvider provider = valueProviders[i];
			VariantLink.moveOnConsumer(null, provider, this, excludeNames);
		}
		
		return this;
	}
	
	public Filter addAll(Filter other) {
		if (other == null) {
			return this;
		}
		
		for (FilterItem item: other) {
			items.add(item.getFieldName(), item);
		}
		
		if (other.isRaw()) {
			this.rawFilter = other.rawFilter;
			this.raw = other.raw;
		}
		
		return this;
	}
	
	public Filter add(DataReader dataReader) { 
		Object filterObject = dataReader.getValue("filter");
		if (filterObject instanceof String) {
			this.add(String.valueOf(filterObject));
			return this;
		}
		
		if (filterObject instanceof JSONArray) {
			JArrayReader jsonArray = dataReader.getReader("filter", JType.Array);
			
			for (JSONReader jsonObject: jsonArray) {
				 this.add(jsonObject.getString("field"), jsonObject.getString("operator"), Util.quotedStr(jsonObject.getString("value")));
			}
			return this;
		}
		
		return this;
	}	

	public Filter add(String segment) {
		if (Util.isEmpty(segment)) {
			return this;
		}
		
		FilterItem item = new FilterItem(segment);
		items.add(ID.newValue(), item);
		
		return this;
	}
	
	public Filter add(String fieldName, String value) {
		if (value == null) {
			this.add(fieldName, "is", "null");
			return this;
		}
		
		this.add(fieldName, "=", Util.quotedStr(value));
		return this;
	}
	
	public Filter add(String fieldName, Object value) {
		if (value == null) {
			this.add(fieldName, "is", "null");
			return this;
		}
		
		this.add(fieldName, "=", String.valueOf(value));
		return this;
	}
	
	public Filter add(String fieldName, String operator, String value) {
		if (Util.isEmpty(fieldName)) {
			return this;
		}
		
		if (Util.isEmpty(operator)) {
			operator = "=";
		}
		
		operator = operator.trim().toLowerCase();
		
		if ("like".equals(operator)) {
			if (value.indexOf("%") < 0) {
				value = "%" + value + "%";
			}
		}
		else if ("in".equals(operator)) {
			if (value.startsWith("'")) {
				value = value.substring(1);
			}
			if (value.endsWith("'")) {
				value = value.substring(0, value.length() - 1);
			}
		}
		
				
		FilterItem item = new FilterItem(fieldName, operator, value);
		items.add(fieldName, item);
		
		VariantNames.add(fieldName.toLowerCase());
		
		return this;
	}

	@Override
	public void setVariant(DataEvent dataEvent, String name, Object value) throws Exception {
		if (value == null) {
			return;
		}
		
		if (entityMeta == null) {
			throw new Exception("filter entityMeta is null");
		}
		
		if(!entityMeta.contains(name)) {
			return;
		}
		Field field = entityMeta.get(name);
		
		if (field == null) {
			return;
		}
		
		ITranslator translator = field.getValueTranslator();
		ValueType type = field.getType();
		
		if (ValueType.String == type) {
			String stringValue = value.toString();
			String segmentValue = null;
			
			//1. like
			if (stringValue.startsWith("(like)")) {
				if (stringValue.endsWith("(like)")) {
					//1.1 all like
					segmentValue = "'%" + stringValue.substring(7, stringValue.length() - 6) + "%'";
					add(name, "like", segmentValue);
				}
				else {
					//1.2 left like
					segmentValue = "'%" + stringValue.substring(7) + "'";
					add(name, "like", segmentValue);
				}
			}
			else if (stringValue.endsWith("(like)")) {
				//1.3 right like
				segmentValue = "'" + stringValue.substring(0, stringValue.length() - 6) + "%'";
				add(name, "like", segmentValue);
			}
			else {
				//1.3 no like
				segmentValue = "'" + stringValue + "'";
				add(name, "=", segmentValue);
			}
		}
		else {
			String segmentValue = translator.toSqlString(dbaseType, value);
			add(name, "=", segmentValue);
		}
	}
	
	@Override
	public void setVariants(DataEvent dataEvent, IVariantsProvider... providers) throws Exception { 
		if (providers == null || providers.length == 0) {
			return;
		}
		
		Set<String> keySet = items.keySet();
		
		for (String key: keySet) {
			for (IVariantsProvider provider: providers) {
				if (provider.containsVariant(key)) {
					FilterItem item = items.get(key);
					Object value = provider.getVariantValue(dataEvent, key);
					
					if (!Util.isEmpty(value)) {
						item.setValue(String.valueOf(value));
					}
				}
			}
		}
	}
	
	@Override
	public boolean isVariantNull(String name) {
		return empty;
	}
	
	public FilterItem getItemByName(String name) {
		if (items == null) {
			return null;
		}
		return items.get(name);
	}
	
	public FilterItem removeItemByName(String name) {
		if (items == null) {
			return null;
		}
		return items.remove(name);
	}
	
	public boolean isRaw() {
		return raw;
	}
	
	public String getRawFilter() {
		return rawFilter;
	}

	public boolean isEmpty() {
		return items.isEmpty() && Util.isEmpty(rawFilter);
	}

	public boolean containsSlaveTables(String... tableNames) {
		String sql = toString();
		
		if (Util.isEmpty(sql) || tableNames == null || tableNames.length == 0) {
			return false;
		}
		
		sql = sql.toLowerCase();
		int max = tableNames.length;
		
		for (int i = 0; i < max; i++) {
			String tableName = tableNames[i];
			
			if (Util.isEmpty(tableName)) {
				continue; 
			}
			
			tableName = tableName.toLowerCase() + ".";
			
			if (sql.indexOf(tableName) >= 0) {
				return true;
			}
		}
		
		return false;
	}
	
	public synchronized void addMark(Object mark) {
		if (marks == null) {
			marks = new HashSet<Object>();
		}
		
		marks.add(mark);
	}
	
	public boolean containsMark(Object mark) {
		if (marks == null || mark == null) {
			return false;
		}
		
		return marks.contains(mark);
	}

	@Override
	public String toString() {
		if (raw) {
			return rawFilter;
		}
		
		if (items.isEmpty()) {
			return "1=1";
		}
		
		ContentBuilder result = new ContentBuilder(" and ");
		Set<String> keySet = items.keySet();
		for (String key : keySet) {
			FilterItem filterItem = items.get(key);
			result.append(filterItem.toSQLString());
		}
		
		if (result.isEmpty()) {
			result.append(" 1 = 1 ");
		}
		
		return "(" + result + ")";
	}

	@Override
	public String getProviderName() {
		return ProviderName;
	}

	@Override
	public VariantProviderType getProviderType() {
		return VariantProviderType.Transiant;
	}
	
	@Override
	public boolean containsVariant(String name) {
		if (name == null) {
			return false;
		}
		
		return VariantNames.contains(name);
	}

	@Override
	public Object getVariantValue(DataEvent dataEvent, String name) {
		if ("filter".equalsIgnoreCase(name)) {
			return toString();
		}
		
		FilterItem item = items.get(name);
		
		if (item == null) {
			return null;
		}
		
		return item.getValue();
	}

	@Override
	public Set<String> getVariantNames() {
		return VariantNames;
	}
	
	@Override
	public Iterator<FilterItem> iterator() {
		return items.iterator();
	}
}