package zutil.db.bean;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.logging.Level;
import java.util.logging.Logger;

import zutil.db.DBConnection;
import zutil.log.LogUtil;

/**
 * <XMP>
 * The class that extends this will be able to save its state to a DB.
 * Fields that are transient will be ignored, and fields that extend 
 * DBBean will be replaced by the id field of that class.
 * 
 * Supported fields:
 * 	*Boolean
 * 	*Integer
 * 	*Short
 * 	*Float
 * 	*Double
 * 	*String
 * 	*Character
 * 	*DBBean
 * 	*java.sql.Date
 * 	*List<DBBean>
 * 
 * </XMP>
 * @author Ziver
 */
public abstract class DBBean {
	public static final Logger logger = LogUtil.getLogger();

	/** The id of the bean **/
	protected Long id;

	/**
	 * Sets the name of the table in the database
	 */
	@Retention(RetentionPolicy.RUNTIME)
	@Target(ElementType.TYPE)
	public @interface DBTable {
		String value();
	}

	/**
	 * Sets the name of the table that links different DBBeans together
	 */
	@Retention(RetentionPolicy.RUNTIME)
	@Target(ElementType.FIELD)
	public @interface DBLinkTable {
		/** The name of the Link table */
		String name();
		/** The class of the linked bean */
		Class<? extends DBBean> beanClass();
		/** The name of the column that contains this objects id */
		String column() default "";
	}

	/**
	 * A Class that contains information about a bean
	 */
	protected static class DBBeanConfig{
		/** The name of the table in the DB */
		protected String tableName;
		/** All the fields in the bean */
		protected ArrayList<Field> fields;

		protected DBBeanConfig(){
			fields = new ArrayList<Field>();
		}
	}

	/** This is a cache of all the initialized beans */	 
	private static HashMap<Class<? extends DBBean>,DBBeanConfig> beanConfigs = new HashMap<Class<? extends DBBean>,DBBeanConfig>();
	/** This value is for preventing recursive loops */	 
	private boolean processing;

	protected DBBean(){
		if( !beanConfigs.containsKey( this.getClass() ) )
			initBeanConfig( this.getClass() );
		processing = false;
	}

	/**
	 * @return all the fields except the ID field
	 */
	public static ArrayList<Field> getFields(Class<? extends DBBean> c){
		if( !beanConfigs.containsKey( c ) )
			initBeanConfig( c );
		return beanConfigs.get( c ).fields;		
	}

	/**
	 * @return the configuration object for the specified class
	 */
	protected static DBBeanConfig getBeanConfig(Class<? extends DBBean> c){
		if( !beanConfigs.containsKey( c ) )
			initBeanConfig( c );
		return beanConfigs.get( c );	
	}

	/**
	 * Caches the fields
	 */
	private static void initBeanConfig(Class<? extends DBBean> c){
		Field[] fields = c.getDeclaredFields();
		DBBeanConfig config = new DBBeanConfig();
		// Find the table name
		if( c.getAnnotation(DBTable.class) != null )
			config.tableName = c.getAnnotation(DBTable.class).value().replace('\"', ' ');
		// Add the fields in the bean
		for( Field field : fields ){
			int mod = field.getModifiers();
			if( !Modifier.isTransient( mod ) &&
					!Modifier.isAbstract( mod ) &&
					!Modifier.isFinal( mod ) &&
					!Modifier.isStatic( mod ) &&
					!Modifier.isInterface( mod ) &&
					!Modifier.isNative( mod )){
				config.fields.add( field );
			}
		}

		beanConfigs.put(c, config);
	}

