package org.andromda.core.metafacade;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import org.andromda.core.common.ClassUtils;
import org.andromda.core.profile.Profile;
import org.apache.commons.lang.StringUtils;

/**
 * A meta facade mapping class. This class is a child of {@link MetafacadeMappings}
 * (that is: instances of this class below to an instance of {@link MetafacadeMappings}).
 *
 * @author Chad Brandon
 * @author Bob Fields
 */
public class MetafacadeMapping
{
    /**
     * The meta facade for which this mapping applies.
     */
    private Class metafacadeClass = null;

    /**
     * Gets the metafacadeClass for this mapping.
     *
     * @return Returns the metafacadeClass.
     */
    public Class getMetafacadeClass()
    {
        return metafacadeClass;
    }

    /**
     * Sets the metafacadeClassName for this mapping.
     *
     * @param metafacadeClassName The name of the metafacade class to set.
     */
    public void setMetafacadeClassName(final String metafacadeClassName)
    {
        try
        {
            this.metafacadeClass = ClassUtils.loadClass(StringUtils.trimToEmpty(metafacadeClassName));
        }
        catch (final Throwable throwable)
        {
            throw new MetafacadeMappingsException(throwable);
        }
    }

    /**
     * The names of the mapping classes for which this mapping applies. The {@link #context},{@link #stereotypes}and this
     * names make up the identifying key for this mapping.
     */
    private Set<String> mappingClassNames = new HashSet<String>();

    /**
     * Gets the names of the metaobject classes used for this mapping.
     *
     * @return Returns the mappingClassNames.
     */
    protected  Set<String> getMappingClassNames()
    {
        // - if we have a mappingClassName defined, we use it
        if (this.mappingClassNames.isEmpty())
        {
            // - attempt to get the inherited mapping since it doesn't exist on this class
            this.mappingClassNames = MetafacadeUtils.getInheritedMappingClassNames(this);
        }
        return this.mappingClassNames;
    }

    /**
     * Indicates whether or not the mapping class has been present.
     *
     * @return whether or not the mapping class is present in this mapping.
     */
    final boolean isMappingClassNamePresent()
    {
        return !this.mappingClassNames.isEmpty();
    }

    /**
     * The name of the metaobject class to use for this mapping.
     *
     * @param mappingClassName The mappingClassName to set.
     */
    public void setMappingClassName(final String mappingClassName)
    {
        if(!StringUtils.isBlank(mappingClassName))
        {
            this.mappingClassNames.clear();
            this.mappingClassNames.add(StringUtils.trimToEmpty(mappingClassName));
        }
    }

    /**
     * Whether or not this mapping represents a <code>contextRoot</code>.
     */
    private boolean contextRoot = false;

    /**
     * <p>
     * Gets whether or not this mapping represents a <code>contextRoot</code>, by default a mapping is <strong>NOT
     * </strong> a contextRoot. You'll want to specify this as true when other metafacades need to be created within the
     * context of this metafacade. </p>
     *
     * @return Returns the contextRoot.
     */
    public boolean isContextRoot()
    {
        return this.contextRoot;
    }

    /**
     * Sets the name of the <code>contextRoot</code> for this mapping.
     *
     * @param contextRoot The contextRoot to set.
     * @see #isContextRoot()
     */
    public void setContextRoot(final boolean contextRoot)
    {
        this.contextRoot = contextRoot;
    }

    /**
     * The stereotypes to which this mapping applies (all stereotypes must be present for this mapping to apply).
     */
    private final List<String> stereotypes = new ArrayList<String>();

    /**
     * Adds a <code>stereotype</code> to the stereotypes.
     *
     * @param stereotype
     */
    public void addStereotype(final String stereotype)
    {
        this.stereotypes.add(stereotype);
    }

    /**
     * Gets the stereotypes which apply to this mapping.
     *
     * @return the names of the stereotypes
     */
    final List<String> getStereotypes()
    {
        for (final ListIterator<String> iterator = this.stereotypes.listIterator(); iterator.hasNext();)
        {
            iterator.set(Profile.instance().get(iterator.next()));
        }
        return this.stereotypes;
    }

