package org.andromda.cartridges.ejb3.metafacades;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.andromda.cartridges.ejb3.EJB3Globals;
import org.andromda.cartridges.ejb3.EJB3Profile;
import org.andromda.core.common.ExceptionUtils;
import org.andromda.metafacades.uml.AttributeFacade;
import org.andromda.metafacades.uml.ClassifierFacade;
import org.andromda.metafacades.uml.EntityMetafacadeUtils;
import org.andromda.metafacades.uml.ModelElementFacade;
import org.andromda.metafacades.uml.OperationFacade;
import org.andromda.metafacades.uml.UMLProfile;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.lang.StringUtils;

/**
 * Contains utilities for use with EJB metafacades.
 *
 * @author Chad Brandon
 * @author Vance Karimi
 */
class EJB3MetafacadeUtils
{
    /**
     * Gets all create methods for the given <code>classifier</code>.
     *
     * @param classifier The classifier from which to retries the create methods
     * @param follow if true, all super type create methods are also retrieved
     * @return collection of create methods found.
     */
    static Collection<OperationFacade> getCreateMethods(
            ClassifierFacade classifier,
            boolean follow)
    {
        ExceptionUtils.checkNull("classifer", classifier);
        Collection<OperationFacade> retval = new ArrayList<OperationFacade>();
        ClassifierFacade entity = classifier;
        do
        {
            for (final OperationFacade op : entity.getOperations())
            {
                if (op.hasStereotype(EJB3Profile.STEREOTYPE_CREATE_METHOD))
                {
                    retval.add(op);
                }
            }
            if (follow)
            {
                entity = (ClassifierFacade)entity.getGeneralization();
            }
        }
        while (follow && entity != null);
        return retval;
    }

    /**
     * Gets the interface name for the passed in <code>classifier</code>. Returns 'LocalHome' if the mode element has
     * the entity stereotype, returns 'Home' otherwise.
     * @param classifier
     * @return the interface name.
     */
    static String getHomeInterfaceName(ClassifierFacade classifier)
    {
        ExceptionUtils.checkNull("classifer", classifier);
        String homeInterfaceName;
        if (classifier.hasStereotype(UMLProfile.STEREOTYPE_ENTITY))
        {
            homeInterfaceName = classifier.getName() + "LocalHome";
        }
        else
        {
            homeInterfaceName = classifier.getName() + "Home";
        }
        return homeInterfaceName;
    }

    /**
     * Gets the view type for the passed in <code>classifier</code>. If no
     * view type can be retrieved from the <code>classifier</code>, then the
     * <code>defaultViewType</code> is returned.
     *
     * If session ejb pojo then checks the ejb tagged value and if there is
     * no value defined, returns 'remote'.
     *
     * @param classifier The classifier to lookup the view type tagged value
     * @param defaultViewType The default view type if one is not found
     * @return String the view type name.
     */
    static String getViewType(
            ClassifierFacade classifier,
            String defaultViewType)
    {
        ExceptionUtils.checkNull("classifer", classifier);
        String viewType = (String)classifier.findTaggedValue(EJB3Profile.TAGGEDVALUE_EJB_VIEWTYPE);
        if (StringUtils.isBlank(viewType))
        {
            if (classifier.hasStereotype(EJB3Profile.STEREOTYPE_SERVICE))
            {
                // if the view type wasn't found, search all super classes
                if (StringUtils.isBlank(viewType))
                {
                    viewType = (String)CollectionUtils.find(
                            classifier.getAllGeneralizations(),
                            new Predicate()
                            {
                                public boolean evaluate(Object object)
                                {
                                    return ((ModelElementFacade)object).findTaggedValue(
                                            EJB3Profile.TAGGEDVALUE_EJB_VIEWTYPE) != null;
                                }
                            });
                }
                if (StringUtils.isBlank(viewType))
                {
                    viewType = (StringUtils.isNotBlank(defaultViewType) ?
                            defaultViewType : EJB3Globals.VIEW_TYPE_REMOTE);
                }
            }
        }
        return viewType.toLowerCase();
    }

    /**
     * Gets all the inherited instance attributes, excluding the instance attributes directory from this
     * <code>classifier</code>.
     *
     * @param classifier the ClassifierFacade from which to retrieve the inherited attributes.
     * @return a list of ordered attributes.
     */
    static List<AttributeFacade> getInheritedInstanceAttributes(ClassifierFacade classifier)
    {
        ExceptionUtils.checkNull("classifer", classifier);
        ClassifierFacade current = (ClassifierFacade)classifier.getGeneralization();
        if (current == null)
        {
            return new ArrayList<AttributeFacade>();
        }
        List<AttributeFacade> retval = getInheritedInstanceAttributes(current);

        if (current.getInstanceAttributes() != null)
        {
            retval.addAll(current.getInstanceAttributes());
        }
        return retval;
    }

