/* Copyright 2004-2005 the original author or authors.
 * 
 * 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 org.codehaus.groovy.grails.orm.hibernate.cfg;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.codehaus.groovy.grails.commons.GrailsDomainClass;
import org.codehaus.groovy.grails.commons.GrailsDomainClassProperty;
import org.hibernate.FetchMode;
import org.hibernate.MappingException;
import org.hibernate.cfg.Mappings;
import org.hibernate.cfg.SecondPass;
import org.hibernate.id.PersistentIdentifierGenerator;
import org.hibernate.mapping.*;
import org.hibernate.mapping.Collection;
import org.hibernate.util.StringHelper;

import java.util.*;
import java.util.Map;
import java.util.Set;


/**
 * Handles the binding Grails domain classes and properties to the Hibernate runtime meta model.
 * Based on the HbmBinder code in Hibernate core and influenced by AnnotationsBinder.
 * 
 * @author Graeme Rocher
 * @since 06-Jul-2005
 */
public final class GrailsDomainBinder {
	
	private static final String FOREIGN_KEY_SUFFIX = "_ID";
	private static final Log LOG = LogFactory.getLog( GrailsDomainBinder.class );
	
	/**
	 * A Collection type, for the moment only Set is supported
	 * 
	 * @author Graeme
	 *
	 */
	abstract static class CollectionType {
		
		private Class clazz;

		public abstract Collection create(GrailsDomainClassProperty property, PersistentClass owner,
				Mappings mappings) throws MappingException;

		CollectionType(Class clazz) {
			this.clazz = clazz;
		}

		public String toString() {
			return clazz.getName();
		}
		
		private static CollectionType SET = new CollectionType(Set.class) {

			public Collection create(GrailsDomainClassProperty property, PersistentClass owner, Mappings mappings) throws MappingException {
				org.hibernate.mapping.Set coll = new org.hibernate.mapping.Set(owner);
				coll.setCollectionTable(owner.getTable());
				bindCollection( property, coll, owner, mappings );
				return coll;
			}

			
		};
		
		private static final Map INSTANCES = new HashMap();
		
		static {
			INSTANCES.put( SET.toString(), SET );			
		}
		public static CollectionType collectionTypeForClass(Class clazz) {
			return (CollectionType)INSTANCES.get( clazz.getName() );
		}
	}

	
	/**
	 * Second pass class for grails relationships. This is required as all
	 * persistent classes need to be loaded in the first pass and then relationships
	 * established in the second pass compile
	 * 
	 * @author Graeme
	 *
	 */
	static class GrailsCollectionSecondPass implements SecondPass {

		private static final long serialVersionUID = -5540526942092611348L;
		private GrailsDomainClassProperty property;
		private Mappings mappings;
		private Collection collection;

		public GrailsCollectionSecondPass(GrailsDomainClassProperty property, Mappings mappings, Collection coll) {
			this.property = property;
			this.mappings = mappings;
			this.collection = coll;
		}

		public void doSecondPass(Map persistentClasses, Map inheritedMetas) throws MappingException {
			bindCollectionSecondPass( this.property, mappings, persistentClasses, collection,inheritedMetas );			
		}

	}

