package frame.object.meta;

import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

import frame.persist.loader.ResultMetaFieldReader;
import frame.variant.ValueType;
import frame.variant.translator.ITranslator;
import frame.variant.translator.Translator;


public class EntityMeta implements Iterable<Field> {

	protected static Logger logger;
	
	protected String tableName;
	protected List<Field> fieldList;
	protected String[] names;
	protected String[] lowerNames;
	protected Map<String, Integer> nameIndexMap;
	protected ITranslator[] translators;

	static {
		logger = Logger.getLogger(EntityMeta.class);
	}

	protected EntityMeta() {
		
	}
	
	public EntityMeta(String tableName, IFieldReader fieldReader) throws SQLException {
		this.tableName = tableName;
		nameIndexMap = new HashMap<String, Integer>();
		fieldList = new ArrayList<Field>();

		initFields(fieldReader);
	}

	public static EntityMeta getInstance(String tableName) throws Exception {
		EntityMetaLoader loader = new EntityMetaLoader();
		return  loader.getEntityMetaByTable(tableName);
	}

	public static EntityMeta getInstance(ResultSetMetaData metaData) throws Exception {
		ResultMetaFieldReader fieldReader = new ResultMetaFieldReader(metaData);
		return new EntityMeta("tablemeta", fieldReader);
	}

	private void initFields(IFieldReader fieldReader) throws SQLException {
		String fieldName;
		int columnType;
		int fieldLength;
		int nullable;
		Field field;

		//1. fields
		fieldReader.first();

		while (fieldReader.next()) {
			fieldName = fieldReader.getFieldName();
			columnType = fieldReader.getFieldType();
			fieldLength = fieldReader.getFieldLength();
			nullable = fieldReader.getNullable();

			if (fieldName == null) {
				continue;
			}

			field = new Field(fieldName);
			fieldList.add(field);

			field.setType(columnType);
			field.setLength(fieldLength);
			field.setNullable(nullable);
		}

		//2. names
		int fieldCount = fieldList.size();
		names = new String[fieldCount];
		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;
			nameIndexMap.put(name, i);
		}
		
		//3. translators
		translators = new ITranslator[fieldCount];
		
		for (int i = 0; i < fieldCount; i++) {
			field = fieldList.get(i);
			ValueType valueType = field.getValueType();
			ITranslator translator = Translator.getInstance(valueType);
			
			translators[i] = translator;
			field.setTranslator(translator);
		}
	}

	public int getFieldCount() {
		return fieldList.size();
	}

	public Iterator<Field> iterator() {
		return fieldList.iterator();
	}

	public String getTableName() {
		return tableName;
	}

	public List<Field> getFields() {
		return fieldList;
	}

	public Field getField(String name) {
		if (name == null)
			return null;

		Integer idx = nameIndexMap.get(name.toLowerCase());

		if (idx == null) {
			return null;
		}

		return fieldList.get(idx);
	}

	public Field getField(int idx) {
		return fieldList.get(idx);
	}
	
	public ValueType getValueType(int idx) {
		Field field = fieldList.get(idx);
		return field.getValueType();
	}

	public Integer getIndex(String fieldName) {
		if (fieldName == null) {
			return null;
		}
		
		try {
			return nameIndexMap.get(fieldName.toLowerCase());
		}
		catch (Exception e) {
			return null;
		}
	}

	public String[] getLowerNames() {
		return lowerNames;
	}

	public String[] getFieldNames() {
		return names;
	}
	
	public boolean contains(String name) {
		if (name == null) {
			return false;
		}

		name = name.toLowerCase();
		return nameIndexMap.containsKey(name);
	}

	public ITranslator getTranslator(int idx) {
		return translators[idx];
	}
	
	public ITranslator getTranslator(String name) {
		name = name.toLowerCase();
		Integer idx = nameIndexMap.get(name);

		if (idx == null) {
			return null;
		}
		
		return translators[idx];
	}

}