package foundation.io.define;

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

import foundation.dao.Filter;
import foundation.dao.OrderBy;
import foundation.data.object.DataObject;
import foundation.io.mapping.FieldMappingRuntime;
import foundation.io.mapping.MappingsRuntime;
import foundation.persist.ISQLContext;
import foundation.persist.NamedSQL;
import foundation.util.ContentBuilder;
import foundation.util.Util;

public class IOSQLContext implements ISQLContext {
	
	private List<String> paramNames;
	private Map<String, String> paramMap;
	private DataIO dataIO;
	private MappingsRuntime mainMappingsRuntime;
	private MappingsRuntime toMappingsRuntime;
	private Filter dynamicFilter;
	private Filter userFilter;
	private String ioBatchId;
	

	public IOSQLContext(DataIO dataIO) {
		this.paramMap = new HashMap<String, String>();
		this.dataIO = dataIO;
		initParamNames();
	}
	
	public IOSQLContext(IOTask fileIO) {
		this.paramMap = new HashMap<String, String>();
		initParamNames();
	}
	
	public void setParametersTo(NamedSQL namedSQL) {
        for (String name : paramNames) {
            if (namedSQL.containsVariant(name)) {
                String value = getParameter(name);

                if (value == null) {
                    continue;
                }

                namedSQL.setParam(name, value);
            }
        }
    }
	
	public void addOneParameter(String name, String value) {
		if (Util.isEmpty(name)) {
			return;
		}
		
		String lower = name.toLowerCase();
		
		if (!paramMap.containsKey(lower)) {
			paramNames.add(name);
		}
		
		paramMap.put(lower, value);
	}
	
	public String getParameter(String name) {
        if (Util.isEmpty(name)) {
            return name;
        }

        try {
            name = name.toLowerCase();

            if ("toTable".equalsIgnoreCase(name)) {
                return dataIO.getToName();
            }
            else if ("toTempTable".equalsIgnoreCase(name)) {
                return dataIO.getToTempName();
            }       
            else if ("fromTable".equalsIgnoreCase(name)) {
                return dataIO.getFromName();
            }
            else if ("distinct".equalsIgnoreCase(name)) {
                return dataIO.isDistinctSelect() ? "distinct" : "";
            }
            else if ("insertToFieldNames".equalsIgnoreCase(name)) {
            	return getInsertToFieldNames();
            }
            else if ("insertToPlaceHolders".equalsIgnoreCase(name)) {
            	return insertToPlaceHolders();
            }
            else if ("insertFromFieldNames".equalsIgnoreCase(name)) {
            	return getInsertFromFieldNames();
            }
            else if ("insertFromToTempFieldNames".equalsIgnoreCase(name)) {
            	return insertFromToTempFieldNames();
            } 
            else if ("keyFieldPairs".equalsIgnoreCase(name)) {
                return getKeyFieldPairs();
            }
            else if ("filterFieldValues".equalsIgnoreCase(name)) {
                return getFilterFieldValues();
            }
            else if ("updateFieldPairs".equalsIgnoreCase(name)) {
                return getUpdateFieldPairs();
            }        
            else if ("updateFromFieldNames".equalsIgnoreCase(name)) {
                return getUpdateFromFieldNames();
            }
            else if ("selectFromFieldNames".equalsIgnoreCase(name)) {
                return getSelectFromFieldNames();
            }   
            else if ("orderBy".equalsIgnoreCase(name)) {
                return getOrderBy();
            }
            else if ("dynamicFilter".equalsIgnoreCase(name)) {
                return getDynamicFilter();
            }
            else if ("userFilter".equalsIgnoreCase(name)) {
                return getUserFilter();
            }
            else if ("ioBatchId".equalsIgnoreCase(name)) {
                return ioBatchId;
            }
            else if (paramMap.containsKey(name)) {
                return paramMap.get(name);
            }
            else if("taskName".equalsIgnoreCase(name)) {
            	return dataIO.getTaskName();
            }
        }
        catch (Exception e) {
        	e.printStackTrace();
		}

        return null;
    }
    
	private String getInsertToFieldNames() throws Exception {
    	ContentBuilder builder = new ContentBuilder(", ");
    	MappingsRuntime mappingsRuntime = toMappingsRuntime;

    	for (FieldMappingRuntime mappingRuntime : mappingsRuntime) {
    		builder.append(mappingRuntime.getToName());
		}
    	
    	if (isSaveRowNo()) {
    		builder.append("rowno");
    	}
    	
    	return builder.toString();
    }
	
	private String insertToPlaceHolders() throws Exception {
    	ContentBuilder builder = new ContentBuilder(", ");
    	MappingsRuntime mappingsRuntime = toMappingsRuntime;

    	for (int i = 0; i < mappingsRuntime.size(); i++) {
    		builder.append("?");
		}
    	
    	if (isNewID()) {
    		builder.append("?");
    	}
    	
    	if (isSaveRowNo()) {
    		builder.append("?");
    	}
    	
    	return builder.toString();
	}

    private String getInsertFromFieldNames() {
    	ContentBuilder builder = new ContentBuilder(", ");
    	MappingsRuntime mappingsRuntime = mainMappingsRuntime;

    	for (FieldMappingRuntime mappingRuntime : mappingsRuntime) {
    		builder.append(mappingRuntime.getFromName());
		}
    	
    	String selectFields = builder.toString();
		if ("distinct".equalsIgnoreCase(getParameter("distinct"))) {
			selectFields = " distinct " + selectFields;
        }
		
    	return selectFields;
    }

