package foundation.io.mapping;

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

import foundation.data.entity.DictionaryTranslator;
import foundation.data.entity.Entity;
import foundation.data.meta.field.Field;
import foundation.data.meta.field.FieldsRuntime;
import foundation.io.define.IODirection;
import foundation.io.define.IOSource;
import foundation.io.object.Header;
import foundation.io.object.Headers;
import foundation.io.object.Titles;
import foundation.util.Util;

public class IOMappings {
	
	private IOSource source;
	private String id;
	private String name;
	private boolean open;
	private List<FieldMapping> mappingList;
	private Map<String, FieldMapping> fromFieldMap;
	private Map<String, FieldMapping> toFieldMap;
	private Map<String, DictionaryTranslator> dictionaryList;

	
	public IOMappings(IOSource source) {
		this.source = source;
		
		mappingList = new ArrayList<FieldMapping>();
		fromFieldMap = new HashMap<String, FieldMapping>();
		toFieldMap = new HashMap<String, FieldMapping>();
		dictionaryList = new HashMap<String, DictionaryTranslator>();
	}

	public void load(Entity entity) throws Exception {
		id = entity.getString("id");
		name = entity.getString("name");
		open = entity.getBoolean("is_open", true);
	}
	
	public MappingsRuntime createRuntime(FieldsRuntime fromMeta, FieldsRuntime toMeta, MappingDirection direction) throws Exception {
		return createRuntime(fromMeta, toMeta, direction, false);
	}
	
	public MappingsRuntime createRuntime(FieldsRuntime fromMeta, FieldsRuntime toMeta, MappingDirection direction, boolean open) throws Exception {
		MappingsRuntime mappingSetRuntime = new MappingsRuntime();
        
        for (FieldMapping fieldMapping : mappingList) {
        	String fromName, toName;
        	if (MappingDirection.Normal == direction) {
				fromName = fieldMapping.getFromName();
				toName = fieldMapping.getToName();
			}
        	else {
				fromName = fieldMapping.getToName();
				toName = fieldMapping.getFromName();
			}
        	
        	Field formField = fromMeta.get(fromName);
        	Field toField = toMeta.get(toName);
        	
        	if (formField == null || toField == null) {
				continue;
			}
        	
        	int fromIndex = fromMeta.getIndex(fromName);
        	int toIndex = toMeta.getIndex(toName);
        	
        	FieldMappingRuntime mappingRuntime = new FieldMappingRuntime(fieldMapping, formField, toField, fromIndex, toIndex);
        	mappingSetRuntime.addItem(mappingRuntime);
		}
        
        if (open) {
	        List<Field> fields = fromMeta.getFields();
	        for (Field field : fields) {
	        	String fieldName = field.getName();
	        	
	        	if (mappingSetRuntime.containsFromField(fieldName)) {
	        		continue;
	        	}
				if (!toMeta.contains(fieldName)) {
					continue;
				}
				
				Field fromField = fromMeta.get(fieldName);
				Field toField = toMeta.get(fieldName);
				
				int fromIndex = fromMeta.getIndex(fieldName);
				int toIndex = toMeta.getIndex(fieldName);
				
				FieldMappingRuntime mappingRuntime = new FieldMappingRuntime(null, fromField, toField, fromIndex, toIndex);
	        	mappingSetRuntime.addItem(mappingRuntime);
			}
        }
        
        return mappingSetRuntime;
	}
	
	public MappingsRuntime createRuntime(Titles fromTitles, FieldsRuntime toMeta, MappingDirection direction) throws Exception {
		MappingsRuntime mappingsRuntime = new MappingsRuntime();
		 
        for (FieldMapping fieldMapping : mappingList) {
        	String fromName, toName;
        	if (MappingDirection.Normal == direction) {
				fromName = fieldMapping.getFromName();
				toName = fieldMapping.getToName();
			}
        	else {
				fromName = fieldMapping.getToName();
				toName = fieldMapping.getFromName();
			}
        	
        	Integer fromIndex = fromTitles.getIndex(fromName);
        	Field toField = toMeta.get(toName);
        	
        	if (fromIndex == null || toField == null) {
				continue;
			}
        	
        	int toIndex = toMeta.getIndex(toName);
        	
        	FieldMappingRuntime mappingRuntime = new FieldMappingRuntime(fieldMapping, fromName, toField, fromIndex, toIndex);
        	mappingsRuntime.addItem(mappingRuntime);
		}
        
        return mappingsRuntime;
	}
	
