package org.andromda.cartridges.spring;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import org.andromda.cartridges.spring.metafacades.SpringService;
import org.andromda.metafacades.uml.AssociationEndFacade;
import org.andromda.metafacades.uml.AttributeFacade;
import org.andromda.metafacades.uml.ClassifierFacade;
import org.andromda.metafacades.uml.Entity;
import org.andromda.metafacades.uml.EntityAttribute;
import org.andromda.metafacades.uml.EnumerationFacade;
import org.andromda.metafacades.uml.EnumerationLiteralFacade;
import org.andromda.metafacades.uml.GeneralizableElementFacade;
import org.andromda.metafacades.uml.ModelElementFacade;
import org.andromda.metafacades.uml.Role;
import org.andromda.metafacades.uml.Service;
import org.andromda.utils.StringUtilsHelper;
import org.apache.commons.collections.Closure;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;


/**
 * Contains utilities used within the Spring cartridge.
 *
 * @author Chad Brandon
 * @author Joel Kozikowski
 */
public class SpringUtils
{
    /**
     * The logger instance.
     */
    private static final Logger logger = Logger.getLogger(SpringUtils.class);

    /**
     * Retrieves all roles from the given <code>services</code> collection.
     *
     * @param services the collection services.
     * @return all roles from the collection.
     */
    public Collection<Role> getAllRoles(Collection<Service> services)
    {
        final Collection<Role> allRoles = new LinkedHashSet<Role>();
        CollectionUtils.forAllDo(
            services,
            new Closure()
            {
                public void execute(Object object)
                {
                    if (object != null && Service.class.isAssignableFrom(object.getClass()))
                    {
                        allRoles.addAll(((Service)object).getAllRoles());
                    }
                }
            });
        return allRoles;
    }

    /**
     * Indicates if any remote EJBs are present in the collection
     * of services.
     *
     * @param services the collection of services to check.
     * @return true/false.
     */
    public boolean remoteEjbsPresent(final Collection<Service> services)
    {
        boolean present = services != null && !services.isEmpty();
        if (present)
        {
            present =
                CollectionUtils.find(
                    services,
                    new Predicate()
                    {
                        public boolean evaluate(final Object object)
                        {
                            boolean valid = false;
                            if (object instanceof SpringService)
                            {
                                final SpringService service = (SpringService)object;
                                valid = service.isEjbRemoteView();
                            }
                            return valid;
                        }
                    }) != null;
        }
        return present;
    }

    /**
     * Indicates if any local EJBs are present in the collection
     * of services.
     *
     * @param services the collection of services to check.
     * @return true/false.
     */
    public boolean localEjbsPresent(final Collection<Service> services)
    {
        boolean present = services != null && !services.isEmpty();
        if (present)
        {
            present =
                CollectionUtils.find(
                    services,
                    new Predicate()
                    {
                        public boolean evaluate(final Object object)
                        {
                            boolean valid = false;
                            if (object instanceof SpringService)
                            {
                                final SpringService service = (SpringService)object;
                                valid = service.isEjbLocalView();
                            }
                            return valid;
                        }
                    }) != null;
        }
        return present;
    }

    /**
     * Indicates if any Spring remotable services are present.
     *
     * @param services the collection of services to check.
     * @return true/false.
     */
    public boolean remotableServicesPresent(final Collection<Service> services)
    {
        boolean present = services != null && !services.isEmpty();
        if (present)
        {
            present =
                CollectionUtils.find(
                    services,
                    new Predicate()
                    {
                        public boolean evaluate(final Object object)
                        {
                            boolean valid = false;
                            if (object instanceof SpringService)
                            {
                                final SpringService service = (SpringService)object;
                                valid = service.isRemotable();
                            }
                            return valid;
                        }
                    }) != null;
        }
        return present;
    }

    /**
     * Indicates if any remotable services using Lingo are present.
     *
     * @param services the collection of services to check.
     * @return true/false.
     */
    public boolean lingoRemotableServicesPresent(final Collection<Service> services)
    {
        boolean present = services != null && !services.isEmpty();
        if (present)
        {
            present =
                CollectionUtils.find(
                        services,
                        new Predicate()
                        {
                            public boolean evaluate(final Object object)
                            {
                                boolean valid = false;
                                if (object instanceof SpringService)
                                {
                                    final SpringService service = (SpringService)object;
                                    valid = service.isRemotingTypeLingo();
                                }
                                return valid;
                            }
                        }) != null;
        }
        return present;
    }