    private String insertFromToTempFieldNames() throws Exception {
    	ContentBuilder builder = new ContentBuilder(", ");
    	MappingsRuntime mappingsRuntime = toMappingsRuntime;

    	for (FieldMappingRuntime mappingRuntime : mappingsRuntime) {
    		builder.append(mappingRuntime.getFromName());
		}
    	
    	return builder.toString();
	}

	private String getKeyFieldPairs() {
    	String[] fieldPairs = dataIO.getKeyFieldPairs();
    	
    	//1. if not define
		if (fieldPairs == null || fieldPairs.length == 0) {
			return dataIO.getFromName() + ".id = " + dataIO.getToName() + ".id";
		}
    	
    	//2. if define
        ContentBuilder result = new ContentBuilder(" and ");

        for (String fieldPair : fieldPairs) {
            String segment = setParametersTo(fieldPair);
            result.append(segment);
        }

        return result.toString();
    }

    private String getFilterFieldValues() {
		String[] fields = dataIO.getFilterFieldValues();

		//1. if not define
        if (fields == null || fields.length == 0) {
            return "1=1";
        }
    	
        //2. if define
        ContentBuilder result = new ContentBuilder(" and ");

        for (String fieldPair : fields) {
            String segment = setParametersTo(fieldPair);
            result.append(segment);
        }

        return result.toString();
    }    

	private String getUpdateFieldPairs() throws Exception {
        ContentBuilder result = new ContentBuilder(", ");

        MappingsRuntime mappingsRuntime = mainMappingsRuntime;
        String toTable = dataIO.getToName();
        String fromTable = dataIO.getFromName();

        for (FieldMappingRuntime mappingRuntime : mappingsRuntime) {
            result.append(toTable + "." + mappingRuntime.getToName() + " = " + fromTable + "." + mappingRuntime.getFromName());
        }

	    return result.toString();
    }	
	
	private String getUpdateFromFieldNames() throws Exception {
		ContentBuilder builder = new ContentBuilder(", ");
		
        MappingsRuntime mappingsRuntime = mainMappingsRuntime;
    	
		for (FieldMappingRuntime mappingRuntime : mappingsRuntime) {
    		builder.append(mappingRuntime.getFromName());
		}
		
		return builder.toString();
    }
	
	private String getSelectFromFieldNames() throws Exception {
		ContentBuilder builder = new ContentBuilder(", ");

        MappingsRuntime mappingsRuntime = toMappingsRuntime;

		for (FieldMappingRuntime mappingRuntime : mappingsRuntime) {
    		builder.append(mappingRuntime.getFromName());
		}
		
		String selectFields = builder.toString();
		if ("distinct".equalsIgnoreCase(getParameter("distinct"))) {
			selectFields = " distinct " + selectFields;
        }
		return selectFields;
	}
	
	private String getOrderBy() {
		String fromName = dataIO.getFromName();
		DataObject dataObject = DataObject.getInstance(fromName);
		
		if (dataObject == null) {
			return "";
		}
		
		OrderBy orderBy = dataObject.getDefaultOrderBy();
		
		if (orderBy == null) {
			return "";
		}
		
		return orderBy.toString();
	}
	
	private String getDynamicFilter() {
		if (dynamicFilter == null) {
			return "1=1";
		}
		
		return dynamicFilter.toString();
	}
	
	private String getUserFilter() {
		if (userFilter == null) {
			return "1=1";
		}
		
		return userFilter.toString();
	}

    public String setParametersTo(String segment) {
        if (segment == null) {
            return segment;
        }

        segment = segment.toLowerCase();

        for (String name : paramNames) {
            if (segment.indexOf(name) >= 0) {
                String value = getParameter(name);

                if (value == null) {
                    continue;
                }

                segment = segment.replace(name, value);
            }
        }

        return segment;
    }
	
	public boolean isNewID() {
		MappingsRuntime mappingsRuntime = mainMappingsRuntime;
		return !mappingsRuntime.containsToField("id");
	}

	public boolean isSaveRowNo() {
		MappingsRuntime mappingsRuntime = mainMappingsRuntime;
		return mappingsRuntime.containsToField("rowno");			
	}

	public void setDynamicFilter(Filter dynamicFilter) {
		this.dynamicFilter = dynamicFilter;
	}

	public void setUserFilter(Filter userFilter) {
		this.userFilter = userFilter;
	}

	public void setIoBatchId(String ioBatchId) {
		this.ioBatchId = ioBatchId;
	}

	public void setToMappingsRuntime(MappingsRuntime toMappingsRuntime) {
		this.toMappingsRuntime = toMappingsRuntime;
	}

	public void setMainMappingsRuntime(MappingsRuntime mainMappingsRuntime) {
		this.mainMappingsRuntime = mainMappingsRuntime;
	}

	private void initParamNames() {
		paramNames = new ArrayList<String>();
        paramNames.add("toTable");
        paramNames.add("toTempTable");
        paramNames.add("fromTable");
        paramNames.add("distinct");
        paramNames.add("toFieldCreateMetas");
        paramNames.add("insertToFieldNames");
        paramNames.add("insertToPlaceHolders");
        paramNames.add("insertFromFieldNames");
        paramNames.add("insertFromToTempFieldNames");
        paramNames.add("keyFieldPairs");
        paramNames.add("filterFieldValues");
        paramNames.add("updateFieldPairs");
        paramNames.add("updateFromFieldNames");
        paramNames.add("selectFromFieldNames");
        paramNames.add("dynamicFilter");
        paramNames.add("userFilter");
        paramNames.add("orderBy");
        paramNames.add("ioBatchId");
        paramNames.add("taskName");
	}

	public DataIO getDataIO() {
		return dataIO;
	}
	
}