	/**
	 * Saves the Object to the DB
	 */
	@SuppressWarnings("unchecked")
	public void save(DBConnection db) throws SQLException{
		if( processing )
			return;
		processing = true;
		Class<? extends DBBean> c = this.getClass();
		DBBeanConfig config = beanConfigs.get(c);
		try {
			Long id = this.getId();
			// Generate the SQL
			StringBuilder query = new StringBuilder();
			if( id == null )
				query.append("INSERT INTO ");
			else query.append("UPDATE ");
			query.append( config.tableName );

			StringBuilder params = new StringBuilder();
			for( Field field : config.fields ){
				if( !List.class.isAssignableFrom(field.getType()) ){
					params.append(" ");
					params.append(field.getName());
					params.append("=?,");
				}
			}
			if( params.length() > 0 ){
				params.delete( params.length()-1, params.length());
				query.append( " SET" );
				query.append( params );
				if( id != null )
					query.append( " WHERE id=?" );
			}
			logger.finest("Save query: "+query.toString());
			PreparedStatement stmt = db.getPreparedStatement( query.toString() );
			// Put in the variables in the SQL
			int index = 1;
			for(Field field : config.fields){

				// Another DBBean class
				if( DBBean.class.isAssignableFrom( field.getType() )){
					DBBean subobj = (DBBean)getFieldValue(field);
					if(subobj != null){
						subobj.save(db);
						stmt.setObject(index, subobj.getId() );
					}
					else
						stmt.setObject(index, null);
					index++;
				}
				// A list of DBBeans
				else if( List.class.isAssignableFrom( field.getType() ) && 
						field.getAnnotation( DBLinkTable.class ) != null){
					List<DBBean> list = (List<DBBean>)getFieldValue(field);
					if( list != null ){
						DBLinkTable linkTable = field.getAnnotation( DBLinkTable.class );
						String subtable = linkTable.name();
						String idcol = (linkTable.column().isEmpty() ? config.tableName : linkTable.column() );

						DBBeanConfig subConfig = null;
						for(DBBean subobj : list){
							if(subConfig == null)
								subConfig = beanConfigs.get( subobj.getClass() );
							// Save links in link table
							PreparedStatement subStmt = db.getPreparedStatement("REPLACE INTO "+subtable+" SET ?=? id=?");
							subStmt.setString(1, idcol);
							subStmt.setString(2, subConfig.tableName);
							subStmt.setObject(3, subobj.getId() );
							DBConnection.exec(subStmt);
							// Save the sub bean
							subobj.save(db);
						}
					}
				}
				// Normal field
				else{
					Object value = getFieldValue(field);
					stmt.setObject(index, value);
					index++;
				}
			}
			if( id != null )
				stmt.setObject(index, id);

			// Execute the SQL
			DBConnection.exec(stmt);
			if( id == null )
				this.id = (Long) db.getLastInsertID();
		} catch (SQLException e) {
			throw e;
		} catch (Exception e) {
			throw new SQLException(e);
		}
		processing = false;
	}

	/**
	 * Deletes the object from the DB, WARNING will not delete sub beans
	 * 
	 * @throws SQLException 
	 */
	public void delete(DBConnection db) throws SQLException{
		Class<? extends DBBean> c = this.getClass();
		DBBeanConfig config = beanConfigs.get(c);
		if( this.getId() == null )
			throw new NoSuchElementException("ID field is null( Has the bean been saved?)!");

		String sql = "DELETE FROM "+config.tableName+" WHERE id=?";
		logger.fine("Load query: "+sql);
		PreparedStatement stmt = db.getPreparedStatement( sql );
		// Put in the variables in the SQL
		logger.fine("Delete query: "+sql);
		stmt.setObject(1, this.getId() );

		// Execute the SQL
		DBConnection.exec(stmt);
	}

	/**
	 * Loads all the rows in the table into a LinkedList
	 * 
	 * @param 	<T> 	is the class of the bean
	 * @param 	c 		is the class of the bean
	 * @return			a LinkedList with all the Beans in the DB
	 */
	public static <T extends DBBean> List<T> load(DBConnection db, Class<T> c) throws SQLException {
		// Initiate a BeanConfig if there is non
		if( !beanConfigs.containsKey( c ) )
			initBeanConfig( c );
		DBBeanConfig config = beanConfigs.get(c);
		// Generate query
		String sql = "SELECT * FROM "+config.tableName;
		logger.fine("Load query: "+sql);
		PreparedStatement stmt = db.getPreparedStatement( sql );
		// Run query
		List<T> list = DBConnection.exec(stmt, DBBeanSQLResultHandler.createList(c, db) );
		return list;
	}

