package foundation.data.rule.exists;

import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import foundation.data.entity.Entity;
import foundation.data.entity.EntitySet;
import foundation.persist.NamedSQL;
import foundation.server.config.DBaseType;
import foundation.util.Util;

public class ExistsRule {

	private DBaseType dbaseType;
	private String id;
	private String name;
	private String dataName;
	private String targetTableName;
	private String selectField;
	private String filter;
	private String dateFrom;
	private String dateTo;
	private Set<String> filterFields;
	private NamedSQL templateSQL;
	
	
	public ExistsRule() {
		
	}
	
	public void load(Entity entity) throws Exception {
		id = entity.getString("id");
		name = entity.getString("name");
		dataName = entity.getString("data_name");
		targetTableName = entity.getString("target_table_name");
		selectField = entity.getString("select_field");
		filter = entity.getString("filter");
		dateFrom = entity.getString("date_from");
		dateTo = entity.getString("date_to");
		
		init(filter);
	}
	
	private void init(String filter) throws Exception {
		//1. 解析过滤条件（字段）filter Meta
		filterFields = new HashSet<String>();
		String field = "" ;
		
		if (Util.isEmpty(filter)) {
			return ;
		}
		
		Pattern paramsPattern = Pattern.compile("(?<=\\{)[^\\}]*(?=\\})");
		Matcher paramsMatcher = paramsPattern.matcher(filter);
		
		while (paramsMatcher.find()) {
			field = paramsMatcher.group();
			
			if (Util.isEmpty(field)) {
				continue;
			}
					
			filterFields.add(field);
		}
		
		//2. 创建SQL
		templateSQL = NamedSQL.getInstance(dbaseType, "getExistsEntity");
		templateSQL.setParam("selectField", selectField);
		templateSQL.setParam("tableName", targetTableName);
	}

	public EntitySet exec(Entity entity, EntitySet errorSet) throws Exception {
		//1. 根据模板创建运行时SQL
		NamedSQL namedSQL = templateSQL;

		//2. 将当前数据的过滤条件设置到SQL中
		String realFilter = concatDateExists(entity);
		
		if (!filterFields.isEmpty()) {
			NamedSQL filterSQL = new NamedSQL(dbaseType, realFilter);
			
			for (String field : filterFields) {
				filterSQL.setParam(field, entity.getString(field));
			}
			
			namedSQL.setParam("filter", filterSQL.toString());
		}
		else {
			namedSQL.setParam("filter", realFilter);
		}
		
		namedSQL.setParam("id", entity.getString("id"));		
			
		//3. 查询存在规则下的其他数据
		EntitySet entitySet = namedSQL.getEntitySet();			
		
		if (entitySet.isEmpty()) {
			return errorSet;
		}
		
		if (errorSet == null || errorSet.isEmpty()) {
			errorSet = entitySet;
		}
		else {
			for(Entity oneError : entitySet) {
				errorSet.append(oneError);
			}
		}
		
		return errorSet;
	}

	private String concatDateExists(Entity entity) {
		String realFilter = filter;
		String dateFromValue = "", dateToValue = "";
		
		if(Util.isEmpty(dateFrom) && Util.isEmpty(dateTo)) {
			return realFilter;
		}
		
		realFilter = realFilter + " and ( ";		
		
		if (!Util.isEmpty(dateFrom)) {
			dateToValue = entity.getString(dateTo);
			realFilter = realFilter + dateFrom + " < " + Util.quotedStr(dateToValue);
		}else {
			realFilter = realFilter + " 1 <> 1 ";
		}
		
		realFilter = realFilter + " or ";
		 
		if (!Util.isEmpty(dateTo)) {
			dateFromValue = entity.getString(dateFrom);
			realFilter = realFilter + dateTo + " > " + Util.quotedStr(dateFromValue);
		}else {
			realFilter = realFilter + " 1 <> 1 ";
		}

		realFilter = realFilter + ") ";
		
		return realFilter;
	}

	public String getName() {
		return name;
	}

	public String getDataName() {
		return dataName;
	}

	public String getTargetTableName() {
		return targetTableName;
	}

	public String getSelectField() {
		return selectField;
	}

	public String getFilter() {
		return filter;
	}

	public String getDateFrom() {
		return dateFrom;
	}

	public String getDateTo() {
		return dateTo;
	}

	public void setDBaseType(DBaseType dbaseType) {
		this.dbaseType = dbaseType;
	}

	public String getId() {
		return id;
	}
	
}