    /**
     * Indicates if any private services are present.
     *
     * @param services the collection of services to check.
     * @return true/false.
     */
    public boolean privateServicesPresent(final Collection<Service> services)
    {
        boolean present = services != null && !services.isEmpty();
        if (present)
        {
            present =
                CollectionUtils.find(
                    services,
                    new Predicate()
                    {
                        public boolean evaluate(final Object object)
                        {
                            boolean valid = false;
                            if (object instanceof SpringService)
                            {
                                final SpringService service = (SpringService)object;
                                valid = service.isPrivate();
                            }
                            return valid;
                        }
                    }) != null;
        }
        return present;
    }

    /**
     * Indicates if any public (non private) services are present.
     *
     * @param services the collection of services to check.
     * @return true/false.
     */
    public boolean publicServicesPresent(final Collection<Service> services)
    {
        boolean present = services != null && !services.isEmpty();
        if (present)
        {
            present =
                CollectionUtils.find(
                    services,
                    new Predicate()
                    {
                        public boolean evaluate(final Object object)
                        {
                            boolean valid = false;
                            if (object instanceof SpringService)
                            {
                                final SpringService service = (SpringService)object;
                                valid = !service.isPrivate();
                            }
                            return valid;
                        }
                    }) != null;
        }
        return present;
    }

    /**
     * Based on the given <code>value</code>, this method will return
     * a formatted Spring property (including the handling of 'null').
     *
     * @param value the value from which to create the spring value.
     * @return the spring value.
     */
    public String getSpringPropertyValue(final String value)
    {
        String propertyValue = "";
        if (value != null)
        {
            if ("null".equalsIgnoreCase(value))
            {
                propertyValue = "<null/>";
            }
            else
            {
                propertyValue = "<value>" + value + "</value>";
            }
        }
        return propertyValue;
    }

    /**
     * Removes generics from string. Currently used to strip generics
     * from ejb-jar.xml method parameters.
     * @param parameter String containing generics
     * @return String with generics stripped
     */
    public String removeGenerics(final String parameter)
    {
        int position = parameter.indexOf('<');
        String result = parameter;
        if(position != -1)
        {
            result = result.substring(0, position);
        }
        return result;
    }

    /**
     * Are we generating code for a rich client? false.
     */
    private boolean richClient = false;


    /**
     * Sets if code is being generated for a rich client.
     * @param richClientProperty
     */
    public void setRichClient(final boolean richClientProperty)
    {
        this.richClient = richClientProperty;
    }

    /**
     * Returns TRUE if code is being generated for a rich client environment
     * @return richClient
     */
    public boolean isRichClient()
    {
        return this.richClient;
    }

    /**
     * Returns the class name part of a fully qualified name
     * @param fullyQualifiedName
     * @return just the "class name" part of the fully qualified name
     */
    public String getClassName(String fullyQualifiedName)
    {
       String className = null;
       if (StringUtils.isNotBlank(fullyQualifiedName))
       {
           int lastDot = fullyQualifiedName.lastIndexOf('.');
           if (lastDot >= 0)
           {
               className = fullyQualifiedName.substring(lastDot+1);
           }
           else
           {
               className = fullyQualifiedName;
           }
       }
       else
       {
           className = "";
       }

       return className;
    }


    /**
     * Returns the package name part of a fully qualified name
     * @param fullyQualifiedName
     * @return just the "package" part of the fully qualified name
     */
    public String getPackageName(String fullyQualifiedName)
    {
       String packageName = null;
       if (StringUtils.isNotBlank(fullyQualifiedName))
       {
           int lastDot = fullyQualifiedName.lastIndexOf('.');
           packageName = (lastDot >= 0 ? fullyQualifiedName.substring(0, lastDot) : "");
       }
       else
       {
           packageName = "";
       }

       return packageName;
    }

    /**
     * Returns an ordered set containing the argument model elements, model elements with a name that is already
     * used by another model element in the argument collection will not be returned.
     * The first operation with a name not already encountered will be returned, the order inferred by the
     * argument's iterator will determine the order of the returned list.
     *
     * @param modelElements a collection of model elements, elements that are not model elements will be ignored
     * @return the argument model elements without, elements with a duplicate name will only be recorded once
     */
    public List<ModelElementFacade> filterUniqueByName(Collection<ModelElementFacade> modelElements)
    {
        final Map<String, ModelElementFacade> filteredElements = new LinkedHashMap<String, ModelElementFacade>();

        for (final ModelElementFacade modelElement : modelElements)
        {
            /*final Object object = elementIterator.next();
            if (object instanceof ModelElementFacade)
            {*/
            if (!filteredElements.containsKey(modelElement.getName()))
            {
                filteredElements.put(modelElement.getName(), modelElement);
            }
            /*}*/
        }

        return new ArrayList<ModelElementFacade>(filteredElements.values());
    }

