package org.andromda.core.mapping;

import java.io.File;
import java.io.FileReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import org.andromda.core.common.ExceptionUtils;
import org.andromda.core.common.ResourceUtils;
import org.andromda.core.common.XmlObjectFactory;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.builder.ToStringBuilder;

/**
 * <p> An object responsible for mapping multiple <code>from</code> values to
 * single <code>to</code>. The public constructor should NOT be used to
 * construct this instance. An instance of this object should be retrieved
 * through the method getInstance(java.net.URL).
 * </p>
 * <p> The mappings will change based upon the language, database, etc being
 * used. </p>
 *
 * @author Chad Brandon
 * @author Wouter Zoons
 * @author Bob Fields
 * @see org.andromda.core.common.XmlObjectFactory
 */
public class Mappings
{
    /**
     * Contains the set of Mapping objects keyed by the 'type' element defined
     * within the from type mapping XML file.
     */
    private final Map<String, Mapping> mappings = new LinkedHashMap<String, Mapping>();

    /**
     * A static mapping containing all logical mappings currently available.
     */
    private static final Map<String, Mappings> logicalMappings = new LinkedHashMap<String, Mappings>();

    /**
     * Holds the resource path from which this Mappings object was loaded.
     */
    private URL resource;

    /**
     * Returns a new configured instance of this Mappings configured from the
     * mappings configuration URI string.
     *
     * @param mappingsUri the URI to the XML type mappings configuration file.
     * @return Mappings the configured Mappings instance.
     */
    public static Mappings getInstance(String mappingsUri)
    {
        mappingsUri = StringUtils.trimToEmpty(mappingsUri);
        ExceptionUtils.checkEmpty(
            "mappingsUri",
            mappingsUri);
        try
        {
            Mappings mappings = logicalMappings.get(mappingsUri);
            if (mappings == null)
            {
                try
                {
                    mappings = getInstance(new URL(mappingsUri));
                }
                catch (final MalformedURLException exception)
                {
                    throw new MappingsException("The given URI --> '" + mappingsUri + "' is invalid", exception);
                }
            }
            return getInheritedMappings(mappings);
        }
        catch (final Throwable throwable)
        {
            throw new MappingsException(throwable);
        }
    }

    /**
     * Attempts to get any inherited mappings for the
     * given <code>mappings</code>.
     *
     * @param mappings the mappings instance for which to
     *        get the inherited mappings.
     * @return the Mappings populated with any inherited mappings
     *         or just the same mappings unchanged if the
     *         <code>mappings</code> doesn't extend anything.
     * @throws Exception if an exception occurs.
     */
    private static Mappings getInheritedMappings(final Mappings mappings)
        throws Exception
    {
        return getInheritedMappings(
            mappings,
            false);
    }

    /**
     * Attempts to get any inherited mappings for the
     * given <code>mappings</code>.
     * This method may only be called when the logical mappings have been initialized.
     *
     * @param mappings the mappings instance for which to
     *        get the inherited mappings.
     * @param ignoreInheritanceFailure whether or not a failure retrieving the parent
     *        should be ignored (an exception will be thrown otherwise).
     * @return the Mappings populated with any inherited mappings
     *         or just the same mappings unchanged if the
     *         <code>mappings</code> doesn't extend anything.
     * @throws Exception if an exception occurs.
     * @see #initializeLogicalMappings()
     */
    private static Mappings getInheritedMappings(
        final Mappings mappings,
        final boolean ignoreInheritanceFailure)
        throws Exception
    {
        // if we have a parent then we add the child mappings to
        // the parent's (so we can override any duplicates in the
        // parent) and set the child mappings to the parent's
        if (mappings != null && StringUtils.isNotBlank(mappings.extendsUri))
        {
            Mappings parentMappings = logicalMappings.get(mappings.extendsUri);
            if (parentMappings == null)
            {
                try
                {
                    // since we didn't find the parent in the logical
                    // mappings, try a relative path
                    parentMappings = getInstance(new File(mappings.getCompletePath(mappings.extendsUri)));
                }
                catch (final Exception exception)
                {
                    if (!ignoreInheritanceFailure)
                    {
                        throw exception;
                    }
                }
            }
            if (parentMappings != null)
            {
                mergeWithoutOverriding(parentMappings, mappings);
            }
        }
        return mappings;
    }

    /**
     * Returns a new configured instance of this Mappings configured from the
     * mappings configuration URI.
     *
     * @param mappingsUri the URI to the XML type mappings configuration file.
     * @return Mappings the configured Mappings instance.
     */
    public static Mappings getInstance(final URL mappingsUri)
    {
        return getInstance(
            mappingsUri,
            false);
    }