    /**
     * Indicates whether or not this mapping has any stereotypes defined.
     *
     * @return true/false
     */
    final boolean hasStereotypes()
    {
        return !this.stereotypes.isEmpty();
    }

    /**
     * Used to hold references to language mapping classes.
     */
    private final Collection<String> propertyReferences = new LinkedHashSet<String>();

    /**
     * Adds a mapping property reference. These are used to populate metafacade impl classes with mapping files, etc.
     * The property reference applies to the given mapping.
     *
     * @param reference the name of the reference.
     * @see MetafacadeMappings#addPropertyReference(String)
     */
    public void addPropertyReference(final String reference)
    {
        this.propertyReferences.add(reference);
    }

    /**
     * Returns all mapping references for this MetafacadeMapping instance.
     * @return this.propertyReferences
     */
    public Collection<String> getPropertyReferences()
    {
        return this.propertyReferences;
    }

    /**
     * Used to hold the properties that should apply to the mapping element.
     */
    private PropertyGroup mappingProperties = null;

    /**
     * Adds a mapping property. This are used to narrow the metafacade to which the mapping can apply. The properties
     * must exist and must evaluate to the specified value if given for the mapping to match.
     *
     * @param name the name of the reference.
     * @param value the default value of the property reference.
     */
    public void addMappingProperty(
        final String name,
        final String value)
    {
        if (value != null)
        {
            if (this.mappingProperties == null)
            {
                this.mappingProperties = new PropertyGroup();

                // we add the mapping properties to the mappingPropertyGroups
                // collection only once
                this.mappingPropertyGroups.add(this.mappingProperties);
            }
            this.mappingProperties.addProperty(new Property(
                    name,
                    value));
        }
    }

    /**
     * Stores a collection of all property groups added through {@link #addPropertyReferences(java.util.Collection)}. These are
     * property groups added from other mappings that return true when executing {@link #match(MetafacadeMapping)}.
     */
    private final Collection<PropertyGroup> mappingPropertyGroups = new ArrayList<PropertyGroup>();

    /**
     * Adds the <code>propertyGroup</code> to the existing mapping property groups within this mapping.
     *
     * @param propertyGroup a property group for this mapping
     */
    final void addMappingPropertyGroup(final PropertyGroup propertyGroup)
    {
        this.mappingPropertyGroups.add(propertyGroup);
    }

    /**
     * Returns all mapping property groups for this MetafacadeMapping instance.
     * @return this.mappingPropertyGroups
     */
    final Collection<PropertyGroup> getMappingPropertyGroups()
    {
        return this.mappingPropertyGroups;
    }

    /**
     * Gets the mapping properties associated this this mapping directly (contained within a {@link
     * PropertyGroup}instance).
     *
     * @return the mapping property group.
     */
    final PropertyGroup getMappingProperties()
    {
        return this.mappingProperties;
    }

    /**
     * Indicates whether or not this mapping contains any mapping properties.
     *
     * @return true/false
     */
    final boolean hasMappingProperties()
    {
        return this.mappingProperties != null && !this.mappingProperties.getProperties().isEmpty();
    }

    /**
     * Adds all <code>propertyReferences</code> to the property references contained in this MetafacadeMapping
     * instance.
     *
     * @param propertyReferences the property references to add.
     */
    public void addPropertyReferences(final Collection<String> propertyReferences)
    {
        if (propertyReferences != null)
        {
            this.propertyReferences.addAll(propertyReferences);
        }
    }

    /**
     * The context to which this mapping applies.
     */
    private String context = "";

    /**
     * Sets the context to which this mapping applies.
     *
     * @param context The metafacade context name to set.
     */
    public void setContext(final String context)
    {
        this.context = StringUtils.trimToEmpty(context);
    }

    /**
     * Gets the context to which this mapping applies.
     *
     * @return the name of the context
     */
    final String getContext()
    {
        return this.context;
    }

    /**
     * Indicates whether or not this mapping has a context.
     *
     * @return true/false
     */
    final boolean hasContext()
    {
        return StringUtils.isNotBlank(this.context);
    }

    /**
     * The "parent" metafacade mappings;
     */
    private MetafacadeMappings mappings;