    /**
     * Formats the given type to the appropriate Hibernate query parameter value.
     *
     * @param type the type of the Hibernate query parameter.
     * @param value the current value to format.
     * @return the formatted value.
     */
    public String formatHibernateQueryParameterValue(final ClassifierFacade type, String value)
    {
        if (type != null)
        {
            if (type.isPrimitive())
            {
                value = "new " + type.getWrapperName() + '(' + value + ')';
            }
        }
        return value;
    }

    /**
     * Takes the given <code>names</code> and concatenates them in camel case
     * form.
     *
     * @param names the names to concatenate.
     * @return the result of the concatenation
     */
    public static String concatNamesCamelCase(final Collection<String> names)
    {
        String result = null;
        if (names != null)
        {
            result = StringUtilsHelper.lowerCamelCaseName(StringUtils.join(names.iterator(), " "));
        }
        return result;
    }

    /**
     * Constructs the fully qualified class name from the packageName and name.
     * @param packageName the package name to which the class belongs.
     * @param name the name of the class.
     * @return the fully qualified name.
     */
    public static String getFullyQualifiedClassName(final String packageName, final String name)
    {
        final StringBuilder fullName = new StringBuilder(StringUtils.trimToEmpty(packageName));
        if (fullName.length() > 0)
        {
            fullName.append('.');
        }
        fullName.append(name);
        return fullName.toString();
    }

    /**
     * Constructs the fully qualified class definition from the facade. Used for
     * ValueObject, EmbeddedValue
     * @param facade the class to construct the roo field definition.
     * @return the Roo class definition.
     */
    public static List<String> getRooEnum(final EnumerationFacade facade)
    {
        List<String> results = new ArrayList<String>();
        String result = "enum type --class " + facade.getFullyQualifiedName() + " --permitReservedWords";
        results.add(result);
        // Can't do for: because literal may be AttributeFacade or EnumerationLiteralFacade - ClassCastException
        Iterator literals = facade.getLiterals().iterator();
        while (literals.hasNext())
        {
            result = "enum constant --name " + ((ModelElementFacade)literals.next()).getName();
            results.add(result);
        }
        return results;
    }

    /**
     * Constructs the fully qualified class definition from the facade. Used for
     * ValueObject, EmbeddedValue
     * @param facade the class to construct the roo field definition.
     * @return the Roo class definition.
     */
    public static List<String> getRooClass(final ClassifierFacade facade)
    {
        List<String> results = new ArrayList<String>();
        String result = null;
        if (facade.isEmbeddedValue() || facade.hasStereotype("ValueObject"))
        {
            if (facade.isEmbeddedValue())
            {
                result = "embeddable --class ";
            }
            else if (facade.hasStereotype("ValueObject"))
            {
                result = "class --class ";
            }
            result += facade.getFullyQualifiedName() + " --permitReservedWords";
            if (facade.isAbstract())
            {
                result += " --abstract";
            }
            if (facade.getGeneralization() != null)
            {
                result += " --extends " + facade.getGeneralization().getFullyQualifiedName();
            }
            results.add(result);
            for (AttributeFacade attr : facade.getAttributes())
            {
                results.add(getRooField(attr));
            }
            //results.add("");
        }
        // Old style Java 1.4 enumeration class
        /*else if (facade.hasStereotype("Enumeration"))
        {
            result = "enum type --class " + facade.getName() + " --permitReservedWords";
            results.add(result);
            for (AttributeFacade literal : facade.getAttributes())
            {
                result = "enum constant --name " + literal.getName();
                results.add(result);
            }
            results.add("");
        }*/
        return results;
    }

    /**
     * Constructs the fully qualified class name from the packageName and name.
     * Removes the words 'Test' and 'TestCase' because Roo cannot create tests for Entities
     * with those names.
     * @param entity the entity to construct the roo script definition.
     * @return the Roo field definition.
     */
    public static String getRooEntityName(final Entity entity)
    {
        return StringUtils.remove(entity.getFullyQualifiedName(), "Test");
    }