	private static void bindCollectionSecondPass(GrailsDomainClassProperty property, Mappings mappings, Map persistentClasses, Collection collection, Map inheritedMetas) {

		PersistentClass associatedClass = null;
		// Configure one-to-many
		if(collection.isOneToMany()) {
			OneToMany oneToMany = (OneToMany)collection.getElement();
			String associatedClassName = oneToMany.getReferencedEntityName();
			
			associatedClass = (PersistentClass)persistentClasses.get(associatedClassName);
			// if there is no persistent class for the association throw
			// exception
			if(associatedClass == null) {
				throw new MappingException( "Association references unmapped class: " + oneToMany.getReferencedEntityName() );
			}
			
			oneToMany.setAssociatedClass( associatedClass );
			collection.setCollectionTable( associatedClass.getTable() );
			collection.setLazy(true);
			
			LOG.info( "Mapping collection: "
					+ collection.getRole()
					+ " -> "
					+ collection.getCollectionTable().getName() );
			
		}
		
		// setup the primary key references
		KeyValue keyValue;
		
		String propertyRef = collection.getReferencedPropertyName();
		// this is to support mapping by a property
		if(propertyRef == null) {
			keyValue = collection.getOwner().getIdentifier();
		}
		else {
			keyValue = (KeyValue)collection.getOwner().getProperty( propertyRef ).getValue();
		}
		
		DependantValue key = new DependantValue(collection.getCollectionTable(), keyValue);		
		key.setTypeName(null);
		
//		
		if(property.isBidirectional()) {
			GrailsDomainClassProperty otherSide = property.getOtherSide();
			if(otherSide.isManyToOne()) {
				collection.setInverse(true);
				Iterator mappedByColumns = associatedClass.getProperty( otherSide.getName() ).getValue().getColumnIterator();
				while(mappedByColumns.hasNext()) {
					Column column = (Column)mappedByColumns.next();
					linkValueUsingAColumnCopy(otherSide,column,key);
				}
			}			
		}
		else {
			bindSimpleValue( property,key,mappings );
		}				
		collection.setKey( key );
		// make required and non-updateable
		key.setNullable(false);
		key.setUpdateable(false);
		
		// if we have a many-to-many
		if(property.isManyToMany()) {
			ManyToOne element = new ManyToOne( collection.getCollectionTable() );
			collection.setElement(element);
			bindManyToOne(property,element, mappings);
		}
		else if ( property.isOneToMany() && !property.isBidirectional() ) {
				// for non-inverse one-to-many, with a not-null fk, add a backref!
			OneToMany oneToMany = (OneToMany) collection.getElement();
				String entityName = ( oneToMany ).getReferencedEntityName();
				PersistentClass referenced = mappings.getClass( entityName );
				Backref prop = new Backref();
				prop.setName( '_' + property.getName() + "Backref" );
				prop.setUpdateable( true );
				prop.setInsertable( true );
				prop.setCollectionRole( collection.getRole() );
				prop.setValue( collection.getKey() );
				prop.setOptional( property.isOptional() );
				referenced.addProperty( prop );
		}		
	}		
	
	private static void linkValueUsingAColumnCopy(GrailsDomainClassProperty prop, Column column, DependantValue key) {
		Column mappingColumn = new Column();
		mappingColumn.setName(column.getName());
		mappingColumn.setLength(column.getLength());
		mappingColumn.setNullable(!prop.isOptional());
		mappingColumn.setSqlType(column.getSqlType());		
		
		mappingColumn.setValue(key);
		key.addColumn( mappingColumn );
		key.getTable().addColumn( mappingColumn );		
	}

	/**
	 * First pass to bind collection to Hibernate metamodel, sets up second pass
	 * 
	 * @param property The GrailsDomainClassProperty instance
	 * @param collection The collection
	 * @param owner The owning persistent class
	 * @param mappings The Hibernate mappings instance
	 */
	private static void bindCollection(GrailsDomainClassProperty property, Collection collection, PersistentClass owner, Mappings mappings) {
		
		// set role
		collection.setRole( StringHelper.qualify( property.getDomainClass().getFullName() , property.getName() ) );
		
		// TODO: add code to configure optimistic locking
		
		// TODO: configure fetch strategy
		collection.setFetchMode( FetchMode.DEFAULT );
		
		// if its a one-to-many mapping
		if(property.isOneToMany()) {
			
			OneToMany oneToMany = new OneToMany( collection.getOwner() );
			collection.setElement( oneToMany );
			
			bindOneToMany( property, oneToMany, mappings );			
		}
		else {
			String tableName = property.getReferencedDomainClass().getName();
			
			Table table = mappings.addTable(
								mappings.getSchemaName(),
								mappings.getCatalogName(),
								tableName,
								null,
								false
							);
			collection.setCollectionTable(table);
		}
		
		// setup second pass
		mappings.addSecondPass( new GrailsCollectionSecondPass(property, mappings, collection) );
		
	}
	/**
	 * Binds a Grails domain class to the Hibernate runtime meta model
	 * @param domainClass The domain class to bind
	 * @param mappings The existing mappings
	 * @throws MappingException Thrown if the domain class uses inheritance which is not supported
	 */
	public static void bindClass(GrailsDomainClass domainClass, Mappings mappings)
		throws MappingException {		
		if(domainClass.getClazz().getSuperclass() == java.lang.Object.class) {
			bindRoot(domainClass, mappings);
		}
		else {
			throw new MappingException("Grails domain classes do not support inheritance");				
		}		
	}

