/*

    * Copyright 2007 Daniel Spiewak

    * 

    * Licensed under the Apache License, Version 2.0 (the "License"); 

    * you may not use this file except in compliance with the License. 

    * You may obtain a copy of the License at

    * 

    *	    http://www.apache.org/licenses/LICENSE-2.0 

    * 

   * Unless required by applicable law or agreed to in writing, software 

   * distributed under the License is distributed on an "AS IS" BASIS,

   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

   * See the License for the specific language governing permissions and

   * limitations under the License.

   */

  package net.java.ao;

  import com.google.common.base.Defaults;

  import net.java.ao.schema.FieldNameConverter;

  import net.java.ao.schema.TableNameConverter;

  import net.java.ao.schema.info.FieldInfo;

  import net.java.ao.schema.info.EntityInfo;

  import net.java.ao.types.TypeInfo;

  import net.java.ao.types.TypeManager;

  import java.beans.PropertyChangeEvent;

  import java.beans.PropertyChangeListener;

  import java.lang.reflect.Array;

  import java.lang.reflect.InvocationHandler;

  import java.lang.reflect.Method;

  import java.math.BigDecimal;

  import java.sql.Connection;

  import java.sql.PreparedStatement;

  import java.sql.ResultSet;

  import java.sql.SQLException;

  import java.util.ArrayList;

  import java.util.HashMap;

  import java.util.HashSet;

  import java.util.LinkedHashSet;

  import java.util.LinkedList;

  import java.util.List;

  import java.util.Map;

  import java.util.Set;

  import java.util.concurrent.locks.Lock;

  import java.util.concurrent.locks.ReentrantLock;

  import static net.java.ao.Common.getAttributeTypeFromMethod;

  import static net.java.ao.Common.preloadValue;

  import static net.java.ao.Common.where;

  import static net.java.ao.sql.SqlUtils.closeQuietly;

  public class EntityProxy<T extends RawEntity<K>, K> implements InvocationHandler

  {

  	private final K key;

  	private final EntityInfo<T, K> entityInfo;

  	private final EntityManager manager;

      private final Map<String, Object> values = new HashMap<String, Object>();

      private final Set<String> dirty = new HashSet<String>();

      private final Lock lockValuesDirty = new ReentrantLock();

  	private ImplementationWrapper<T> implementation;

  	private List<PropertyChangeListener> listeners;

  	EntityProxy(EntityManager manager, EntityInfo<T, K> entityInfo, K key) {

  		this.key = key;

  		this.entityInfo = entityInfo;

  		this.manager = manager;

  		listeners = new LinkedList<PropertyChangeListener>();

  	}

      private FieldNameConverter getFieldNameConverter()

      {

          return manager.getNameConverters().getFieldNameConverter();

      }

      @SuppressWarnings("unchecked")

  	public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {

          final String methodName = method.getName();

          if(methodName.equals("getEntityProxy")) {

              return this;

          }

  		if (methodName.equals("getEntityType")) {

  			return getType();

  		}

  		if (implementation == null) {

  			implementation = new ImplementationWrapper<T>();

  			implementation.init((T) proxy);

  		}

  		final MethodImplWrapper methodImpl = implementation.getMethod(methodName, method.getParameterTypes());

 		if (methodImpl != null) {

 			final Class<?> declaringClass = methodImpl.getMethod().getDeclaringClass();

 			if (!Object.class.equals(declaringClass)) {

                 // We don't want to return get the class Class using Class.forName as this doesn't play well

                 // with multiple ClassLoaders (if the AO library has a separate class loader to the AO client)

                 // Instead just compare the classNames

 				final String callingClassName = Common.getCallingClassName(1);

 				if (callingClassName == null || !callingClassName.equals(declaringClass.getName())) {

 					return methodImpl.getMethod().invoke(methodImpl.getInstance(), args);

 				}

 			}

 		}

 		if (entityInfo.hasAccessor(method) && entityInfo.getField(method).equals(entityInfo.getPrimaryKey())) {

 			return getKey();

 		}

         if (methodName.equals("save")) {

 			save((RawEntity<K>) proxy);

 			return Void.TYPE;

 		}

         if (methodName.equals("getEntityManager")) {

             return manager;

         }

         if (methodName.equals("addPropertyChangeListener")) {

 			addPropertyChangeListener((PropertyChangeListener) args[0]);

 			return null;

 		}

         if (methodName.equals("removePropertyChangeListener")) {

 			removePropertyChangeListener((PropertyChangeListener) args[0]);

 			return null;

 		}

         if (methodName.equals("hashCode")) {

 			return hashCodeImpl();

 		}

         if (methodName.equals("equals")) {

 			return equalsImpl((RawEntity<K>) proxy, args[0]);

 		}

         if (methodName.equals("toString")) {

 			return toStringImpl();

 		}

         if (methodName.equals("init")) {

 			return null;

 		}

         final FieldInfo fieldInfo = entityInfo.getField(method);

         if (fieldInfo != null && !fieldInfo.isNullable() && args != null && args.length > 0) {

             if (args[0] == null) {

                 throw new IllegalArgumentException("Field '" + getFieldNameConverter().getName(method) + "' does not accept null values");

             }

         }

         // TODO move this information into EntityInfo and friends

         final OneToOne oneToOneAnnotation = method.getAnnotation(OneToOne.class);

         final boolean isOneToOne = oneToOneAnnotation != null && RawEntity.class.isAssignableFrom(method.getReturnType());

         final OneToMany oneToManyAnnotation = method.getAnnotation(OneToMany.class);

         final boolean isOneToMany = oneToManyAnnotation != null && method.getReturnType().isArray() && RawEntity.class.isAssignableFrom(method.getReturnType().getComponentType());

         final ManyToMany manyToManyAnnotation = method.getAnnotation(ManyToMany.class);

         final boolean isManyToMany = manyToManyAnnotation != null && method.getReturnType().isArray() && RawEntity.class.isAssignableFrom(method.getReturnType().getComponentType());

         if (isOneToOne || isOneToMany || isManyToMany) {

             final Object ret;

             lockValuesDirty.lock();

             try {

                 if (values.containsKey(methodName)) {

                     ret = values.get(methodName);

                 } else if (isOneToOne) {

                     if (oneToOneAnnotation.reverse().isEmpty()) {

                         ret = legacyFetchOneToOne((RawEntity<K>) proxy, method, oneToOneAnnotation);

                     } else {

                         ret = fetchOneToOne(method, oneToOneAnnotation);

                     }

                     values.put(methodName, ret);

                 } else if (isOneToMany) {

                     if (oneToManyAnnotation.reverse().isEmpty()) {

                         ret = legacyFetchOneToMany((RawEntity<K>) proxy, method, oneToManyAnnotation);

                     } else {

                         ret = fetchOneToMany(method, oneToManyAnnotation);

                     }

                     values.put(methodName, ret);

                 } else if (isManyToMany) {

                     if (manyToManyAnnotation.reverse().isEmpty() || manyToManyAnnotation.through().isEmpty()) {

                         ret = legacyFetchManyToMany((RawEntity<K>) proxy, method, manyToManyAnnotation);

                     } else {

                         ret = fetchManyToMany(method, manyToManyAnnotation);

                     }

                     values.put(methodName, ret);

                 } else {

                     ret = null;

                 }

             } finally {

                 lockValuesDirty.unlock();

             }

             return ret;

         }

         if (fieldInfo != null) {

             if (method.equals(fieldInfo.getAccessor())) {

                 return invokeGetter(fieldInfo);

             }

             if (method.equals(fieldInfo.getMutator())) {

                 invokeSetter(getFieldNameConverter().getName(method), args[0], fieldInfo.getPolymorphicName());

                 return Void.TYPE;

             }

         }

 		throw new IllegalArgumentException("Cannot handle method. It is not a valid getter or setter and does not have an implementation supplied. " +

                 "Signature: " + method.toString());

 	}

     private RawEntity[] fetchManyToMany(final Method method, final ManyToMany annotation) throws SQLException, NoSuchMethodException

     {

         final Class remoteType = method.getReturnType().getComponentType();

         final Class throughType = annotation.value();

         final String whereClause = Common.where(annotation, getFieldNameConverter());

         final Preload preloadAnnotation = (Preload) remoteType.getAnnotation(Preload.class);

         final Method reverseMethod = throughType.getMethod(annotation.reverse());

         final Method throughMethod = throughType.getMethod(annotation.through());

         final String reversePolymorphicTypeFieldName = getAttributeTypeFromMethod(reverseMethod).isAnnotationPresent(Polymorphic.class) ? getFieldNameConverter().getPolyTypeName(reverseMethod) : null;

         final String remotePolymorphicTypeFieldName = getAttributeTypeFromMethod(throughMethod).isAnnotationPresent(Polymorphic.class) ? getFieldNameConverter().getPolyTypeName(throughMethod) : null;

         final String returnField = getFieldNameConverter().getName(throughMethod);

         final Set<String> selectFields = new LinkedHashSet<String>();

         final DatabaseProvider provider = manager.getProvider();

         final StringBuilder sql = new StringBuilder("SELECT t.").append(provider.processID(returnField));

         if (remotePolymorphicTypeFieldName != null) {

             sql.append(", t.").append(provider.processID(remotePolymorphicTypeFieldName));

         } else {

             if (preloadAnnotation != null) {

                 selectFields.addAll(preloadValue(preloadAnnotation, getFieldNameConverter()));

             } else {

                 selectFields.addAll(Common.getValueFieldsNames(manager.resolveEntityInfo(remoteType), getFieldNameConverter()));

             }

             if (selectFields.contains(Preload.ALL)) {

                 sql.append(", r.*");

             } else {

                 for (final String field : selectFields) {

                     sql.append(", r.").append(manager.getProvider().processID(field));

                 }

             }

         }

         final String throughTable = provider.withSchema(getTableNameConverter().getName(throughType));

         sql.append(" FROM ").append(throughTable).append(" t ");

         final String remotePrimaryKeyField = Common.getPrimaryKeyField(remoteType, getFieldNameConverter());

         if (!selectFields.isEmpty()) {

             final String remoteTable = provider.withSchema(getTableNameConverter().getName(remoteType));

             sql.append(" INNER JOIN ").append(remoteTable).append(" r ON t.").append(provider.processID(returnField)).append(" = r.").append(provider.processID(remotePrimaryKeyField));

         }

         final String reverseField = provider.processID(getFieldNameConverter().getName(reverseMethod));

         sql.append(" WHERE ");

         if (!selectFields.isEmpty()) {

             sql.append("t.");

         }

         sql.append(reverseField).append(" = ?");

         if (reversePolymorphicTypeFieldName != null)

         {

             sql.append(" AND ");

             if (!selectFields.isEmpty()) {

                 sql.append("t.");

             }

             sql.append(provider.processID(reversePolymorphicTypeFieldName)).append(" = ?");

         }

         if (!whereClause.trim().equals(""))

         {

             sql.append(" AND (").append(provider.processWhereClause(whereClause)).append(")");

         }

         final List<RawEntity> back = new ArrayList<RawEntity>();

         final Connection conn = provider.getConnection();

         try

         {

             final PreparedStatement stmt = provider.preparedStatement(conn, sql);

             try

             {

                 final TypeInfo<K> dbType = getTypeManager().getType(getClass(key));

                 dbType.getLogicalType().putToDatabase(manager, stmt, 1, key, dbType.getJdbcWriteType());

                 if (reversePolymorphicTypeFieldName != null)

                 {

                     stmt.setString(2, manager.getPolymorphicTypeMapper().convert(entityInfo.getEntityType()));

                 }

                 final TypeInfo<K> primaryKeyType = Common.getPrimaryKeyType(provider.getTypeManager(), (Class<? extends RawEntity<K>>) remoteType);

                 final ResultSet res = stmt.executeQuery();

                 try

                 {

                     while (res.next())

                     {

                         EntityInfo entityInfo = manager.resolveEntityInfo((remotePolymorphicTypeFieldName == null ? remoteType : manager.getPolymorphicTypeMapper().invert(remoteType, res.getString(remotePolymorphicTypeFieldName))));

                         if (selectFields.remove(Preload.ALL))

                         {

                             selectFields.addAll(entityInfo.getFieldNames());

                         }

                         final RawEntity returnValueEntity = manager.peer(entityInfo, primaryKeyType.getLogicalType().pullFromDatabase(manager, res, throughType, returnField));

                         final EntityProxy<?, ?> proxy = manager.getProxyForEntity(returnValueEntity);

                         proxy.lockValuesDirty.lock();

                         try

                         {

                             for (final String field : selectFields)

                             {

                                 proxy.values.put(field, res.getObject(field));

                             }

                         }

                         finally

                         {

                             proxy.lockValuesDirty.unlock();

                         }

                         back.add(returnValueEntity);

                     }

                 }

                 finally

                 {

                     res.close();

                 }

             }

             finally

             {

                 stmt.close();

             }

         }

         finally

         {

             conn.close();

         }

         return back.toArray((RawEntity[]) Array.newInstance(remoteType, back.size()));

     }

     private RawEntity[] fetchOneToMany(final Method method, final OneToMany annotation) throws SQLException, NoSuchMethodException

     {

         final Class remoteType = method.getReturnType().getComponentType();

         final EntityInfo entityInfo = manager.resolveEntityInfo(remoteType);

         final String remotePrimaryKeyFieldName = Common.getPrimaryKeyField(remoteType, getFieldNameConverter());

         final String whereClause = where(annotation, getFieldNameConverter());

         final Preload preloadAnnotation = (Preload) remoteType.getAnnotation(Preload.class);

         final Method remoteMethod = remoteType.getMethod(annotation.reverse());

         final String remotePolymorphicTypeFieldName = getPolymorphicTypeFieldName(remoteMethod);

         final StringBuilder sql = new StringBuilder("SELECT ");

         final Set<String> selectFields = new LinkedHashSet<String>();

         selectFields.add(remotePrimaryKeyFieldName);

         if (remotePolymorphicTypeFieldName == null) {

             if (preloadAnnotation != null) {

                 selectFields.addAll(preloadValue(preloadAnnotation, getFieldNameConverter()));

             } else {

                 selectFields.addAll(Common.getValueFieldsNames(entityInfo, getFieldNameConverter()));

             }

         }

         if (selectFields.contains(Preload.ALL)) {

             sql.append(Preload.ALL);

         } else {

             for (final String field : selectFields) {

                 sql.append(manager.getProvider().processID(field)).append(',');

             }

             sql.setLength(sql.length() - 1);

         }

         sql.append(" FROM ").append(manager.getProvider().withSchema(getTableNameConverter().getName(remoteType)));

         sql.append(" WHERE ").append(manager.getProvider().processID(getFieldNameConverter().getName(remoteMethod))).append(" = ?");

         if (!whereClause.trim().equals("")) {

             sql.append(" AND (").append(manager.getProvider().processWhereClause(whereClause)).append(")");

         }

         if (remotePolymorphicTypeFieldName != null) {

             sql.append(" AND ").append(manager.getProvider().processID(remotePolymorphicTypeFieldName)).append(" = ?");

         }

         final Connection conn = manager.getProvider().getConnection();

         try {

             final PreparedStatement stmt = manager.getProvider().preparedStatement(conn, sql);

             try

             {

                 final TypeInfo<K> dbType = getTypeManager().getType(getClass(key));

                 dbType.getLogicalType().putToDatabase(manager, stmt, 1, key, dbType.getJdbcWriteType());

                 if (remotePolymorphicTypeFieldName != null) {

                     stmt.setString(2, manager.getPolymorphicTypeMapper().convert(entityInfo.getEntityType()));

                 }

                 final ResultSet res = stmt.executeQuery();

                 try {

                     final List<RawEntity<?>> result = new ArrayList<RawEntity<?>>();

                     while (res.next()) {

                         final Object returnValue = Common.getPrimaryKeyType(getTypeManager(), (Class) remoteType).getLogicalType().pullFromDatabase(manager, res, (Class) remoteType, remotePrimaryKeyFieldName);

                         final RawEntity<?> returnValueEntity = manager.peer(entityInfo, returnValue);

                         final EntityProxy<?, ?> proxy = manager.getProxyForEntity(returnValueEntity);

                         if (selectFields.remove(Preload.ALL))

                         {

                             selectFields.addAll(entityInfo.getFieldNames());

                         }

                         proxy.lockValuesDirty.lock();

                         try {

                             for (final String field : selectFields) {

                                 proxy.values.put(field, res.getObject(field));

                             }

                         } finally {

                             proxy.lockValuesDirty.unlock();

                         }

                         result.add(returnValueEntity);

                     }

                     return result.toArray((RawEntity<?>[]) Array.newInstance(remoteType, result.size()));

                 } finally {

                     res.close();

                 }

             } finally {

                 stmt.close();

             }

         } finally {

             conn.close();

         }

     }

     private String getPolymorphicTypeFieldName(final Method remoteMethod)

     {

         final Class<?> attributeType = getAttributeTypeFromMethod(remoteMethod);

         return attributeType != null && attributeType.isAssignableFrom(getType())

                 && attributeType.isAnnotationPresent(Polymorphic.class) ? getFieldNameConverter().getPolyTypeName(remoteMethod) : null;

     }

     private RawEntity fetchOneToOne(final Method method, final OneToOne annotation) throws SQLException, NoSuchMethodException

     {

         final Class remoteType = method.getReturnType();

         final EntityInfo entityInfo = manager.resolveEntityInfo(remoteType);

         final String remotePrimaryKeyFieldName = Common.getPrimaryKeyField(remoteType, getFieldNameConverter());

         final String whereClause = Common.where(annotation, getFieldNameConverter());

         final Method remoteMethod = remoteType.getMethod(annotation.reverse());

         final String remotePolymorphicTypeFieldName = getPolymorphicTypeFieldName(remoteMethod);

         final Preload preloadAnnotation = (Preload) remoteType.getAnnotation(Preload.class);

         final StringBuilder sql = new StringBuilder("SELECT ");

         final Set<String> selectFields = new LinkedHashSet<String>();

         selectFields.add(remotePrimaryKeyFieldName);

         if (remotePolymorphicTypeFieldName == null) {

             if (preloadAnnotation != null) {

                 selectFields.addAll(preloadValue(preloadAnnotation, getFieldNameConverter()));

             } else {

                 selectFields.addAll(Common.getValueFieldsNames(entityInfo, getFieldNameConverter()));

             }

         }

         if (selectFields.contains(Preload.ALL)) {

             sql.append(Preload.ALL);

         } else {

             for (final String field : selectFields) {

                 sql.append(manager.getProvider().processID(field)).append(',');

             }

             sql.setLength(sql.length() - 1);

         }

         sql.append(" FROM ").append(manager.getProvider().withSchema(getTableNameConverter().getName(remoteType)));

         sql.append(" WHERE ").append(manager.getProvider().processID(getFieldNameConverter().getName(remoteMethod))).append(" = ?");

         if (whereClause.trim().length() != 0)

         {

             sql.append(" AND (").append(manager.getProvider().processWhereClause(whereClause)).append(")");

         }

         if (remotePolymorphicTypeFieldName != null)

         {

             sql.append(" AND ").append(manager.getProvider().processID(remotePolymorphicTypeFieldName)).append(" = ?");

         }

         final Connection conn = manager.getProvider().getConnection();

         try

         {

             final PreparedStatement stmt = manager.getProvider().preparedStatement(conn, sql);

             try

             {

                 final TypeInfo<K> dbType = getTypeManager().getType(getClass(key));

                 dbType.getLogicalType().putToDatabase(manager, stmt, 1, key, dbType.getJdbcWriteType());

                 if (remotePolymorphicTypeFieldName != null)

                 {

                     stmt.setString(2, manager.getPolymorphicTypeMapper().convert(entityInfo.getEntityType()));

                 }

                 final ResultSet res = stmt.executeQuery();

                 try

                 {

                     if (res.next())

                     {

                         final RawEntity returnValueEntity = manager.peer(entityInfo, Common.getPrimaryKeyType(getTypeManager(), (Class<? extends RawEntity<K>>) remoteType).getLogicalType().pullFromDatabase(manager, res, (Class<K>) remoteType, remotePrimaryKeyFieldName));

                         if (selectFields.remove(Preload.ALL))

                         {

                             selectFields.addAll(entityInfo.getFieldNames());

                         }

                         final EntityProxy<?, ?> proxy = manager.getProxyForEntity(returnValueEntity);

                         proxy.lockValuesDirty.lock();

                         try

                         {

                             for (final String field : selectFields)

                             {

                                 proxy.values.put(field, res.getObject(field));

                             }

                         }

                         finally

                         {

                             proxy.lockValuesDirty.unlock();

                         }

                         return returnValueEntity;

                     }

                     else

                     {

                         return null;

                     }

                 }

                 finally

                 {

                     res.close();

                 }

             }

             finally

             {

                 stmt.close();

             }

         }

         finally

         {

             conn.close();

         }

     }

    

     @Deprecated

     private RawEntity[] legacyFetchManyToMany(final RawEntity<K> proxy, final Method method, final ManyToMany manyToManyAnnotation) throws SQLException

     {

         final Class<? extends RawEntity<?>> throughType = manyToManyAnnotation.value();

         final Class<? extends RawEntity<?>> type = (Class<? extends RawEntity<?>>) method.getReturnType().getComponentType();

         return retrieveRelations(proxy, null,

                 Common.getMappingFields(getFieldNameConverter(),

                         throughType, type), throughType, (Class<? extends RawEntity>) type,

                         Common.where(manyToManyAnnotation, getFieldNameConverter()),

                         Common.getPolymorphicFieldNames(getFieldNameConverter(), throughType, entityInfo.getEntityType()),

                         Common.getPolymorphicFieldNames(getFieldNameConverter(), throughType, type));

     }

    

     @Deprecated

     private RawEntity[] legacyFetchOneToMany(final RawEntity<K> proxy, final Method method, final OneToMany oneToManyAnnotation) throws SQLException

     {

         final Class<? extends RawEntity<?>> type = (Class<? extends RawEntity<?>>) method.getReturnType().getComponentType();

         return retrieveRelations(proxy, new String[0],

                 new String[] { Common.getPrimaryKeyField(type, getFieldNameConverter()) },

                 (Class<? extends RawEntity>) type, where(oneToManyAnnotation, getFieldNameConverter()),

                 Common.getPolymorphicFieldNames(getFieldNameConverter(), type, entityInfo.getEntityType()));

     }

    

     @Deprecated

     private RawEntity legacyFetchOneToOne(final RawEntity<K> proxy, final Method method, final OneToOne oneToOneAnnotation) throws SQLException

     {

         Class<? extends RawEntity<?>> type = (Class<? extends RawEntity<?>>) method.getReturnType();

         final RawEntity[] back = retrieveRelations(proxy, new String[0],

                 new String[] { Common.getPrimaryKeyField(type, getFieldNameConverter()) },

                 (Class<? extends RawEntity>) type, Common.where(oneToOneAnnotation, getFieldNameConverter()),

                 Common.getPolymorphicFieldNames(getFieldNameConverter(), type, entityInfo.getEntityType()));

         return back.length == 0 ? null : back[0];

     }

     private TableNameConverter getTableNameConverter()

     {

         return manager.getNameConverters().getTableNameConverter();

     }

     public K getKey() {

 		return key;

 	}

 	@SuppressWarnings("unchecked")

 	public void save(RawEntity entity) throws SQLException {

         lockValuesDirty.lock();

         try {

             if (dirty.isEmpty()) {

                 return;

             }

             String table = entityInfo.getName();

             final DatabaseProvider provider = this.manager.getProvider();

             final TypeManager typeManager = provider.getTypeManager();

             Connection conn = null;

             PreparedStatement stmt = null;

             try

             {

                 conn = provider.getConnection();

                 StringBuilder sql = new StringBuilder("UPDATE " + provider.withSchema(table) + " SET ");

                 for (String name : dirty) {

                     sql.append(provider.processID(name));

                     if (values.containsKey(name)) {

                         sql.append(" = ?,");

                     } else {

                         sql.append(" = NULL,");

                     }

                 }

                 if (sql.charAt(sql.length() - 1) == ',') {

                     sql.setLength(sql.length() - 1);

                 }

                 sql.append(" WHERE ").append(provider.processID(entityInfo.getPrimaryKey().getName())).append(" = ?");