package org.andromda.core.profile;

import java.io.Serializable;
import java.net.URL;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import org.andromda.core.common.ComponentContainer;
import org.andromda.core.common.XmlObjectFactory;
import org.andromda.core.configuration.NamespaceProperties;
import org.andromda.core.configuration.Namespaces;
import org.andromda.core.configuration.Property;
import org.andromda.core.namespace.BaseNamespaceComponent;
import org.apache.commons.lang.StringUtils;

/**
 * Represents an AndroMDA profile applied to a model.
 * Profiles allow us to extend aspects of a model.
 *
 * @author Chad Brandon
 * @author Bob Fields
 */
public class Profile
    extends BaseNamespaceComponent
    implements Serializable
{
    private static final long serialVersionUID = 34L;

    /**
     * The shared instance of this class.
     */
    private static Profile instance;

    /**
     * Gets the shared instance of this class.
     *
     * @return the shared instance.
     */
    public static Profile instance()
    {
        if (instance == null)
        {
            instance = new Profile();
        }
        return instance;
    }

    /**
     * Stores the elements for the profile (by name).
     */
    private final Map<String, String> elements = new LinkedHashMap<String, String>();

    /**
     * Adds a new element to this namespace registry.
     * @param name
     * @param value
     */
    public void addElement(
        final String name,
        final String value)
    {
        this.elements.put(
            name,
            value);
    }

    /**
     * Gets the profile value (if one is available)
     * for the given name, otherwise returns name.
     *
     * @param name the profile name to retrieve.
     * @return the value.
     */
    public String get(String name)
    {
        name = StringUtils.trim(name);
        // - attempt to get the profile value from the profile defined
        //   by the profile mappings uri first
        String value = this.elements.get(name);

        // - if we can't get any profile value from an the override profile
        //   mapping, then we resort to the ones defined in the namespace
        if (StringUtils.isBlank(value))
        {
            Map<String, String> namespaceElements = this.getNamespaceElements(this.getNamespace());
            if (namespaceElements != null)
            {
                value = namespaceElements.get(name);
            }
            if (value == null)
            {
                namespaceElements = this.getNamespaceElements(Namespaces.DEFAULT);
                if (namespaceElements != null)
                {
                    value = namespaceElements.get(name);
                }
            }
        }
        return value != null ? value : name;
    }

    /**
     * Initializes this profile instance.
     */
    public void initialize()
    {
        final Collection<Profile> profiles = ComponentContainer.instance().findComponentsOfType(Profile.class);
        for (final Profile profile : profiles)
        {
            String namespace = profile.getNamespace();
            if (Namespaces.instance().isShared(namespace))
            {
                profile.setNamespace(Namespaces.DEFAULT);
            }
            this.addElements(profile);
        }
    }

    /**
     * Refreshes the profile instance.
     */
    public void refresh()
    {
        // - clear out the instance's elements
        this.elements.clear();
        try
        {
            final Property mappingsUri =
                Namespaces.instance().getProperty(
                    Namespaces.DEFAULT,
                    NamespaceProperties.PROFILE_MAPPINGS_URI,
                    false);
            final String mappingsUriValue = mappingsUri != null ? mappingsUri.getValue() : null;
            if (mappingsUriValue != null)
            {
                final XmlObjectFactory factory = XmlObjectFactory.getInstance(Profile.class);
                final Profile profile = (Profile)factory.getObject(new URL(mappingsUriValue.trim()));
                this.elements.putAll(profile.elements);
            }
        }
        catch (final Throwable throwable)
        {
            throw new ProfileException(throwable);
        }
    }

    /**
     * Stores all elements.
     */
    private final Map<String, Map<String, String>> allElements = new LinkedHashMap<String, Map<String, String>>();

    /**
     * Adds the elements to the internal elements map.
     * @param profile Profile
     */
    private void addElements(final Profile profile)
    {
        final Collection<String> elements = profile != null ? profile.elements.keySet() : null;
        if (elements != null && profile != null)
        {
            final String namespace = profile.getNamespace();
            final Map<String, String> namespaceElements = this.getNamespaceElements(namespace);
            for (final String name : elements)
            {
                namespaceElements.put(
                    name,
                    profile.elements.get(name));
            }
        }
    }

    /**
     * Adds a namespace element for the given namespace with the given name and
     * value.
     * @param namespace the namespace for which to add the namespace element.
     * @param name the element name.
     * @param value the element value.
     */
    public void addElement(
        final String namespace,
        final String name,
        final String value)
    {
        final Map<String, String> namespaceElements = this.getNamespaceElements(namespace);
        namespaceElements.put(
            name,
            value);
    }

    /**
     * Retrieves the namespace elements map for the given namespace.
     * If one doesn't exist, then a new one is created.
     * @param namespace the namespace for which to retrieve the namespace elements
     * @return the namespace element map
     */
    private Map<String, String> getNamespaceElements(final String namespace)
    {
        Map<String, String> namespaceElements = this.allElements.get(namespace);
        if (namespaceElements == null)
        {
            namespaceElements = new LinkedHashMap<String, String>();
            this.allElements.put(
                namespace,
                namespaceElements);
        }
        return namespaceElements;
    }

    /**
     * Shuts down the shared instance and releases any used resources.
     */
    public void shutdown()
    {
        Profile.instance = null;
    }
}