	/**
	 * Binds the specified persistant class to the runtime model based on the 
	 * properties defined in the domain class
	 * @param domainClass The Grails domain class
	 * @param persistentClass The persistant class
	 * @param mappings Existing mappings
	 */
	private static void bindClass(GrailsDomainClass domainClass, PersistentClass persistentClass, Mappings mappings) {
		
		// set lazy loading for now
		persistentClass.setLazy(true);
		persistentClass.setEntityName(domainClass.getFullName());
		persistentClass.setProxyInterfaceName( domainClass.getFullName() );
		persistentClass.setClassName(domainClass.getFullName());
		// set dynamic insert to false
		persistentClass.setDynamicInsert(false);
		// set dynamic update to false
		persistentClass.setDynamicUpdate(false);
		// set select before update to false
		persistentClass.setSelectBeforeUpdate(false);
		
		// add import to mappings
		if ( mappings.isAutoImport() && persistentClass.getEntityName().indexOf( '.' ) > 0 ) {
			mappings.addImport( persistentClass.getEntityName(), StringHelper.unqualify( persistentClass
				.getEntityName() ) );
		}		
	}

	
	/**
	 * Binds a root class (one with no super classes) to the runtime meta model
	 * based on the supplied Grails domain class
	 * 
	 * @param domainClass The Grails domain class 
	 * @param mappings The Hibernate Mappings object
	 */
	public static void bindRoot(GrailsDomainClass domainClass, Mappings mappings) {
		
		RootClass root = new RootClass();
		bindClass(domainClass, root, mappings);		
		bindRootPersistentClassCommonValues(domainClass, root, mappings);
		
		mappings.addClass(root);
	}


	/**
	 * Binds a persistent classes to the table representation and binds the class properties
	 * 
	 * @param domainClass
	 * @param root
	 * @param mappings
	 */
	private static void bindRootPersistentClassCommonValues(GrailsDomainClass domainClass, RootClass root, Mappings mappings) {
		
		// get the schema and catalog names from the configuration
		String schema = mappings.getSchemaName();
		String catalog = mappings.getCatalogName();
		
		// create the table 
		Table table = mappings.addTable(
				schema,
				catalog,
				domainClass.getTableName(),
				null,
				false
		);
		root.setTable(table);
		
		LOG.info( "[GrailsDomainBinder] Mapping Grails domain class: " + domainClass.getFullName() + " -> " + root.getTable().getName() );
		
		bindSimpleId( domainClass.getIdentifier(), root, mappings );
		bindVersion( domainClass.getVersion(), root, mappings );
		
		root.createPrimaryKey();
		
		createClassProperties(domainClass,root,mappings);
	}

	/**
	 * Creates and binds the properties for the specified Grails domain class and PersistantClass
	 * and binds them to the Hibernate runtime meta model
	 * 
	 * @param domainClass The Grails domain class
	 * @param persistentClass The Hibernate PersistentClass instance
	 * @param mappings The Hibernate Mappings instance
	 */
	protected static void createClassProperties(GrailsDomainClass domainClass, PersistentClass persistentClass, Mappings mappings) {
		
		GrailsDomainClassProperty[] persistantProperties = domainClass.getPersistantProperties();
		Table table = persistentClass.getTable();
		
		for(int i = 0; i < persistantProperties.length;i++) {
			
			GrailsDomainClassProperty currentGrailsProp = persistantProperties[i];
			// TODO: Implement support for many from many relationships
			if(currentGrailsProp.isManyToMany())
				continue;
/*			if(currentGrailsProp.isManyToOne() && currentGrailsProp.isBidirectional() ) {
				GrailsDomainClassProperty otherSide = currentGrailsProp.getOtherSide();
				if(otherSide.isOneToMany())
					table = null;
			}*/
			
			if(LOG.isTraceEnabled()) 
				LOG.trace("[GrailsDomainBinder] Binding persistent property [" + currentGrailsProp.getName() + "]");
			
			Value value = null;
			
			// see if its a collection type
			CollectionType collectionType = CollectionType.collectionTypeForClass( currentGrailsProp.getType() );
			if(collectionType != null) {
				// create collection
				Collection collection = collectionType.create( 
						currentGrailsProp,
						persistentClass,
						mappings
				);
				mappings.addCollection(collection);
				value = collection;
			}
			// work out what type of relationship it is and bind value
			else if ( currentGrailsProp.isManyToOne() ) {
				value = new ManyToOne( table );
				bindManyToOne( currentGrailsProp, (ManyToOne) value, mappings );
			}
			else if ( currentGrailsProp.isOneToOne()) {				
				//value = new OneToOne( table, persistentClass );
				//bindOneToOne( currentGrailsProp, (OneToOne)value, mappings );
				value = new ManyToOne( table );
				bindManyToOne( currentGrailsProp, (ManyToOne) value, mappings );
			}	
			else {
				value = new SimpleValue( table );
				bindSimpleValue( persistantProperties[i], (SimpleValue) value, mappings );
			}

			if(value != null) {
				Property property = createProperty( value, persistentClass, persistantProperties[i], mappings );			
				persistentClass.addProperty( property );						
			}
		}		
	}