    /**
     * Returns a new configured instance of this Mappings configured from the
     * mappings configuration URI.
     *
     * @param mappingsUri the URI to the XML type mappings configuration file.
     * @param ignoreInheritanceFailure a flag indicating whether or not failures while attempting
     *        to retrieve the mapping's inheritance should be ignored.
     * @return Mappings the configured Mappings instance.
     */
    private static Mappings getInstance(
        final URL mappingsUri,
        final boolean ignoreInheritanceFailure)
    {
        ExceptionUtils.checkNull(
            "mappingsUri",
            mappingsUri);
        try
        {
            final Mappings mappings = (Mappings)XmlObjectFactory.getInstance(Mappings.class).getObject(mappingsUri);
            mappings.resource = mappingsUri;
            return getInheritedMappings(
                mappings,
                ignoreInheritanceFailure);
        }
        catch (final Throwable throwable)
        {
            throw new MappingsException(throwable);
        }
    }

    /**
     * Returns a new configured instance of this Mappings configured from the
     * mappingsFile.
     *
     * @param mappingsFile the XML type mappings configuration file.
     * @return Mappings the configured Mappings instance.
     */
    private static Mappings getInstance(final File mappingsFile)
        throws Exception
    {
        final FileReader reader = new FileReader(mappingsFile);
        final Mappings mappings =
            (Mappings)XmlObjectFactory.getInstance(Mappings.class).getObject(reader);
        mappings.resource = mappingsFile.toURI().toURL();
        reader.close();
        return mappings;
    }

    /**
     * This initializes all logical mappings that
     * are contained with global Mapping set.  This
     * <strong>MUST</strong> be called after all logical
     * mappings have been added through {@link #addLogicalMappings(java.net.URL)}
     * otherwise inheritance between logical mappings will not work correctly.
     */
    public static void initializeLogicalMappings()
    {
        // !!! no calls to getInstance(..) must be made in this method !!!

        // reorder the logical mappings so that they can safely be loaded
        // (top-level mappings first)

        final Map<String, Mappings> unprocessedMappings = new HashMap<String, Mappings>(logicalMappings);
        final Map<String, Mappings> processedMappings = new LinkedHashMap<String, Mappings>(); // these will be in the good order

        // keep looping until there are no more unprocessed mappings
        // if nothing more can be processed but there are unprocessed mappings left
        // then we have an error (cyclic dependency or unknown parent mappings) which cannot be solved
        boolean processed = true;
        while (processed)
        {
            // we need to have at least one entry processed before the routine qualifies for the next iteration
            processed = false;

            // we only process mappings if they have parents that have already been processed
            for (final Iterator<Map.Entry<String, Mappings>> iterator = unprocessedMappings.entrySet().iterator(); iterator.hasNext();)
            {
                final Map.Entry<String, Mappings> logicalMapping = iterator.next();
                final String name = logicalMapping.getKey();
                final Mappings mappings = logicalMapping.getValue();

                if (mappings.extendsUri == null)
                {
                    // no parent mappings are always safe to add

                    // move to the map of processed mappings
                    processedMappings.put(name, mappings);
                    // remove from the map of unprocessed mappings
                    iterator.remove();
                    // set the flag
                    processed = true;
                }
                else if (processedMappings.containsKey(mappings.extendsUri))
                {
                    final Mappings parentMappings = processedMappings.get(mappings.extendsUri);
                    if (parentMappings != null)
                    {
                        mergeWithoutOverriding(parentMappings, mappings);
                    }

                    // move to the map of processed mappings
                    processedMappings.put(name, mappings);
                    // remove from the map of unprocessed mappings
                    iterator.remove();
                    // set the flag
                    processed = true;
                }
            }

        }

        if (!unprocessedMappings.isEmpty())
        {
            throw new MappingsException(
                "Logical mappings cannot be initialized due to invalid inheritance: " +
                    unprocessedMappings.keySet());
        }

        logicalMappings.putAll(processedMappings);
    }

    /**
     * Clears the entries from the logical mappings cache.
     */
    public static void clearLogicalMappings()
    {
        logicalMappings.clear();
    }

    /**
     * Holds the name of this mapping. This corresponds usually to some language
     * (i.e. Java, or a database such as Oracle, Sql Server, etc).
     */
    private String name = null;

    /**
     * Returns the name name (this is the name for which the type mappings are
     * for).
     *
     * @return String the name name
     */
    public String getName()
    {
        final String methodName = "Mappings.getName";
        if (StringUtils.isEmpty(this.name))
        {
            throw new MappingsException(methodName + " - name can not be null or empty");
        }
        return name;
    }

    /**
     * Sets the name name.
     *
     * @param name a new name
     */
    public void setName(final String name)
    {
        this.name = name;
    }

    /**
     * Stores the URI that this mappings extends.
     */
    private String extendsUri;

    /**
     * Sets the name of the mappings which this
     * instance extends.
     *
     * @param extendsUri the URI of the mapping which
     *        this one extends.
     */
    public void setExtendsUri(final String extendsUri)
    {
        this.extendsUri = extendsUri;
    }

    /**
     * Adds a Mapping object to the set of current mappings.
     *
     * @param mapping the Mapping instance.
     */
    public void addMapping(final Mapping mapping)
    {
        ExceptionUtils.checkNull(
            "mapping",
            mapping);
        final Collection<String> fromTypes = mapping.getFroms();
        ExceptionUtils.checkNull(
            "mapping.fromTypes",
            fromTypes);
        for (final String fromType : fromTypes)
        {
            mapping.setMappings(this);
            this.mappings.put(
                fromType,
                mapping);
        }
    }