    /**
     * Sets the metafacade mappings instance to which this particular mapping belongs. (i.e. the parent) Note, that this
     * is populated during the call to {@link MetafacadeMappings#addMapping(MetafacadeMapping)}.
     *
     * @param mappings the MetacadeMappings instance to which this mapping belongs.
     */
    final void setMetafacadeMappings(final MetafacadeMappings mappings)
    {
        this.mappings = mappings;
    }

    /**
     * Gets the "parent" MetafacadeMappings instance to which this mapping belongs.
     *
     * @return the parent metafacade mappings instance.
     */
    final MetafacadeMappings getMetafacadeMappings()
    {
        return this.mappings;
    }

    /**
     * Indicates whether or not the <code>mapping</code> matches this mapping. It matches on the following: <ul>
     * <li>metafacadeClass</li> <li>mappingClassName</li> <li>stereotypes</li> </ul>
     * @param mapping
     * @return match this.getMappingClassName().equals(mapping.getMappingClassName())
     */
    final boolean match(final MetafacadeMapping mapping)
    {
        boolean match =
            mapping != null && this.getMetafacadeClass().equals(mapping.getMetafacadeClass()) &&
            this.getStereotypes().equals(mapping.getStereotypes()) && this.getContext().equals(mapping.getContext());

        // - if they match and the mappingClassNames are both non-null, verify they match
        if (match && !this.mappingClassNames.isEmpty() && mapping != null && !mapping.mappingClassNames.isEmpty())
        {
            match = this.getMappingClassNames().equals(mapping.getMappingClassNames());
        }
        return match;
    }

    /**
     * @see Object#toString()
     */
    public String toString()
    {
        return super.toString() + '[' + this.getMetafacadeClass() + "], mappingClassName[" + this.mappingClassNames +
        "], properties[" + this.getMappingProperties() + "], stereotypes" + this.stereotypes + ", context[" +
        this.context + "], propertiesReferences" + this.getPropertyReferences();
    }

    /**
     * Represents a group of properties. Properties within a group are evaluated within an 'AND' expression.
     * PropertyGroups are evaluated together as an 'OR' expressions (i.e. you 'OR' property groups together, and 'AND'
     * properties together).
     *
     * @see MetafacadeMappings#addMapping(MetafacadeMapping)
     */
    static final class PropertyGroup
    {
        private final Map<String, Property> properties = new LinkedHashMap<String, Property>();

        /**
         * Adds a property to the internal collection of properties.
         *
         * @param property the property to add to this group.
         */
        final void addProperty(final Property property)
        {
            final String name = property.getName();
            if (!this.properties.containsKey(name))
            {
                this.properties.put(
                    name,
                    property);
            }
        }

        /**
         * Gets the currently internal collection of properties.
         *
         * @return the properties collection.
         */
        final Collection<Property> getProperties()
        {
            return this.properties.values();
        }

        /**
         * @see Object#toString()
         */
        public String toString()
        {
            final StringBuilder toString = new StringBuilder();
            char separator = ':';
            for (final Iterator<Property> iterator = this.getProperties().iterator(); iterator.hasNext();)
            {
                final Property property = iterator.next();
                toString.append(property.getName());
                if (StringUtils.isNotBlank(property.getValue()))
                {
                    toString.append(separator).append(property.getValue());
                }
                if (iterator.hasNext())
                {
                    toString.append(separator);
                }
            }
            return toString.toString();
        }
    }

    /**
     * Stores and provides access to the mapping element's nested &lt;property/&gt;.
     */
    static final class Property
    {
        private String name;
        private String value;

        /**
         * @param name
         * @param value
         */
        Property(
            final String name,
            final String value)
        {
            this.name = StringUtils.trimToEmpty(name);
            this.value = value;
        }

        /**
         * Gets the value of the <code>name</code> attribute on the <code>property</code> element.
         *
         * @return the name
         */
        final String getName()
        {
            return StringUtils.trimToEmpty(this.name);
        }

        /**
         * Gets the value of the <code>value</code> attribute defined on the <code>property</code> element.
         *
         * @return the value
         */
        final String getValue()
        {
            return StringUtils.trimToEmpty(this.value);
        }
    }
}