	/**
	 * Creates a persistant class property based on the GrailDomainClassProperty instance
	 * 
	 * @param value
	 * @param persistentClass
	 * @param mappings
	 */
	private static Property createProperty(Value value, PersistentClass persistentClass, GrailsDomainClassProperty grailsProperty, Mappings mappings) {
		// set type
		value.setTypeUsingReflection( persistentClass.getClassName(), grailsProperty.getName() );
		
		// if it is a ManyToOne or OneToOne relationship
		if ( value instanceof ToOne ) {
			ToOne toOne = (ToOne) value;
			String propertyRef = toOne.getReferencedPropertyName();
			if ( propertyRef != null ) {
				// TODO: Hmm this method has package visibility. Why?
				
				//mappings.addUniquePropertyReference( toOne.getReferencedEntityName(), propertyRef );
			}
		}
		else if( value instanceof Collection ) {
			//Collection collection = (Collection)value;
			//String propertyRef = collection.getReferencedPropertyName();
		}
		
		if(value.getTable() != null)
			value.createForeignKey();
		
		Property prop = new Property();
		prop.setValue( value );
		
		bindProperty( grailsProperty, prop, mappings );
		return prop;
	}

	/**
	 * @param property
	 * @param oneToOne
	 * @param mappings
	 */
/*	private static void bindOneToOne(GrailsDomainClassProperty property, OneToOne oneToOne, Mappings mappings) {
		
		// bind value
		bindSimpleValue(property, oneToOne, mappings );
		// set foreign key type
		oneToOne.setForeignKeyType( ForeignKeyDirection.FOREIGN_KEY_TO_PARENT );
		
		oneToOne.setForeignKeyName( property.getFieldName() + FOREIGN_KEY_SUFFIX );
		
		// TODO configure fetch settings
		oneToOne.setFetchMode( FetchMode.DEFAULT );
		// TODO configure lazy loading
		oneToOne.setLazy(true);
				
		oneToOne.setPropertyName( property.getName() );
		oneToOne.setReferencedEntityName( property.getType().getName() );
		
		
	}*/

	/**
	 * @param currentGrailsProp
	 * @param one
	 * @param mappings
	 */
	private static void bindOneToMany(GrailsDomainClassProperty currentGrailsProp, OneToMany one, Mappings mappings) {
		one.setReferencedEntityName( currentGrailsProp.getReferencedPropertyType().getName() );		
	}

	/**
	 * Binds a many-to-one relationship to the 
	 * @param property
	 * @param manyToOne
	 * @param mappings
	 */
	private static void bindManyToOne(GrailsDomainClassProperty property, ManyToOne manyToOne, Mappings mappings) {
		
		// TODO configure fetching
		manyToOne.setFetchMode(FetchMode.DEFAULT);
		// TODO configure lazy loading
		manyToOne.setLazy(true);
		
		// bind column
		bindSimpleValue(property,manyToOne,mappings);

		// set referenced entity
		manyToOne.setReferencedEntityName( property.getReferencedPropertyType().getName() );
		manyToOne.setIgnoreNotFound(true);
	}

	/**
	 * @param version
	 * @param mappings
	 */
	private static void bindVersion(GrailsDomainClassProperty version, RootClass entity, Mappings mappings) {
		
		SimpleValue val = new SimpleValue( entity.getTable() );
		bindSimpleValue( version, val, mappings);
		
		if ( !val.isTypeSpecified() ) {
			val.setTypeName( "version".equals( version.getName() ) ? "integer" : "timestamp" );
		}
		Property prop = new Property();
		prop.setValue( val );
		
		bindProperty( version, prop, mappings );
		val.setNullValue( "undefined" );
		entity.setVersion( prop );
		entity.addProperty( prop );		
	}

