package frame.file.office;

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

import com.sun.org.apache.regexp.internal.recompile;

import frame.data.Entity;
import frame.data.meta.EntityMeta;
import frame.data.meta.Field;
import frame.file.Direction;
import frame.file.FileIOContext;
import frame.file.FileIOItem;
import frame.file.IFileload;
import frame.util.Util;

public class IOMapping implements IFileload{

	private String id;
	private String name;
	private boolean open;
	private int typeCode;
	private List<IOMappingItem> itemList;
	private Map<String, IOMappingItem> fromItemMap;
	private Map<String, IOMappingItem> toItemMap;

	public IOMapping() {
		itemList = new ArrayList<IOMappingItem>();
		fromItemMap = new HashMap<String, IOMappingItem>();
		toItemMap = new HashMap<String, IOMappingItem>();
	}

	@Override
	public void initLoad(Entity entity) {
		// TODO Auto-generated method stub
		
	}
	public IOMappingRuntime createRuntime(FileIOContext context, String condition, EntityMeta fromMeta, EntityMeta toMeta, Direction direction) throws Exception {
		List<IOMappingItemRuntime> updateMappingRuntime = new ArrayList<IOMappingItemRuntime>();
        List<IOMappingItemRuntime> insertMappingRuntime = new ArrayList<IOMappingItemRuntime>();
        
        for (IOMappingItem mappingItem : itemList) {
        	String fromField, toField;
        	if (Direction.Normal == direction) {
				fromField = mappingItem.getFromField();
				toField = mappingItem.getToField();
			}
        	else {
				fromField = mappingItem.getToField();
				toField = mappingItem.getFromField();
			}
        	
        	if (context != null) {
				fromField = context.setParametersTo(fromField);
				toField = context.setParametersTo(toField);
			}
        	
        	Field fieldByFrom = fromMeta.get(fromField);
        	Field fieldByto = fromMeta.get(toField);
        	
        	if (fieldByFrom == null || fieldByto == null) {
        		if (FileIOItem.TypeCode_DB.equalsIgnoreCase(condition)) {
					if (mappingItem.isInsertIgnore() || mappingItem.isUpdateIgnore()) {
						continue;
					}
					else {
						throw new Exception("IO Mapping fields not in table:" + mappingItem.toString() + " " + fromMeta.getName() + ", " + toMeta.getName());
					}
				}
        		else {
					continue;
				}
			}
        	
        	IOMappingItemRuntime mappingItemRuntime = new IOMappingItemRuntime(mappingItem, fromField, fieldByFrom, toField, fieldByto);
        	
        	if (!mappingItem.isInsertIgnore()) {
        		insertMappingRuntime.add(mappingItemRuntime);
			}
        	
        	if (!mappingItem.isUpdateIgnore()) {
        		updateMappingRuntime.add(mappingItemRuntime);
			}
        
		}
        
        if (open) {
	        List<Field> fields = fromMeta.getFields();
	        for (Field field : fields) {
	        	String fieldName = field.getName();
				if (!toMeta.contains(fieldName)) {
					continue;
				}
				
				Field fromField = fromMeta.get(fieldName);
				Field toField = toMeta.get(fieldName);
				
				IOMappingItemRuntime itemRuntime = new IOMappingItemRuntime(null, fieldName, fromField, fieldName, toField);
				
				if (!fromItemMap.containsKey(field)) {
                    updateMappingRuntime.add(itemRuntime);
                }

                if (!fromItemMap.containsKey(field)) {
                    insertMappingRuntime.add(itemRuntime);
                } 
			}
        }
        
        IOMappingRuntime ioMappingRuntime = new IOMappingRuntime(insertMappingRuntime, updateMappingRuntime);
        
        return ioMappingRuntime;
	}
	
	public int size() {
        return itemList.size();
    }

    public List<IOMappingItem> getList() {
        return itemList;
    }

    public void addItem(IOMappingItem item) {
        String fromField = item.getFromField();
        String toField = item.getToField();

        itemList.add(item);

        if (fromField != null) {
            fromItemMap.put(fromField, item);
        }

        if (toField != null) {
        	toItemMap.put(toField, item);
        }
    }
    
    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) {
    	IOMappingItem item = getIoMappingItem(field, isFromField);
    	
    	if (isFromField) {
    		return item.getToField();
		}
    	else {
    		return item.getFromField();
		}
    	
    }
    
    public void clear() {
    	if (itemList != null) {
    		itemList.clear();
		}
    	
    	if (fromItemMap != null) {
    		fromItemMap.clear();
		}
    
    	if (toItemMap != null) {
    		toItemMap.clear();
		}
    }

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

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

	public String getId() {
		return id;
	}

	public String getName() {
		return name;
	}

	public boolean isOpen() {
		return open;
	}

	public int getTypeCode() {
		return typeCode;
	}

	public List<IOMappingItem> getItemList() {
		return itemList;
	}


}