package foundation.data.mapping;

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

import foundation.data.entity.Entity;
import foundation.data.meta.field.Field;
import foundation.data.meta.field.FieldsRuntime;
import foundation.util.ContentBuilder;
import foundation.util.Util;

public class Mappings implements Iterable<FieldMapping> {
	
	private String id;
	private String name;
	private boolean open;
	private List<FieldMapping> mappingList;
	private Map<String, FieldMapping> fromFieldMap;
	private Map<String, FieldMapping> toFieldMap;

	
	public Mappings() {
		mappingList = new ArrayList<FieldMapping>();
		fromFieldMap = new HashMap<String, FieldMapping>();
		toFieldMap = new HashMap<String, FieldMapping>();
	}

	public Mappings(String id) {
		this.id = id;
		mappingList = new ArrayList<FieldMapping>();
		fromFieldMap = new HashMap<String, FieldMapping>();
		toFieldMap = new HashMap<String, FieldMapping>();
	}
	
	public static Mappings getInstance(FieldsRuntime one, FieldsRuntime another) {
		Mappings result = new Mappings();
		String fieldName = null; FieldMapping mapping = null; int idx = 0;
		
		for (Field field: one) {
			fieldName = field.getName();
			
			if (!another.contains(fieldName)) {
				continue;
			}
			
			mapping = new FieldMapping();
			mapping.setFromName(fieldName);
			mapping.setToName(fieldName);
			mapping.setIndexNo(idx++);
			
			result.loadOne(mapping);
		}
		
		return result;
	}
	
	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 {
		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 int size() {
        return mappingList.size();
    }

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

    public void loadOne(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();
		}
    }

    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 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;
	}

	@Override
	public Iterator<FieldMapping> iterator() {
		return mappingList.iterator();
	}

	public String getFromFieldsString() {
		ContentBuilder builder = new ContentBuilder(", ");
		
		for (FieldMapping mapping: mappingList) {
			builder.append(mapping.getFromName());
		}
		
		return builder.toString();
	}
	
	public String getToFieldsString() {
		ContentBuilder builder = new ContentBuilder(", ");
		
		for (FieldMapping mapping: mappingList) {
			builder.append(mapping.getToName());
		}
		
		return builder.toString();
	}

}