    /**
     * Adds the <code>mappings</code> instance to this Mappings instance
     * overriding any mappings with duplicate names.
     *
     * @param mappings the Mappings instance to add this instance.
     */
    public void addMappings(final Mappings mappings)
    {
        if (mappings != null && mappings.mappings != null)
        {
            this.mappings.putAll(mappings.mappings);
        }
    }

    /**
     * Reads the argument parent mappings and copies any mapping entries that do not already exist in this instance.
     * This method preserves ordering and add new entries to the end.
     *
     * @param sourceMappings the mappings from which to read possible new entries
     * @param targetMappings the mappings to which to store possible new entries from the sourceMappings
     */
    private static void mergeWithoutOverriding(Mappings sourceMappings, Mappings targetMappings)
    {
        final Map<String, Mapping> allMappings = new LinkedHashMap<String, Mapping>(targetMappings.mappings.size() + sourceMappings.mappings.size());
        allMappings.putAll(sourceMappings.mappings);
        allMappings.putAll(targetMappings.mappings);
        targetMappings.mappings.clear();
        targetMappings.mappings.putAll(allMappings);
    }

    /**
     * Returns the <code>to</code> mapping from a given <code>from</code>
     * mapping.
     *
     * @param from the <code>from</code> mapping, this is the type/identifier
     *        that is in the model.
     * @return String to the <code>to</code> mapping (this is the mapping that
     *         can be retrieved if a corresponding 'from' is found).
     */
    public String getTo(String from)
    {
        from = StringUtils.trimToEmpty(from);
        final String initialFrom = from;
        String to = null;

        // first we check to see if there's an array
        // type mapping directly defined in the mappings
        final Mapping mapping = this.getMapping(from);
        if (mapping != null)
        {
            to = mapping.getTo();
        }
        if (to == null)
        {
            to = initialFrom;
        }
        return StringUtils.trimToEmpty(to);
    }

    /**
     * Adds a mapping to the globally available mappings, these are used by this
     * class to instantiate mappings from logical names as opposed to physical
     * names.
     *
     * @param mappingsUri the Mappings URI to add to the globally available Mapping
     *        instances.
     */
    public static void addLogicalMappings(final URL mappingsUri)
    {
        final Mappings mappings = Mappings.getInstance(
                mappingsUri,
                true);
        logicalMappings.put(
            mappings.getName(),
            mappings);
    }

    /**
     * Returns true if the mapping contains the <code>from</code> value
     *
     * @param from the value of the from mapping.
     * @return true if it contains <code>from</code>, false otherwise.
     */
    public boolean containsFrom(final String from)
    {
        return this.getMapping(from) != null;
    }

    /**
     * Returns true if the mapping contains the <code>to</code> value
     *
     * @param to the value of the to mapping.
     * @return true if it contains <code>to</code>, false otherwise.
     */
    public boolean containsTo(final String to)
    {
        for (Mapping mapping : this.getMappings())
        {
            if (mapping.getTo().trim().equals(to))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * Returns the resource URI from which this Mappings object was loaded.
     *
     * @return URL of the resource.
     */
    public URL getResource()
    {
        return this.resource;
    }

    /**
     * Gets all Mapping instances for for this Mappings instance.
     *
     * @return a collection containing <strong>all </strong> Mapping instances.
     */
    public Collection<Mapping> getMappings()
    {
        return this.mappings.values();
    }

    /**
     * Gets the mapping having the given <code>from</code>.
     *
     * @param from the <code>from</code> mapping.
     * @return the Mapping instance (or null if it doesn't exist).
     */
    public Mapping getMapping(final String from)
    {
        return this.mappings.get(StringUtils.trimToEmpty(from));
    }

    /**
     * Caches the complete path.
     */
    private final Map<String, String> completePaths = new LinkedHashMap<String, String>();

    /**
     * Constructs the complete path from the given <code>relativePath</code>
     * and the resource of the parent {@link Mappings#getResource()} as the root
     * of the path.
     * @param relativePath
     * @return the complete path.
     */
    final String getCompletePath(final String relativePath)
    {
        String completePath = this.completePaths.get(relativePath);
        if (completePath == null)
        {
            final StringBuilder path = new StringBuilder();
            if (this.mappings != null)
            {
                final URL resource = this.getResource();
                if (resource != null)
                {
                    String rootPath = resource.getFile().replace(
                            '\\',
                            '/');
                    rootPath = rootPath.substring(
                            0,
                            rootPath.lastIndexOf('/') + 1);
                    path.append(rootPath);
                }
            }
            if (relativePath != null)
            {
                path.append(StringUtils.trimToEmpty(relativePath));
            }
            completePath = path.toString();
            this.completePaths.put(
                relativePath,
                completePath);
        }
        return ResourceUtils.unescapeFilePath(completePath);
    }

    /**
     * @see Object#toString()
     */
    public String toString()
    {
        return ToStringBuilder.reflectionToString(this);
    }
}