	/**
	 * @param identifier
	 * @param entity
	 * @param mappings
	 */
	private static void bindSimpleId(GrailsDomainClassProperty identifier, RootClass entity, Mappings mappings) {
		
		// create the id value
		SimpleValue id = new SimpleValue(entity.getTable());
		// set identifier on entity
		entity.setIdentifier( id );
		// configure generator strategy
		id.setIdentifierGeneratorStrategy( "native" );
		
		Properties params = new Properties();

		if ( mappings.getSchemaName() != null ) {
			params.setProperty( PersistentIdentifierGenerator.SCHEMA, mappings.getSchemaName() );
		}
		if ( mappings.getCatalogName() != null ) {
			params.setProperty( PersistentIdentifierGenerator.CATALOG, mappings.getCatalogName() );
		}
		id.setIdentifierGeneratorProperties(params);
		
		// bind value
		bindSimpleValue(identifier, id, mappings );

		// create property
		Property prop = new Property();
		prop.setValue(id);
		
		// bind property
		bindProperty( identifier, prop, mappings );
		// set identifier property
		entity.setIdentifierProperty( prop );
		
		id.getTable().setIdentifierValue( id );

	}

	/**
	 * @param grailsProperty
	 * @param prop
	 * @param mappings
	 */
	private static void bindProperty(GrailsDomainClassProperty grailsProperty, Property prop, Mappings mappings) {
		// set the property name
		prop.setName( grailsProperty.getName() );
		
		prop.setInsertable(true);
		prop.setUpdateable(true);
		prop.setPropertyAccessorName( mappings.getDefaultAccess() );
		prop.setOptional( grailsProperty.isOptional() );
		// set to cascade all for the moment
		if(grailsProperty.isAssociation()) {
            if(grailsProperty.isOneToMany()) {
                prop.setCascade("all");
            }
            else if(grailsProperty.isManyToOne() || grailsProperty.isOneToOne()) {
                GrailsDomainClass domainClass = grailsProperty.getDomainClass();
                if(domainClass.isOwningClass(grailsProperty.getType())) {
                    prop.setCascade("save-update");
                }
                else {
                    GrailsDomainClassProperty otherSide = grailsProperty.getOtherSide();
                    if(otherSide != null && otherSide.isOneToMany()) {
                        prop.setCascade("save-update");
                    }
                    else {
                        prop.setCascade("all");
                    }
                }
            }
        }

        if(LOG.isTraceEnabled())
            LOG.trace( "[GrailsDomainBinder] Set cascading strategy on property ["+grailsProperty.getName()+"] to ["+prop.getCascade()+"]" );
        // lazy to true
		prop.setLazy(true);
		
	}

	/**
w	 * Binds a simple value to the Hibernate metamodel. A simple value is 
	 * any type within the Hibernate type system
	 * 
	 * @param grailsProp The grails domain class property
	 * @param simpleValue The simple value to bind
	 * @param mappings The Hibernate mappings instance
	 */
	private static void bindSimpleValue(GrailsDomainClassProperty grailsProp, SimpleValue simpleValue,Mappings mappings) {
		// set type
		simpleValue.setTypeName(grailsProp.getType().getName());
		Table table = simpleValue.getTable();
		Column column = new Column();
		if(grailsProp.isManyToOne())
			column.setNullable(false);
		
		column.setValue(simpleValue);
		bindColumn(grailsProp, column);
								
		if(table != null) table.addColumn(column);
		
		simpleValue.addColumn(column);		
	}
	

	/**
	 * Binds a Column instance to the Hibernate meta model
	 * @param grailsProp The Grails domain class property
	 * @param column The column to bind
	 */
	private static void bindColumn(GrailsDomainClassProperty grailsProp, Column column) {						
		if(grailsProp.isAssociation()) {
			if(grailsProp.isOneToMany()) {							
				column.setName( grailsProp.getDomainClass().getTableName() + FOREIGN_KEY_SUFFIX );
			}
			else if(grailsProp.isManyToOne()) {							
				column.setName( grailsProp.getReferencedDomainClass().getTableName() + FOREIGN_KEY_SUFFIX );
			}			
			else {
				column.setName( grailsProp.getFieldName() + FOREIGN_KEY_SUFFIX );
			}			
			column.setNullable(true);
			
		} else {
			column.setNullable(grailsProp.isOptional());
			column.setName(grailsProp.getFieldName());
		}
		if(LOG.isTraceEnabled()) 
			LOG.trace("[GrailsDomainBinder] bound property [" + grailsProp + "] to column name ["+column.getName()+"]");		
	}


}