/***
    * License Agreement.
    * 
    * JSPA (POJO-SP)
    * 
    * Copyright (C) 2009 HRX Pty Ltd
    * 
    * This file is part of JSPA.
    * 
   * JSPA is free software: you can redistribute it and/or modify it under the
   * terms of the GNU Lesser General Public License version 3 as published by the
   * Free Software Foundation.
   * 
   * JSPA is distributed in the hope that it will be useful, but WITHOUT ANY
   * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   * A PARTICULAR PURPOSE. See the Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public License
   * along with JSPA. If not, see <http://www.gnu.org/licenses/>.
   */
  package com.hrx.rasp.util.dao;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Field;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.persistence.Column;
  import javax.persistence.EmbeddedId;
  import javax.persistence.Entity;
  
  import org.apache.log4j.Logger;
  
  import com.hrx.rasp.util.dao.annotations.DAOConstructor;
  import com.hrx.rasp.util.dao.exception.StoredProcedureProccessResultException;
  import com.hrx.rasp.util.dao.metadata.MetadataHelper;
  
  /***
   * The default implementation will return an ArrayList containing instances of
   * the DAO that calls the JDBC Stored Procedure.
   * 
   * The default implementation is expected to be overwrite for any generic Store
   * Procedure where the CURSOR will returns different data type than the DAO
   * caller type.
   * 
   * When using this implementation the DAO implementation must implement a
   * Constructor the has the same arguments and in the same order as the CURSOR
   * record properties.
   * 
   * @author dan.stoica <dan.stoica@acslink.net.au>
   * 
   */
  public class DefaultResultSetProcessor<E> implements ResultSetProcessor<E>
  {
  	private static Logger log = Logger.getLogger(DefaultResultSetProcessor.class);
  
  	/***
  	 * The maximum number of results to retrieve from result set.
  	 * 
  	 */
  	int maxResult = 0;
  
  	/***
  	 * The start position of the first result, numbered from 0 for ResutlSet
  	 * parameters
  	 */
  	int startPosition = 0;
  
  	/*
  	 * (non-Javadoc)
  	 * 
  	 * @see com.hrx.rasp.util.dao.ResultSetProcessor#create(java.sql.ResultSet,
  	 * java.lang.Class)
  	 */
  	public List<E> create(ResultSet rs, Class<E> resultClass, boolean isSecret) throws SQLException, StoredProcedureProccessResultException
  	{
  
  		if (rs == null)
  		{
  			return null;
  		}
  		// Generate an ArrayList for results
  		List<E> values = null;
  
  		values = processConstructor(rs, resultClass, isSecret);
  		if (values == null)
  		{
  			try
  			{
  				values = processColumnSetters(rs, resultClass);
  			}
  			catch (InstantiationException e)
  			{
  				throw new StoredProcedureProccessResultException(resultClass.getCanonicalName(), e);
  			}
  			catch (IllegalAccessException e)
  			{
 				throw new StoredProcedureProccessResultException(resultClass.getCanonicalName(), e);
 			}
 		}
 		return values;
 	}
 
 	/***
 	 * @param rs
 	 * @param resultClass
 	 * @param values
 	 * @return
 	 * @throws StoredProcedureProccessResultException
 	 */
 	private List<E> processConstructor(ResultSet rs, Class<E> resultClass, boolean isSecret) throws StoredProcedureProccessResultException
 	{
 		try
 		{
 			Constructor<E> constuctor = findConstructor(resultClass);
 
 			if (constuctor != null)
 			{
 				int endRecord = startPosition + maxResult;
 				List<E> values = new ArrayList<E>();
 				// transform the record into Java Return Objects
 				while (rs.next() && (maxResult == 0 || rs.getRow() < endRecord))
 				{
 					if (rs.getRow() >= startPosition)
 					{
 						if (!isSecret && log.isTraceEnabled())
 						{
 							StoredProcUtility.dumpResultSetRecord(rs);
 						}
 						
 						E value = MetadataHelper.createInstance(rs, constuctor);
 						values.add(value);
 					}
 				}
 				return values;
 			}
 		}
 		catch (Exception e)
 		{
 			throw new StoredProcedureProccessResultException(e);
 		}
 		return null;
 	}
 
 	/***
 	 * Find the constructor to use for the Result List. It must be annotated
 	 * with DAOConstructor annotation.
 	 * 
 	 * @param constrs
 	 * @return
 	 */
 	protected Constructor<E> findConstructorWithAnnotation(Constructor<E>[] constrs)
 	{
 		/***
 		 * Find the DAO constructor that has been annotated with DAOConstructor
 		 * annotation. This will be used to create the new DAO instances for
 		 * each database record returned in the database ResultSet
 		 * 
 		 */
 		for (Constructor<E> cons : constrs)
 		{
 			if (cons.isAnnotationPresent(DAOConstructor.class))
 			{
 				return cons;
 			}
 		}
 		return null;
 	}
 
 	@SuppressWarnings("unchecked")
 	private Constructor<E> findConstructor(Class<E> resultClass) throws SQLException
 	{
 		Constructor<E>[] constrs = (Constructor<E>[]) resultClass.getConstructors();
 		Constructor<E> constuctor = findConstructorWithAnnotation(constrs);
 		return constuctor;
 	}
 
 	/***
 	 * @param spMetaData
 	 * @param returnType
 	 * @throws SQLException
 	 * @throws IllegalAccessException
 	 * @throws InstantiationException
 	 * @throws StoredProcedureProccessResultException
 	 */
 	private List<E> processColumnSetters(ResultSet rs, Class<E> resultClass) throws SQLException, InstantiationException, IllegalAccessException,
 					StoredProcedureProccessResultException
 	{
 		/*
 		 * If no annotated constructor found, just try any available
 		 * constructor.
 		 */
 
 		if (resultClass.isAnnotationPresent(Entity.class))
 		{
 			try
 			{
 				List<E> entities = new ArrayList<E>();
 
 				Field[] fields = resultClass.getDeclaredFields();
 				// transform the record into Java Return Objects
 
 				int endRecord = startPosition + maxResult;
 
 				// transform the record into Java Return Objects
 				while (rs.next() && (maxResult == 0 || rs.getRow() < endRecord))
 				{
 					if (rs.getRow() >= startPosition)
 					{
 						StoredProcUtility.dumpResultSetRecord(log, rs);
 						E entity = resultClass.newInstance();
 						for (Field field : fields)
 						{
 							if (field.isAnnotationPresent(Column.class))
 							{
 								Object value = getValue(rs, field);
 								MetadataHelper.setPropertyValue(field, value, entity);
 							}
 							else if (field.isAnnotationPresent(EmbeddedId.class))
 							{
 								// set the pk fields
 								Class<?> pkClass = field.getClass();
 								Object pk = pkClass.newInstance();
 								for (Field pkField : pkClass.getDeclaredFields())
 								{
 									if (pkField.isAnnotationPresent(Column.class))
 									{
 										Object value = getValue(rs, pkField);
 										MetadataHelper.setPropertyValue(pkField, value, pk);
 									}
 								}
 								MetadataHelper.setPropertyValue(field, pk, entity);
 							}
 						}
 						entities.add(entity);
 						if (log.isTraceEnabled())
 						{
 							log.trace("Process setter parameters succesful for entity:'" + entity.toString() + "'");
 						}
 					}
 				}
 				return entities;
 			}
 			catch (Exception e)
 			{
 				throw new StoredProcedureProccessResultException("Result Set Entity processor error.", e);
 			}
 		}
 		throw new StoredProcedureProccessResultException("Expect an Entity bean. The '" + resultClass.getName() + "' class is not an Entity.");
 	}
 
 	private Object getValue(ResultSet rs, Field field) throws SQLException, StoredProcedureProccessResultException
 	{
 		Column column = field.getAnnotation(Column.class);
 		String columnName = column.name();
 		if (columnName.length() == 0)
 		{
 			// Use the field name if the property name is not defined.
 			columnName = field.getName();
 		}
 		Class<?> type = ((Field) field).getType();
 		Object value;
 		try
 		{
 			int columnIndex = rs.findColumn(columnName);
 			value = StoredProcUtility.getResultSetObject(rs, columnIndex, type);
 		}
 		catch (SQLException e)
 		{
 			value = null;
 		}
 		return value;
 	}
 
 	/***
 	 * @return the maxResult
 	 */
 	public int getMaxResult()
 	{
 		return maxResult;
 	}
 
 	/***
 	 * @param maxResult
 	 *            the maxResult to set
 	 */
 	public void setMaxResult(int maxResult)
 	{
 		this.maxResult = maxResult;
 	}
 
 	/***
 	 * @return the startPosition
 	 */
 	public int getStartPosition()
 	{
 		return startPosition;
 	}
 
 	/***
 	 * @param startPosition
 	 *            the startPosition to set
 	 */
 	public void setStartPosition(int startPosition)
 	{
 		this.startPosition = startPosition;
 	}
 
 }