    /**
     * Gets all instance attributes including those instance attributes belonging to the
     * <code>classifier</code> and any inherited ones.
     *
     * @param classifier the ClassifierFacade from which to retrieve the instance attributes.
     * @return the list of all instance attributes.
     */
    static List<AttributeFacade> getAllInstanceAttributes(ClassifierFacade classifier)
    {
        ExceptionUtils.checkNull("classifer", classifier);
        List<AttributeFacade> retval = getInheritedInstanceAttributes(classifier);
        retval.addAll(classifier.getInstanceAttributes());
        return retval;
    }

    /**
     * Gets all environment entries for the specified <code>classifier</code>. If <code>follow</code> is true, then a
     * search up the inheritance hierarchy will be performed and all super type environment entries will also be
     * retrieved.
     *
     * @param classifier the classifier from which to retrieve the env-entries
     * @param follow     true/false on whether or not to 'follow' the inheritance hierarchy when retrieving the
     *                   env-entries.
     * @return the collection of environment entries
     */
    static Collection<AttributeFacade> getEnvironmentEntries(
            ClassifierFacade classifier,
            boolean follow)
    {
        ExceptionUtils.checkNull("classifer", classifier);

        Collection<AttributeFacade> attributes = classifier.getStaticAttributes();

        if (follow)
        {
            for (classifier = (ClassifierFacade)classifier.getGeneralization();
                 classifier != null; classifier = (ClassifierFacade)classifier.getGeneralization())
            {
                attributes.addAll(classifier.getStaticAttributes());
            }
        }

        CollectionUtils.filter(attributes, new Predicate()
        {
            public boolean evaluate(Object object)
            {
                return ((AttributeFacade)object).hasStereotype(EJB3Profile.STEREOTYPE_ENV_ENTRY);
            }
        });

        return attributes;
    }

    /**
     * Returns the transaction type for the specified <code>classifier</code>.
     *
     * @param classifier the classifier from which to retrieve the transaction type.
     * @param defaultTransactionType the default transaction type if no tagged value is specified.
     * @return the transaction type as a String.
     */
    static String getTransactionType(ClassifierFacade classifier, String defaultTransactionType)
    {
        ExceptionUtils.checkNull("classifer", classifier);

        String transactionType = (String)classifier.findTaggedValue(EJB3Profile.TAGGEDVALUE_EJB_TRANSACTION_TYPE);
        if (StringUtils.isNotBlank(transactionType))
        {
            transactionType = convertTransactionType(transactionType);
        }
        else
        {
            transactionType = defaultTransactionType;
        }
        return transactionType;
    }

    /**
     * Convert the transaction type from lower casing to upper casing.
     * This maintains reusable tagged value enumeration from EJB
     * implementation.
     *
     * @param transType
     * @return transactionType
     */
    static String convertTransactionType(String transType)
    {
        ExceptionUtils.checkNull("transType", transType);

        String type = null;
        if (StringUtils.equalsIgnoreCase(transType, EJB3Globals.TRANSACTION_TYPE_MANDATORY))
        {
            type = "MANDATORY";
        }
        else if (StringUtils.equalsIgnoreCase(transType, EJB3Globals.TRANSACTION_TYPE_NEVER))
        {
            type = "NEVER";
        }
        else if (StringUtils.equalsIgnoreCase(transType, EJB3Globals.TRANSACTION_TYPE_NOT_SUPPORTED))
        {
            type = "NOT_SUPPORTED";
        }
        else if (StringUtils.equalsIgnoreCase(transType, EJB3Globals.TRANSACTION_TYPE_REQUIRED))
        {
            type = "REQUIRED";
        }
        else if (StringUtils.equalsIgnoreCase(transType, EJB3Globals.TRANSACTION_TYPE_REQUIRES_NEW))
        {
            type = "REQUIRES_NEW";
        }
        else if (StringUtils.equalsIgnoreCase(transType, EJB3Globals.TRANSACTION_TYPE_SUPPORTS))
        {
            type = "SUPPORTS";
        }
        return type;
    }