    /**
     * Constructs the fully qualified class name from the packageName and name.
     * @param entity the entity to construct the roo script definition.
     * @param recordType Either 'dao' or 'repository'
     * @return the Roo field definition.
     */
    public static List<String> getRooEntity(final Entity entity, String recordType)
    {
        List<String> results = new ArrayList<String>();
        Collection<ModelElementFacade> identifiers = entity.getIdentifiers(false);
        String identifierLine = null;
        // Keep track of entities already output, so that descendants are created after ancestors.
        if (entity.isCompositeIdentifier())
        {
            String line = "embeddable --class " + StringUtils.remove(entity.getFullyQualifiedIdentifierTypeName(), "Test") + " --serializable";
            //String line = "embeddable --class " + entity.getFullyQualifiedIdentifierTypeName() + " --serializable";
            results.add(line);
            for (AssociationEndFacade associationEnd : entity.getIdentifierAssociationEnds())
            {
                //results.add(SpringUtils.getRooField(associationEnd));
                if (associationEnd.isMany2One())
                {
                    line = "field other --fieldName " + associationEnd.getOtherEnd().getName() + " --type " + associationEnd.getOtherEnd().getType().getFullyQualifiedName();
                    results.add(line);
                }
            }
            for (ModelElementFacade identifier : identifiers)
            {
                logger.info("getRooField identifier: " + getRooField(identifier) + " for " + identifier);
                results.add(SpringUtils.getRooField(identifier));
            }
            identifierLine = " --identifierField " + entity.getIdentifierName() + " --identifierType " + StringUtils.remove(entity.getFullyQualifiedIdentifierTypeName(), "Test");
        }
        // Hibernate cartridge automatically adds default identifier if none, spring cartridge does not
        else if (entity.getIdentifiers(false).size()==0)
        {
            identifierLine = " --identifierField id --identifierType java.lang.Long --identifierColumn ID";
        }
        else if (entity.getIdentifiers(false).size()==1)
        {
            ModelElementFacade id = entity.getIdentifiers(false).iterator().next();
            String identifierType = entity.getFullyQualifiedIdentifierTypeName();
            // Identifier properties can be either attribute or associationEnd. If end, associated class identifiers are added to this class identifiers.
            if (id instanceof EntityAttribute)
            {
                ClassifierFacade type = ((EntityAttribute)id).getType();
                if (type.isPrimitive())
                {
                    // Primitive type not allowed for identifier in Spring Roo
                    identifierType = type.getWrapperName();
                }
            }
            // Some test models have 'Test' in entity/attribute names, conflicting with names created for test scaffolding
            identifierLine = " --identifierField " + entity.getIdentifierName() + " --identifierType " + StringUtils.remove(identifierType, "Test");
        }
        else
        {
            // Should never get to this place
        }
        // Identifiers: identifiers.size()
        String activeRecord = " --activeRecord true";
        // false = Use Spring Data JPA, no DAOs. True = Dao helpers
        if (recordType.equals("active"))
        {
            activeRecord = " --activeRecord false";
        }
        String mappedSuperclass = "";
        if (entity.hasStereotype("MappedSuperclass"))
        {
            mappedSuperclass = " --mappedSuperclass";
        }
        String extension = "";
        GeneralizableElementFacade general = entity.getGeneralization();
        if (general != null)
        {
            extension = " --extends " + general.getFullyQualifiedName();
        }
        String isAbstract = "";
        if (entity.isAbstract())
        {
            isAbstract = " --abstract";
        }
        String schema = "";
        if (StringUtils.isNotBlank(entity.getSchema()))
        {
            schema = " --schema " + entity.getSchema();
        }
        String version = "";
        String entityVersion = (String) entity.findTaggedValue("andromda_hibernate_version");
        for (AttributeFacade attr : entity.getAttributes())
        {
            if (attr.hasStereotype("Version"))
            {
                version = " --versionField " + attr.getName() + " --versionColumn " + ((EntityAttribute)attr).getColumnName() + " --versionType " + attr.getType().getFullyQualifiedName();
            }
        }
        // TODO Check for global configured property "versionProperty" for adding version property to all entities
        if (StringUtils.isNotBlank(entityVersion) && StringUtils.isBlank(version))
        {
            // Add automatic version identifier to entity definition
            version = " --versionField version --versionColumn VERSION --versionType java.lang.Integer";
        }
        // TODO version*, inheritanceType, persistenceUnit, entityName, sequenceName
        String line = "entity jpa --class " + StringUtils.remove(entity.getFullyQualifiedName(), "Test") + activeRecord + " --table " + entity.getTableName() + identifierLine + mappedSuperclass + extension + version + isAbstract + schema + " --equals --serializable --testAutomatically --permitReservedWords";
        results.add(StringUtils.replace(line, "  ", " "));
        return results;
    }

