package foundation.data.meta.field;

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

import foundation.data.entity.Entity;
import foundation.data.entity.EntitySet;
import foundation.data.object.DataJoin;
import foundation.data.object.DataObject;
import foundation.translator.ITranslator;
import foundation.translator.Translator;
import foundation.translator.ValueType;
import foundation.util.MapList;

public class FieldRuntimeCreator {
	
	public static FieldsRuntime create(IFieldReader fieldReader) throws Exception {
		FieldsRuntime runtime = new FieldsRuntime();
		MapList<String, Field> fieldList = runtime.fieldList;

		String fieldName; Field field;

		while (fieldReader.next()) {
			fieldName = fieldReader.getFieldName();

			if (fieldName == null) {
				continue;
			}

			if (fieldList.contains(fieldName)) {
				fieldName = fieldName + "1";
			}
			
			field = new Field(fieldName);
			field.load(fieldReader);
			field.setIndexNo(fieldList.size());
			
			fieldList.add(fieldName, field);
		}
		
		//2. names  字段总数量
		int fieldCount = fieldList.size();
		String[] names = runtime.names = new String[fieldCount];
		String[] lowerNames = runtime.lowerNames = new String[fieldCount];

		String name;
		for (int i = 0; i < fieldCount; i++) {
			 field = fieldList.get(i);
			 name = field.getName();
			 names[i] = name;
             
			 name = name.toLowerCase();
			 lowerNames[i] = name;
		}
		
		//3. translators
		ITranslator[] valueTranslators = runtime.valueTranslators = new ITranslator[fieldCount];
		
		for (int i = 0; i < fieldCount; i++) {
			 field = fieldList.get(i);
			 ValueType valueType = field.getType();
			 
			 if (BooleanPrefix.contains(field.getName())) {
				 valueType = ValueType.Boolean;
			 }
			 
			 ITranslator translator = Translator.getInstance(valueType);
			 
			 valueTranslators[i] = translator;
			 field.setTranslator(translator);
		}
		
		//4. return
		return runtime;
	}

	public static void buildExtension(FieldsRuntime tableFieldMetas, EntitySet entitySet) {
		if (entitySet == null || entitySet.isEmpty()) {
			return;
		}
		
		FieldExtension extension; Field field;
		
		for (Entity entity: entitySet) {
			extension = new FieldExtension();
			extension.load(entity);
			
			field = tableFieldMetas.get(extension.getName());
			
			if (field == null) {
				continue;
			}
			
			field.setExtension(extension);
		}
	}

	public static void buildExtension(FieldsRuntime target, FieldsRuntime anothers) {
		if (anothers == null || anothers.isEmpty()) {
			return;
		}

		Field field;
		
		for (Field another: anothers) {
			field = target.get(another.getName());
			
			if (field == null) {
				continue;
			}
			
			field.setExtension(another.getExtention());
		}
	}

	public static void buildJoinedExtension(FieldsRuntime fieldMetas) throws Exception {
		//1. 选获取需要关联的表
		TableExtensionBucket extensionBucket = new TableExtensionBucket();
		
		for (Field field: fieldMetas) {
			extensionBucket.loadOne(field);
		}
		
		//2. 依次Build
		for (TableExtension tableExtension: extensionBucket) {
			String tableName = tableExtension.tableName;
			DataObject dataObject = DataObject.getInstance(tableName);
			
			if (dataObject == null) {
				continue;
			}
			
			FieldsRuntime fields = dataObject.getTableFieldMetas();
			Field field;
			
			for (Field target: tableExtension) {
				field = fields.get(target.getOriginalName());
				
				if (field == null) {
					continue;
				}
				
				target.setExtension(field.getExtention());
			}
		}
	}
	
	private static class TableExtensionBucket implements Iterable<TableExtension> {
		
		private MapList<String, TableExtension> items;
		private TableExtension cachedTable;
		private String cachedName;
		
		
		public TableExtensionBucket() {
			items = new MapList<String, FieldRuntimeCreator.TableExtension>();
		}
		
		public void loadOne(Field field) {
			String fieldName = field.getName();
			int pos = fieldName.indexOf(DataJoin.TableJoinConnector);
			
			//1. 如果是主表（非关联表）字段，从主表定义中获取
			if (pos < 0) {
				return;
			}
			
			//2. 如果是关联表字段，从关联表定义中获取
			String tableName = fieldName.substring(0, pos);
			
			String originalFieldName = fieldName.substring(pos + 2);
			field.setOriginalName(originalFieldName);
			
			if (tableName.equals(cachedName)) {
				cachedTable.fields.add(field);
				return;
			}
			
			cachedTable = items.get(tableName);
			
			if (cachedTable == null) {
				cachedName = tableName;
				cachedTable = new TableExtension(tableName);
				items.add(cachedName, cachedTable);
			}
			
			cachedTable.fields.add(field);
		}

		@Override
		public Iterator<TableExtension> iterator() {
			return items.iterator();
		}
	}
	
	private static class TableExtension implements Iterable<Field> {
		
		private String tableName;
		private List<Field> fields;
		
		public TableExtension(String tableName) {
			this.tableName = tableName;
			this.fields = new ArrayList<Field>();
		}
		
		@Override
		public Iterator<Field> iterator() {
			return fields.iterator();
		}
	}

}