package org.andromda.cartridges.spring;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.andromda.cartridges.spring.metafacades.SpringGlobals;
import org.andromda.metafacades.uml.Entity;

/**
 * Contains utilities used within the Spring cartridge
 * when dealing with Hibernate.
 *
 * @author Chad Brandon
 * @author Joel Kozikowski
 */
public class SpringHibernateUtils
{
    /**
     * The version of Hibernate we're generating for.
     */
    private String hibernateVersion = SpringGlobals.HIBERNATE_VERSION_3;

    /**
     * Sets the version of Hibernate we're generating for.
     *
     * @param hibernateVersionIn the Hibernate version.
     */
    public void setHibernateVersion(final String hibernateVersionIn)
    {
        this.hibernateVersion = hibernateVersionIn;
    }

    /**
     * Gets the appropriate hibernate package name for the given
     * <code>version</code>.
     *
     * @return the base package name.
     */
    public String getBasePackage()
    {
        return this.isVersion3() || this.isVersion4() ? "org.hibernate" : "net.sf.hibernate";
    }

    /**
     * Gets the appropriate hibernate criterion package name for the given <code>version</code>.
     *
     * @return the Hibernate criterion package name.
     */
    public String getCriterionPackage()
    {
        return this.getBasePackage() + (this.isVersion3() || this.isVersion4() ? ".criterion" : ".expression");
    }

    /**
     * Gets the appropriate hibernate criterion package name for the given <code>version</code>.
     * @param entities 
     * @return the Hibernate criterion package name.
     */
    public String getEntityBasePackage(Collection<Entity> entities)
    {
        String base = "";
        List<String> packages = new ArrayList<String>();
        // Get unique packages containing entities
        for (Entity entity : entities)
        {
            String packageName = entity.getPackageName();
            if (!packages.contains(packageName))
            {
                // TODO: Allow entities in vastly different packages
                /*for (String pkgName : packages)
                {
                    if (packageName.length() < pkgName.length() &&
                        pkgName.contains(packageName))
                    {
                        // replace the longer contained package name in the List
                    }
                }*/
                packages.add(packageName);
            }
        }
        // Get unique top level packages containing entities
        /*for (String packageName : packages)
        {

        }*/
        // TODO Implement this function. Right now it just returns "" always
        return base;
    }

    /**
     * Gets the appropriate hibernate Restrictions/Expression fully qualified class name for the given <code>version</code>.
     *
     * @return the fully qualified Hibernate Restriction/Expression class name.
     */
    public String getRestrictionClass()
    {
        return getCriterionPackage() + (this.isVersion3() || this.isVersion4() ? ".Restrictions" : ".Expression");
    }

    /**
     * Gets the appropriate Spring Hibernate package based on the given
     * <code>version</code>.
     *
     * @return the spring hibernate package.
     */
    public String getSpringHibernatePackage()
    {
        return this.isVersion3() ? "org.springframework.orm.hibernate3" : this.isVersion4() ? "org.springframework.orm.hibernate4" : "org.springframework.orm.hibernate";
    }

    /**
     * Retrieves the appropriate package for Hibernate user types given
     * the version defined within this class.
     *
     * @return the hibernate user type package.
     */
    public String getEagerFetchMode()
    {
        return this.isVersion3() || this.isVersion4() ? "JOIN" : "EAGER";
    }

    /**
     * Retrieves the fully qualified name of the class that retrieves the Hibernate
     * disjunction instance.
     * @return the fully qualified class name.
     */
    public String getDisjunctionClassName()
    {
        return this.getCriterionPackage() + (this.isVersion3() || this.isVersion4() ? ".Restrictions" : ".Expression");
    }

    /**
     * Indicates whether or not version 2 is the one that is currently being used.
     *
     * @return true/false
     */
    public boolean isVersion2()
    {
        return isVersion2(hibernateVersion);
    }