    /**
     * Gets all constants for the specified <code>classifier</code>.
     * If <code>follow</code> is true, then a search up
     * the inheritance hierarchy will be performed and all super
     * type constants will also be retrieved.
     *
     * @param classifier the classifier from which to retrieve the constants
     * @param follow     true/false on whether or not to 'follow' the inheritance hierarchy when retrieving the
     *                   constants.
     * @return the collection of environment entries
     */
    static Collection<AttributeFacade> getConstants(
            ClassifierFacade classifier,
            boolean follow)
    {
        ExceptionUtils.checkNull("classifer", classifier);

        Collection<AttributeFacade> attributes = classifier.getStaticAttributes();

        if (follow)
        {
            for (classifier = (ClassifierFacade)classifier.getGeneralization();
                 classifier != null; classifier = (ClassifierFacade)classifier.getGeneralization())
            {
                attributes.addAll(classifier.getStaticAttributes());
            }
        }

        CollectionUtils.filter(attributes, new Predicate()
        {
            public boolean evaluate(Object object)
            {
                return !((AttributeFacade)object).hasStereotype(EJB3Profile.STEREOTYPE_ENV_ENTRY);
            }
        });

        return attributes;
    }

    /**
     * Returns true/false based on whether or not synthetic or auto generated create methods should be allowed.
     *
     * @param classifier The entity or session bean.
     * @return true/false
     */
    static boolean allowSyntheticCreateMethod(ClassifierFacade classifier)
    {
        ExceptionUtils.checkNull("classifer", classifier);
        return !classifier.isAbstract() && classifier.findTaggedValue(
                EJB3Profile.TAGGEDVALUE_EJB_NO_SYNTHETIC_CREATE_METHOD) == null;
    }

    /**
     * Creates a fully qualified name from the given <code>packageName</code>,
     * <code>name</code>, and <code>suffix</code>.
     *
     * @param packageName the name of the model element package.
     * @param name the name of the model element.
     * @param suffix the suffix to append.
     * @return the new fully qualified name.
     */
    static String getFullyQualifiedName(
        String packageName,
        String name,
        String suffix)
    {
        StringBuilder fullyQualifiedName = new StringBuilder(StringUtils.trimToEmpty(packageName));
        if (StringUtils.isNotBlank(packageName))
        {
            fullyQualifiedName.append('.');
        }
        fullyQualifiedName.append(StringUtils.trimToEmpty(name));
        fullyQualifiedName.append(StringUtils.trimToEmpty(suffix));
        return fullyQualifiedName.toString();
    }

    /**
     * Returns true if the Seam stereotype is modeled on the class.
     *
     * @param classifier The classifier to lookup if the stereotype is modeled
     * @return True is stereotype exists, false otherwise
     */
    static boolean isSeamComponent(ClassifierFacade classifier)
    {
        boolean isSeamComponent = false;
        if (classifier.hasStereotype(EJB3Profile.STEREOTYPE_SEAM_COMPONENT))
        {
            isSeamComponent = true;
        }
        return isSeamComponent;
    }

    /**
     * Gets the Seam component scope type for Entity and Session beans.
     * If no scope has been specified:
     *     If the Classifier is a stateless session bean, then returns STATELESS
     *     If the Classifier is an entity or stateful session bean, then returns CONVERSATION
     *
     * @param classifier The classifier to lookup the scope type tagged value
     * @param stateless Whether the classifier is a stateless session bean
     * @return The scope type as a String
     */
    static String getSeamComponentScopeType(ClassifierFacade classifier, boolean stateless)
    {
        ExceptionUtils.checkNull("classifer", classifier);
        String scopeType = (String)classifier.findTaggedValue(EJB3Profile.TAGGEDVALUE_SEAM_SCOPE_TYPE);
        if (StringUtils.isBlank(scopeType))
        {
            if (stateless)
            {
                scopeType = EJB3Globals.SEAM_COMPONENT_SCOPE_STATELESS;
            }
            else
            {
                scopeType = EJB3Globals.SEAM_COMPONENT_SCOPE_CONVERSATION;
            }
        }
        return scopeType;
    }

    /**
     * Returns the Seam component name.  Can override using tagged value, otherwise just the
     * class name.
     *
     * @param classifier The classifier to get the tagged value or the name from.
     * @return The Seam component name
     */
    static String getSeamComponentName(ClassifierFacade classifier)
    {
        ExceptionUtils.checkNull("classifer", classifier);
        String componentName = (String)classifier.findTaggedValue(EJB3Profile.TAGGEDVALUE_SEAM_COMPONENT_NAME);
        if (StringUtils.isBlank(componentName))
        {
            componentName = StringUtils.uncapitalize(classifier.getName());
        }
        return componentName;
    }