    /**
     * Constructs the fully qualified class name from the packageName and name.
     * @param facade the property (attribute or associationEnd) to construct the roo field definition.
     * @return the Roo field definition.
     */
    public static String getRooField(final ModelElementFacade facade)
    {
        String result = " --fieldName " + facade.getName();
        if (facade instanceof AssociationEndFacade)
        {
            AssociationEndFacade end = (AssociationEndFacade)facade;
            ClassifierFacade type = end.getOtherEnd().getType();
            String typeName = " --type " + type.getFullyQualifiedName();
            if (end.isMany2One())
            {
                result = "field reference " + result + typeName;
            }
            else if (end.isOne2Many())
            {
                result = "field set " + result + typeName;
            }
            else
            {
                result = "field other " + result + typeName;
            }
            //System.out.println(end.getBindedFullyQualifiedName(end) + " " + end.getQualifiedName());
            String owner = end.getFullyQualifiedName();
            if (owner.lastIndexOf('.') > 0)
            {
                owner = owner.substring(0, owner.lastIndexOf('.'));
                result += " --class " + owner;
            }
            else
            {
                logger.error("getRooField invalid owner: " + owner + " for " + facade.getFullyQualifiedName());
            }
        }
        else if (facade instanceof AttributeFacade)
        {
            AttributeFacade attribute = (AttributeFacade)facade;
            ClassifierFacade type = attribute.getType();
            String typeName = " --type " + type.getFullyQualifiedName();
            //logger.info("getRooField " + attribute.getFullyQualifiedName() + " type=" + type.getFullyQualifiedName() + " Integer=" + type.isIntegerType());
            if ((attribute.isMany() || attribute.getName().endsWith("[]")) && !type.isDataType())
            {
                // The Many side of M:1 relationship, as an Attribute instead of an AssociationEnd
                result = "field reference " + result + typeName;
            }
            // Version attribute is specified in the entity definition, skip this field definition
            else if (type.getFullyQualifiedName().endsWith("[]") || attribute.hasStereotype("Version"))
            {
                // TODO: Convert DataType * to column Map with association. Punt for now.
                result = "";
            }
            else
            {
                String primitive = "";
                if (type.isPrimitive())
                {
                    primitive = " --primitive ";
                }
                if (type.isIntegerType() || type.isLongType() || type.isDoubleType() || type.isFloatType())
                {
                    result = "field number " + result + primitive + typeName;
                }
                else if (type.isBooleanType())
                {
                    result = "field boolean " + result + primitive;
                }
                else if (type.isStringType() || type.isCharacterType())
                {
                    result = "field string " + result;
                }
                else if (type.isDateType())
                {
                    result = "field date " + result + typeName;
                }
                // EmbeddedValue cannot have column, notNull, comment options in Roo
                else if (type.isEmbeddedValue())
                {
                    result = "field embedded " + result + typeName;
                }
                else if (type.isEnumeration())
                {
                    result = "field enum " + result + typeName;
                }
                else if (type.isDateType())
                {
                    result = "field reference " + result + typeName;
                }
                else if (type.isDateType())
                {
                    result = "field set " + result + typeName;
                }
                else
                {
                    result = "field other " + result + typeName;
                }
                if (attribute instanceof EntityAttribute && !type.isEmbeddedValue())
                {
                    String column = ((EntityAttribute)attribute).getColumnName();
                    if (StringUtils.isNotBlank(column))
                    {
                        result += " --column " + column;
                    }
                }
                else
                {
                    //logger.error("getRooField facade should be EntityAttribute: " + attribute);
                }
                int lower = attribute.getLower();
                if (lower > 0 && !type.isEmbeddedValue())
                {
                    result += " --notNull ";
                }
                String comment = attribute.getDocumentation("", 9999, false);
                if (StringUtils.isNotBlank(comment) && !type.isEmbeddedValue())
                {
                    result += " --comment \"" + comment + "\"";
                }
            }
        }
        else
        {
            throw new RuntimeException("getRooField facade must be Attribute or AssociationEnd: " + facade);
        }
        if (StringUtils.isNotBlank(result))
        {
            result = StringUtils.replace(result + " --permitReservedWords", "  ", " ");
        }
        return result;
    }
    private static final SimpleDateFormat DF = new SimpleDateFormat("MM/dd/yyyy HH:mm:ssZ");
    /**
     * Returns the current Date in the specified format. $conversionUtils does not seem to work in vsl.
     *
     * @param format The format for the output date
     * @return the current date in the specified format.
     */
    public static String getDate(String format)
    {
        /*if (DF == null || !format.equals(DF.toLocalizedPattern()))
        {
            DF = new SimpleDateFormat(format);
        }*/
        return DF.format(new Date());
    }

    /**
     * Returns the current Date in the specified format.
     *
     * @return the current date with the default format .
     */
    public static String getDate()
    {
        return DF.format(new Date());
    }
}