    /**
     * Indicates whether or not version 3 is the one that is currently being used.
     *
     * @return true/false
     */
    public boolean isVersion3()
    {
        return isVersion3(hibernateVersion);
    }

    /**
     * Indicates whether or not version 4 is the one that is currently being used.
     *
     * @return true/false
     */
    public boolean isVersion4()
    {
        return isVersion4(hibernateVersion);
    }

    /**
     * @param hibernateVersionPropertyValue
     * @return hibernateVersionPropertyValue.startsWith(SpringGlobals.HIBERNATE_VERSION_2)
     */
    public static boolean isVersion2(String hibernateVersionPropertyValue)
    {
        return hibernateVersionPropertyValue.startsWith(SpringGlobals.HIBERNATE_VERSION_2);
    }

    /**
     * @param hibernateVersionPropertyValue
     * @return hibernateVersionPropertyValue.startsWith(SpringGlobals.HIBERNATE_VERSION_3)
     */
    public static boolean isVersion3(String hibernateVersionPropertyValue)
    {
        return hibernateVersionPropertyValue.startsWith(SpringGlobals.HIBERNATE_VERSION_3);
    }

    /**
     * @param hibernateVersionPropertyValue
     * @return hibernateVersionPropertyValue.startsWith(SpringGlobals.HIBERNATE_VERSION_4)
     */
    public static boolean isVersion4(String hibernateVersionPropertyValue)
    {
        return hibernateVersionPropertyValue.startsWith(SpringGlobals.HIBERNATE_VERSION_4);
    }

    /**
     * Denotes whether or not to make use of Hibernate 3 XML persistence support.
     */
    private String hibernateXmlPersistence;

    /**
     * @param hibernateXmlPersistenceIn <code>true</code> when you to make use of Hibernate 3 XML persistence support,
     *      <code>false</code> otherwise
     */
    public void setHibernateXMLPersistence(final String hibernateXmlPersistenceIn)
    {
        this.hibernateXmlPersistence = hibernateXmlPersistenceIn;
    }

    /**
     * @return isXmlPersistenceActive(hibernateVersion, hibernateXmlPersistence)
     */
    public boolean isXmlPersistenceActive()
    {
        return isXmlPersistenceActive(
            this.hibernateVersion,
            this.hibernateXmlPersistence);
    }

    /**
     * @param hibernateVersionPropertyValue
     * @param hibernateXMLPersistencePropertyValue
     * @return isVersion3(hibernateVersionPropertyValue) && "true".equalsIgnoreCase(hibernateXMLPersistencePropertyValue)
     */
    public static boolean isXmlPersistenceActive(
        String hibernateVersionPropertyValue,
        String hibernateXMLPersistencePropertyValue)
    {
        return isVersion3(hibernateVersionPropertyValue) &&
            "true".equalsIgnoreCase(hibernateXMLPersistencePropertyValue);
    }

    private String hibernateMappingStrategy;

    /**
     * @param hibernateMappingStrategyIn
     */
    public void setHibernateMappingStrategy(String hibernateMappingStrategyIn)
    {
        this.hibernateMappingStrategy = hibernateMappingStrategyIn;
    }

    /**
     * @return mapSubclassesInSeparateFile(this.hibernateMappingStrategy)
     */
    public boolean isMapSubclassesInSeparateFile()
    {
        return mapSubclassesInSeparateFile(this.hibernateMappingStrategy);
    }

    /**
     * @param hibernateMappingStrategyIn
     * @return SpringGlobals.HIBERNATE_MAPPING_STRATEGY_SUBCLASS.equalsIgnoreCase(hibernateMappingStrategy)
     */
    public static boolean mapSubclassesInSeparateFile(
        String hibernateMappingStrategyIn)
    {
        // subclass or hierarchy
        return SpringGlobals.HIBERNATE_MAPPING_STRATEGY_SUBCLASS.equalsIgnoreCase(hibernateMappingStrategyIn);
    }
}