    /**
     * Builds an annotation parameter line
     * @param parameters The parameters
     * @return The parameter line
     */
    static String buildAnnotationParameters(Collection<String> parameters)
    {
        StringBuilder buf = new StringBuilder();
        if(!parameters.isEmpty())
        {
            buf.append("(");
            Iterator it = parameters.iterator();
            while(it.hasNext())
            {
                String option = (String) it.next();
                buf.append(option);
                if(it.hasNext())
                {
                    buf.append(", ");
                }
            }
            buf.append(")");
            return buf.toString();
        }
        else
        {
            return null;
        }
    }

    /**
     * Builds a multi valued parameter string
     * @param name The name of the parameter
     * @param values The values for the parameters
     * @return The parameter string
     */
    static String buildAnnotationMultivalueParameter(String name, Collection<String> values)
    {
        return buildAnnotationMultivalueParameter(name, values, true);
    }

    /**
     * Builds a multi valued parameter string
     * @param name The name of the parameter
     * @param values The values for the parameters
     * @param areStrings If the values are strings then surround with " sign
     * @return The parameter string
     */
    static String buildAnnotationMultivalueParameter(String name, Collection<String> values, boolean areStrings)
    {
        return buildAnnotationMultivalueParameter(name, values, areStrings, null);
    }

    /**
     * Builds a multi option string
     * Builds a multi valued parameter string
     * @param name The name of the parameter
     * @param values The values for the parameters
     * @param areStrings If the values are strings then surround with " sign
     * @param suffix Any suffix to add to the values
     * @return The parameter string
     */
    static String buildAnnotationMultivalueParameter(String name, Collection<String> values, boolean areStrings, String suffix)
    {
        if(values.isEmpty())
        {
            return null;
        }
        else
        {
            StringBuilder buf = new StringBuilder();
            buf.append(name + " = {");

            Iterator it = values.iterator();
            while(it.hasNext())
            {
                String parameter = (String) it.next();
                if(areStrings)
                {
                    buf.append("\"");
                }
                buf.append(parameter);
                if((suffix != null) && !parameter.endsWith(suffix))
                {
                    buf.append(suffix);
                }
                if(areStrings)
                {
                    buf.append("\"");
                }
                if(it.hasNext())
                {
                    buf.append(", ");
                }
            }
            buf.append("}");
            return buf.toString();
        }
    }

    /**
     * Gets the SQL name. (i.e. column name, table name, etc.). If it can't find
     * the corresponding tagged value with the specified <code>name</code>,
     * then it uses the element name by default and just returns that.
     *
     * @param prefix the optional prefix to add to the sql name (i.e. table name
     *        prefix, etc.).
     * @param element from which to retrieve the SQL name.
     * @param name the name of the tagged value.
     * @param nameMaxLength if this is not null, then the name returned will be
     *        trimmed to this length (if it happens to be longer).
     * @param suffix the optional suffix to add to the sql name (i.e. foreign
     *        key suffix, etc.)
     * @param separator character used to separate words
     * @param shortenSqlNameMethod The method used to shorten the name, i.e. removeVowels
     * @return the SQL name as a String.
     */
    public static String getSqlNameFromTaggedValue(
        String prefix,
        final EJB3AssociationFacade element,
        String name,
        final Short nameMaxLength,
        String suffix,
        final Object separator,
        final Object shortenSqlNameMethod)
    {
        if (element != null)
        {
            Object value = element.findTaggedValue(name);
            StringBuilder buffer = new StringBuilder(StringUtils.trimToEmpty((String)value));
            if (StringUtils.isBlank(buffer.toString()))
            {
                // if we can't find the tagValue then use the
                // element name for the name
                buffer = new StringBuilder(
                        EntityMetafacadeUtils.toSqlName(
                            element.getName(),
                            separator));

                suffix = StringUtils.trimToEmpty(suffix);
                prefix = StringUtils.trimToEmpty(prefix);
                if (nameMaxLength != null)
                {
                    final short maxLength = (short)(nameMaxLength.shortValue() - suffix.length() - prefix.length());
                    buffer =
                        new StringBuilder(
                            EntityMetafacadeUtils.ensureMaximumNameLength(
                                buffer.toString(),
                                new Short(maxLength),
                                (String)shortenSqlNameMethod));
                }
                if (StringUtils.isNotBlank(prefix))
                {
                    buffer.insert(
                        0,
                        prefix);
                }
                if (StringUtils.isNotBlank(suffix))
                {
                    buffer.append(suffix);
                }
            }
            name = buffer.toString();
        }
        return name;
    }
}