/**
    * Copyright 2005-2014 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    *
   * 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 org.kuali.rice.krad.data.jpa;
  
  import org.kuali.rice.core.api.data.DataType;
  import org.kuali.rice.krad.data.metadata.DataObjectAttribute;
  import org.kuali.rice.krad.data.metadata.DataObjectAttributeRelationship;
  import org.kuali.rice.krad.data.metadata.DataObjectCollection;
  import org.kuali.rice.krad.data.metadata.DataObjectMetadata;
  import org.kuali.rice.krad.data.metadata.DataObjectRelationship;
  import org.kuali.rice.krad.data.metadata.impl.DataObjectAttributeImpl;
  import org.kuali.rice.krad.data.metadata.impl.DataObjectAttributeRelationshipImpl;
  import org.kuali.rice.krad.data.metadata.impl.DataObjectCollectionImpl;
  import org.kuali.rice.krad.data.metadata.impl.DataObjectMetadataImpl;
  import org.kuali.rice.krad.data.metadata.impl.DataObjectRelationshipImpl;
  import org.kuali.rice.krad.data.provider.annotation.ExtensionFor;
  import org.kuali.rice.krad.data.provider.impl.MetadataProviderBase;
  
  import javax.persistence.EntityManager;
  import javax.persistence.metamodel.Attribute.PersistentAttributeType;
  import javax.persistence.metamodel.EmbeddableType;
  import javax.persistence.metamodel.EntityType;
  import javax.persistence.metamodel.IdentifiableType;
  import javax.persistence.metamodel.PluralAttribute;
  import javax.persistence.metamodel.SingularAttribute;
  import java.lang.reflect.Field;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  /**
   * A superclass which handles most of the JPA metadata extraction.
   *
   * <p>
   * It handles everything which can be done via the standard javax.persistence annotations. Any implementation-specific
   * annotations must be processed in the provided abstract hook methods.
   * </p>
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public abstract class JpaMetadataProviderImpl extends MetadataProviderBase implements JpaMetadataProvider {
  	private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(JpaMetadataProviderImpl.class);
  
      /**
       * The entity manager used in interacting with the database.
       */
  	protected EntityManager entityManager;
  
  	/**
  	 * Hook called after all "standard" annotations are processed to perform any further extraction based on the
  	 * internals of the JPA implementation.
       *
       * @param metadata The metadata for the data object.
       * @param entityType The entity type of the data object.
  	 */
  	protected abstract void populateImplementationSpecificEntityLevelMetadata(DataObjectMetadataImpl metadata,
  			EntityType<?> entityType);
  
  	/**
  	 * Hook called after all "standard" attribute-level annotations are processed to perform any further extraction
  	 * based on the internals of the JPA implementation.
       *
       * @param attribute The attribute metadata for the data object.
       * @param attr The persistent single-valued property or field.
  	 */
      protected abstract void populateImplementationSpecificAttributeLevelMetadata(DataObjectAttributeImpl attribute,
  			SingularAttribute<?, ?> attr);
  
  	/**
  	 * Hook called after all "standard" field-level annotations are processed on attributes identified as "plural" to
  	 * perform any further extraction based on the internals of the JPA implementation.
       *
       * @param collection The collection metadata for the data object.
       * @param cd The persistent collection-valued attribute.
  	 */
      protected abstract void populateImplementationSpecificCollectionLevelMetadata(DataObjectCollectionImpl collection,
  			PluralAttribute<?, ?, ?> cd);
  
  	/**
  	 * Hook called after all "standard" field-level annotations are processed on attributes identified as "associations"
  	 * to perform any further extraction based on the internals of the JPA implementation.
       *
      * @param relationship The relationship metadata for the data object.
      * @param rd The persistent single-valued property or field.
 	 */
     protected abstract void populateImplementationSpecificRelationshipLevelMetadata(
 			DataObjectRelationshipImpl relationship, SingularAttribute<?, ?> rd);
 
     /**
      * {@inheritDoc}
      */
 	@Override
 	public abstract DataObjectRelationship addExtensionRelationship(Class<?> entityClass, String extensionPropertyName,
 			Class<?> extensionEntity);
 
     /**
      * {@inheritDoc}
      */
 	@Override
 	protected synchronized void initializeMetadata(Collection<Class<?>> types) {
 		LOG.info("Initializing JPA Metadata from " + entityManager);
 		
 		masterMetadataMap.clear();
 		// QUESTION: When is JPA loaded so this service can initialize itself?
 		// Build and store the map
 
 		for ( IdentifiableType<?> identifiableType : entityManager.getMetamodel().getEntities() ) {
             //Only extract the metadata if EntityType and not a MappedSuperClass
             if(identifiableType instanceof EntityType<?>){
                 EntityType<?> type = (EntityType<?>)identifiableType;
                 try {
                     masterMetadataMap.put(type.getBindableJavaType(), getMetadataForClass(type.getBindableJavaType()));
                     if (LOG.isDebugEnabled()) {
                         LOG.debug("Added Metadata For: " + type.getBindableJavaType());
                     }
                 } catch (Exception ex) {
                     LOG.error("Error obtaining JPA metadata for type: " + type.getJavaType(), ex);
                 }
 			}
 		}
 	}
 
 	/**
 	 * Extracts the data from the JPA Persistence Unit. This code assumes that the given class is persistable.
 	 * 
 	 * @param persistableClass Class which will be looked up in OJB's static descriptor repository.
 	 * @return the metadata for the class
 	 */
 	@SuppressWarnings("unchecked")
 	public DataObjectMetadata getMetadataForClass(Class<?> persistableClass) {
         // first, let's scan for extensions
         List<DataObjectRelationship> relationships = new ArrayList<DataObjectRelationship>();
         Map<Class<?>, Class<?>> extensionMap = new HashMap<Class<?>, Class<?>>();
         for (EntityType<?> entityType : getEntityManager().getMetamodel().getEntities()) {
             if (entityType.getJavaType().isAnnotationPresent(ExtensionFor.class)) {
                 ExtensionFor extensionFor = entityType.getJavaType().getAnnotation(ExtensionFor.class);
                 if (extensionFor.value().equals(persistableClass)) {
                     DataObjectRelationship relationship =
                             addExtensionRelationship(persistableClass, extensionFor.extensionPropertyName(), entityType.getJavaType());
                     // have to do this because even though we've added the DatabaseMapping in EclipseLink, it will not
                     // rebuild the JPA metamodel for us
                     relationships.add(relationship);
                 }
             }
         }
         // now let's build us some metadata!
 		DataObjectMetadataImpl metadata = new DataObjectMetadataImpl();
 		EntityType<?> entityType = entityManager.getMetamodel().entity(persistableClass);
 		metadata.setProviderName(this.getClass().getSimpleName());
 		metadata.setType(persistableClass);
 		metadata.setName(persistableClass.getSimpleName());
 		metadata.setReadOnly(false);
 		
 		metadata.setSupportsOptimisticLocking(entityType.hasVersionAttribute());
 		populateImplementationSpecificEntityLevelMetadata(metadata, entityType);
 
 		// PK Extraction
 		try {
 			metadata.setPrimaryKeyAttributeNames(getPrimaryKeyAttributeNames(entityType));
 		} catch (RuntimeException ex) {
 			LOG.error("Error processing PK metadata for " + entityType.getBindableJavaType().getName());
 			throw new RuntimeException(
 					"Error processing PK metadata for " + entityType.getBindableJavaType().getName(), ex);
 		}
 
 		// Main Attribute Extraction
 		try {
 			List<DataObjectAttribute> attributes = getSingularAttributes(persistableClass,
 					entityType.getSingularAttributes(), metadata.getPrimaryKeyAttributeNames());
 			for (DataObjectAttribute attr : attributes) {
 				metadata.getOrderedAttributeList().add(attr.getName());
 			}
 			metadata.setAttributes(attributes);
 		} catch (RuntimeException ex) {
 			LOG.error("Error processing attribute metadata for " + entityType.getBindableJavaType().getName());
 			throw ex;
 		}
 
 		// Collection Extraction
 		try {
 			metadata.setCollections(getCollectionsFromMetadata((Set) entityType.getPluralAttributes()));
 		} catch (RuntimeException ex) {
 			LOG.error("Error processing collection metadata for " + entityType.getBindableJavaType().getName());
 			throw ex;
 		}
 
 		// Reference/Relationship Extraction
 		try {
             relationships.addAll(getRelationships(entityType.getSingularAttributes()));
 			metadata.setRelationships(relationships);
 		} catch (RuntimeException ex) {
 			LOG.error("Error processing relationship metadata for " + entityType.getBindableJavaType().getName());
 			throw ex;
 		}
 
 		return metadata;
 	}
 
     /**
      * Gets the attribute names for the primary keys from the given entity type.
      *
      * @param entityType The entity type of the data object.
      * @return A list of primary key attribute names.
      */
 	protected List<String> getPrimaryKeyAttributeNames(EntityType<?> entityType) {
 		List<String> primaryKeyAttributeNames = new ArrayList<String>();
 		// JHK: After examining of the metadata structures of EclipseLink, I determined that there
 		// was nothing in those which preserved the order of the original annotations.
 		// We *need* to know the order of PK fields for KNS/KRAD functionality.
 		// So, I'm falling back to checking the annotations and fields on the referenced objects.
 		// Yes, the Javadoc states that the getDeclaredFields() method does not guarantee order,
 		// But, it's the best we have. And, as of Java 6, it is returning them in declaration order.
 
 		if (entityType.getIdType() instanceof EmbeddableType) {
 			for (Field pkField : entityType.getIdType().getJavaType().getDeclaredFields()) {
 				primaryKeyAttributeNames.add(pkField.getName());
 			}
 		} else {
 			// First, get the ID attributes from the metadata
 			List<String> unsortedPkFields = new ArrayList<String>();
 			for (SingularAttribute attr : entityType.getSingularAttributes()) {
 				if (attr.isId()) {
 					unsortedPkFields.add(attr.getName());
 				}
 			}
 
             getPrimaryKeyNamesInOrder(primaryKeyAttributeNames, unsortedPkFields, entityType.getJavaType().getDeclaredFields(), entityType.getJavaType());
 		}
 		return primaryKeyAttributeNames;
 	}
 
     /**
      * Sorts the list of primary key names.
      *
      * @param pkFieldNames The final list to which the primary key field names will be added in order.
      * @param unsortedPks The current list of unsorted primary keys.
      * @param fields The fields on the current object.
      * @param type The class of the current object.
      */
     private void getPrimaryKeyNamesInOrder(List<String> pkFieldNames, List<String> unsortedPks, Field[] fields, Class<?> type) {
         for (Field field : type.getDeclaredFields()) {
             if (unsortedPks.contains(field.getName())) {
                 pkFieldNames.add(field.getName());
             }
         }
 
         if (pkFieldNames.isEmpty() && type.getSuperclass() != null) {
             getPrimaryKeyNamesInOrder(pkFieldNames, unsortedPks, type.getSuperclass().getDeclaredFields(), type.getSuperclass());
         }
     }
 
     /**
      * Gets a list of attributes for this data object.
      *
      * @param persistableClass The class of the data object.
      * @param fields The collection of singular attributes to process.
      * @param primaryKeyAttributes The list of primary key attribute names.
      * @return The list of attributes for this data object.
      */
 	protected List<DataObjectAttribute> getSingularAttributes(Class<?> persistableClass, Collection<?> fields,
 			List<String> primaryKeyAttributes) {
 		if (fields == null) {
 			fields = Collections.emptySet();
 		}
 		// Put them all into a map by their property name so we can find them
 		// We want to add them to the list in appearance order in the class
 		Map<String, SingularAttribute> attrs = new HashMap<String, SingularAttribute>(fields.size());
 		for (SingularAttribute attr : (Collection<SingularAttribute>) fields) {
 			if (!attr.isAssociation()) {
 				attrs.put(attr.getName(), attr);
 			}
 		}
 		List<DataObjectAttribute> attributes = new ArrayList<DataObjectAttribute>(fields.size());
 		// This will process them in appearance order
 		for (Field f : persistableClass.getDeclaredFields()) {
 			SingularAttribute attr = attrs.get(f.getName());
 			if (attr != null) {
 				attributes.add(getAttributeMetadata(persistableClass, attr, primaryKeyAttributes));
 				attrs.remove(f.getName()); // to note that it's been used - see below
 			}
 		}
 		// Just in case there are others which don't match, we don't want to miss them and will add them at the end
 		for (SingularAttribute attr : attrs.values()) {
 			attributes.add(getAttributeMetadata(persistableClass, attr, primaryKeyAttributes));
 		}
 		return attributes;
 	}
 
 	/**
 	 * Gets a single field's metadata from the property descriptor.
 	 * 
 	 * @param persistableClass The class of the data object.
 	 * @param attr The singular attribute to process.
      * @param primaryKeyAttributes The list of primary key attribute names.
 	 * @return The DataObjectAttribute containing the metadata for the given attribute on the provided Class
 	 */
 	protected DataObjectAttribute getAttributeMetadata(Class<?> persistableClass, SingularAttribute<?, ?> attr,
 			List<String> primaryKeyAttributes) {
 		DataObjectAttributeImpl attribute = new DataObjectAttributeImpl();
 
 		attribute.setOwningType(persistableClass);
 		attribute.setName(attr.getName());
 		Class<?> propertyType = attr.getJavaType();
 		attribute.setType(propertyType);
 		DataType dataType = DataType.getDataTypeFromClass(propertyType);
 		if (dataType == null) {
 			dataType = DataType.STRING;
 		}
 		attribute.setDataType(dataType);
 		attribute.setRequired(!attr.isOptional() && !attr.isId() && !primaryKeyAttributes.contains(attr.getName()));
 
 		populateImplementationSpecificAttributeLevelMetadata(attribute, attr);
 
 		return attribute;
 	}
 
     /**
      * Gets a collection's metadata from the property descriptor.
      *
      * @param collections The list of plural attributes to process.
      * @return The list of collections for this data object.
      */
 	protected List<DataObjectCollection> getCollectionsFromMetadata(Set<PluralAttribute> collections) {
 		List<DataObjectCollection> colls = new ArrayList<DataObjectCollection>(collections.size());
 		for (PluralAttribute cd : collections) {
 			colls.add(getCollectionMetadataFromCollectionAttribute(cd));
 		}
 		return colls;
 	}
 
 	/**
 	 * Extracts the collection metadata from a single JPA {@link PluralAttribute} object.
      *
      * @param cd The plural attribute to process.
      * @return The collection metadata from a single JPA {@link PluralAttribute} object.
 	 */
 	protected DataObjectCollection getCollectionMetadataFromCollectionAttribute(PluralAttribute cd) {
 		try {
 			DataObjectCollectionImpl collection = new DataObjectCollectionImpl();
 
 			// OJB stores the related class object name. We need to go into the repository and grab the table name.
 			Class<?> collectionElementClass = cd.getElementType().getJavaType();
 			EntityType<?> elementEntityType = entityManager.getMetamodel().entity(collectionElementClass);
 			collection.setName(cd.getName());
 			collection.setRelatedType(collectionElementClass);
 			populateImplementationSpecificCollectionLevelMetadata(collection, cd);
 
 			// Set to read only if store (save) operations should not be pushed through
 			PersistentAttributeType persistentAttributeType = cd.getPersistentAttributeType();
 			
 			// default case:  Without any mapping attributes, collections are linked by their primary key
 			if (persistentAttributeType == PersistentAttributeType.ONE_TO_MANY) {
 				// TODO: We probably still need to handle the "mappedBy" property on the OneToMany definition
 				
 				// We only perform this logic here if we did not populate it in the implementation-specific call above
 				if (collection.getAttributeRelationships().isEmpty()) {
 					// need to obtain the keys for the relationship
 					List<String> pkFields = getPrimaryKeyAttributeNames((EntityType<?>) cd.getDeclaringType());
 					List<String> fkFields = getPrimaryKeyAttributeNames(elementEntityType);
 					List<DataObjectAttributeRelationship> attributeRelationships = new ArrayList<DataObjectAttributeRelationship>();
 					for (int i = 0; i < pkFields.size(); i++) {
 						attributeRelationships.add(new DataObjectAttributeRelationshipImpl(pkFields.get(i), fkFields
 								.get(i)));
 					}
 					collection.setAttributeRelationships(attributeRelationships);
 				}
 			} else if ( persistentAttributeType == PersistentAttributeType.MANY_TO_MANY ) {
 				// OK, this is an assumption
 				collection.setIndirectCollection( true );
 				// And, since the connection is set at the *database* level through the @JoinTable anotation
 				// we do not have any field names with which to make the connection
 				collection.setAttributeRelationships(null);
 			}
 			
 			return collection;
 		} catch (RuntimeException ex) {
 			LOG.error("Unable to process Collection metadata: " + cd);
 			throw ex;
 		}
 	}
 
     /**
      * Gets the list of relationships for this data object.
      *
      * @param references The list of singular attribute references.
      * @return The list of relationships for this data object.
      */
 	protected List<DataObjectRelationship> getRelationships(Set<?> references) {
 		List<DataObjectRelationship> rels = new ArrayList<DataObjectRelationship>(references.size());
 		for (SingularAttribute rd : (Set<SingularAttribute>) references) {
 			if (rd.isAssociation()) {
 				rels.add(getRelationshipMetadata(rd));
 			}
 		}
 		return rels;
 	}
 
     /**
      * Gets a single field's relationship metadata.
      *
      * @param rd The singular attribute to process.
      * @return The single field's relationship metadata.
      */
 	protected DataObjectRelationship getRelationshipMetadata(SingularAttribute rd) {
 		try {
 			DataObjectRelationshipImpl relationship = new DataObjectRelationshipImpl();
 
 			// OJB stores the related class object name. We need to go into the repository and grab the table name.
 			Class<?> referencedClass = rd.getBindableJavaType();
 			EntityType<?> referencedEntityType = entityManager.getMetamodel().entity(referencedClass);
 			relationship.setName(rd.getName());
 			relationship.setRelatedType(referencedClass);
 			populateImplementationSpecificRelationshipLevelMetadata(relationship, rd);
 
 			return relationship;
 		} catch (RuntimeException ex) {
 			LOG.error("Unable to process Relationship metadata: " + rd);
 			throw ex;
 		}
 	}
 
     /**
      * {@inheritDoc}
      */
 	@Override
 	public boolean isClassPersistable(Class<?> type) {
 		return handles(type);
 	}
 
     /**
      * Setter for the entity manager.
      *
      * @param entityManager The entity manager to set.
      */
 	public void setEntityManager(EntityManager entityManager) {
 		this.entityManager = entityManager;
 	}
 
     /**
      * Gets the entity manager for interacting with the database.
      *
      * @return The entity manager for interacting with the database.
      */
 	public EntityManager getEntityManager() {
 		return entityManager;
 	}
 }