	/**
	 * Loads all the rows in the table into a LinkedList
	 * 
	 * @param 	<T> 	is the class of the bean
	 * @param 	c 		is the class of the bean
	 * @param	id		is the id value of the bean
	 * @return			a DBBean Object with the specific id or null
	 */
	public static <T extends DBBean> T load(DBConnection db, Class<T> c, Object id) throws SQLException {
		// Initiate a BeanConfig if there is non
		if( !beanConfigs.containsKey( c ) )
			initBeanConfig( c );
		DBBeanConfig config = beanConfigs.get(c);
		// Generate query
		PreparedStatement stmt = db.getPreparedStatement( "SELECT * FROM "+config.tableName+" WHERE id=? LIMIT 1" );
		stmt.setObject(1, id );
		// Run query
		T obj = DBConnection.exec(stmt, DBBeanSQLResultHandler.create(c, db) );
		return obj;
	}

	/**
	 * Creates a specific table for the given Bean,
	 * WARNING: Experimental
	 */
	public static void create(DBConnection sql, Class<? extends DBBean> c) throws SQLException{
		if( !beanConfigs.containsKey( c ) )
			initBeanConfig( c );
		DBBeanConfig config = beanConfigs.get(c);

		// Generate the SQL
		StringBuilder query = new StringBuilder();
		query.append("CREATE TABLE "+config.tableName+" (  ");

		// ID
		query.append(" id ");
		query.append( classToDBName( Long.class ) );
		query.append(" PRIMARY KEY AUTO_INCREMENT, ");

		for( Field field : config.fields ){
			query.append(" ");
			query.append( field.getName() );
			query.append( classToDBName(c) );
			query.append(", ");
		}
		query.delete( query.length()-2, query.length());
		query.append(")");
		PreparedStatement stmt = sql.getPreparedStatement( sql.toString() );

		// Execute the SQL
		DBConnection.exec(stmt);
	}

	private static String classToDBName(Class<?> c){
		if(     c == String.class) 		return "CLOB"; // TEXT
		else if(c == Short.class) 		return "SMALLINT";
		else if(c == short.class) 		return "SMALLINT";
		else if(c == Integer.class) 	return "INTEGER";
		else if(c == int.class) 		return "INTEGER";
		else if(c == BigInteger.class)	return "BIGINT";
		else if(c == Long.class) 		return "DECIMAL";
		else if(c == long.class) 		return "DECIMAL";
		else if(c == Float.class) 		return "DOUBLE";
		else if(c == float.class) 		return "DOUBLE";
		else if(c == Double.class) 		return "DOUBLE";
		else if(c == double.class) 		return "DOUBLE";
		else if(c == BigDecimal.class) 	return "DECIMAL";
		else if(c == Boolean.class) 	return "BOOLEAN";
		else if(c == boolean.class) 	return "BOOLEAN";
		else if(c == Byte.class) 		return "BINARY(1)";
		else if(c == byte.class) 		return "BINARY(1)";
		else if(DBBean.class.isAssignableFrom(c))
			return classToDBName(Long.class);
		return null;
	}

	/**
	 * This is a workaround if the field is not visible to other classes
	 * 
	 * @param 	field	is the field
	 * @return 			the value of the field
	 */
	protected Object getFieldValue(Field field){
		try {
			field.setAccessible(true);
			return field.get(this);
		} catch (Exception e) {
			logger.log(Level.WARNING, e.getMessage(), e);
		}
		return null;
	}

	/**
	 * This is a workaround if the field is not visible to other classes
	 * 
	 * @param 	field	is the field
	 * @return 			the value of the field
	 */
	protected void setFieldValue(Field field, Object o){
		try {
			field.setAccessible(true);
			if( o == null && !Object.class.isAssignableFrom( field.getType() ) ){
				logger.fine("Trying to set primitive data type to null!");
				if( 	 field.getType() == Integer.TYPE )	field.setInt(this, 0);
				else if( field.getType() == Character.TYPE )field.setChar(this, (char) 0);
				else if( field.getType() == Byte.TYPE )		field.setByte(this, (byte) 0);
				else if( field.getType() == Short.TYPE )	field.setShort(this, (short) 0);
				else if( field.getType() == Long.TYPE )		field.setLong(this, 0l);
				else if( field.getType() == Float.TYPE )	field.setFloat(this, 0f);
				else if( field.getType() == Double.TYPE )	field.setDouble(this, 0d);
				else if( field.getType() == Boolean.TYPE )	field.setBoolean(this, false);
			}
			else
				field.set(this, o);
		} catch (Exception e) {
			logger.log(Level.WARNING, e.getMessage(), e);
		}
	}

	/**
	 * @return the object id or null if the bean has not bean saved yet
	 */
	public Long getId(){
		return id;
	}
}