	public MappingsRuntime createRuntime(FieldsRuntime fromMeta, Headers toHeaders, MappingDirection direction, IODirection ioDirection) throws Exception {
		MappingsRuntime mappingSetRuntime = new MappingsRuntime();
        
		//1. if to titles is empty
		if (toHeaders.isEmpty()) {
			for (FieldMapping fieldMapping : mappingList) {
	        	String fromName, toName;
	        	if (MappingDirection.Normal == direction) {
					fromName = fieldMapping.getFromName();
					toName = fieldMapping.getToName();
				}
	        	else {
					fromName = fieldMapping.getToName();
					toName = fieldMapping.getFromName();
				}
	        	
	        	Field fromField = fromMeta.get(fromName);
	        	
	        	if (fromField == null) {
					continue;
				}
	        	
	        	int fromIndex = fromMeta.getIndex(fromName);
	        	
	        	FieldMappingRuntime mappingRuntime = new FieldMappingRuntime(fieldMapping, fromField, toName, fromIndex, fromIndex);
	        	mappingSetRuntime.addItem(mappingRuntime);
	        	
	        	toHeaders.addOne(toName);
			}
			 
			if (IODirection.ErrorsToSheet == ioDirection) {
				String fromName = "error_message";
				String toName = "导入反馈";
				Field fromField = fromMeta.get(fromName);
				int fromIndex = fromMeta.getIndex(fromName);
				FieldMapping fieldMapping = new FieldMapping();
				FieldMappingRuntime mappingRuntime = new FieldMappingRuntime(fieldMapping, fromField, toName, fromIndex, fromIndex);
	        	mappingSetRuntime.addItem(mappingRuntime);
	        	
	        	toHeaders.addOne(toName);
			}
			
			return mappingSetRuntime;
		}
		
		//2. if to headers is not empty
		for (Header header: toHeaders) {
            Field fromField = fromMeta.get(header.getFieldName());
            
            if (fromField == null) {
                continue;
            }

            FieldMappingRuntime mappingRuntime = new FieldMappingRuntime(null, fromField, header.getTitle(), fromField.getIndexNo(), header.getIndex());
        	mappingSetRuntime.addItem(mappingRuntime);
        	
		}
		
        return mappingSetRuntime;
	}
	
	public int size() {
        return mappingList.size();
    }

    public List<FieldMapping> getList() {
        return mappingList;
    }

    public void addFieldMapping(FieldMapping mapping) {
        String fromField = mapping.getFromName();
        String toField = mapping.getToName();

        mappingList.add(mapping);

        if (fromField != null) {
            fromFieldMap.put(fromField, mapping);
        }

        if (toField != null) {
        	toFieldMap.put(toField, mapping);
        }
    }
    
    public String getFromField(String toField) {
    	return convertField(toField, true);
    }
    
    public String getToField(String fromField) {
       return convertField(fromField, false);
    }
    
    private String convertField(String field, boolean isFromField) {
    	FieldMapping item = getIoMappingItem(field, isFromField);
    	
    	if (isFromField) {
    		return item.getToName();
		}
    	else {
    		return item.getFromName();
		}
    }
    
    public void clear() {
    	if (mappingList != null) {
    		mappingList.clear();
		}
    	
    	if (fromFieldMap != null) {
    		fromFieldMap.clear();
		}
    
    	if (toFieldMap != null) {
    		toFieldMap.clear();
		}
    	
    	if (dictionaryList != null) {
    		dictionaryList.clear();
		}
    }

    public FieldMapping getItemByFromField(String fromField) {
    	return getIoMappingItem(fromField, true);
    }
	
    public FieldMapping getItemByToField(String toField) {
    	return getIoMappingItem(toField, false);
    }
    
    private FieldMapping getIoMappingItem(String field, boolean isFromField) {
		Map<String, FieldMapping> itemMap = null;
    	if (Util.isEmpty(field)) {
    		return null;
    	}
    	 
    	field = field.toLowerCase();
    	
    	if (isFromField) {
    		itemMap = fromFieldMap;
		}
    	else {
    		itemMap = toFieldMap;
		}
    	
    	if (!itemMap.containsKey(field)) {
    		return null;
    	}

    	FieldMapping item = itemMap.get(field);
		return item;
	}

	public boolean containsToField(String toField) {
		if (Util.isEmpty(toField)) {
			return false;
		}
		
		toField = toField.toLowerCase();
		return toFieldMap.containsKey(toField);
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public boolean isOpen() {
		return open;
	}

	public void setOpen(boolean open) {
		this.open = open;
	}

	public List<FieldMapping> getItemList() {
		return mappingList;
	}

	public IOSource getSource() {
		return source;
	}
}