package org.andromda.core.namespace;

import java.io.InputStream;
import java.net.URL;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.andromda.core.common.AndroMDALogger;
import org.andromda.core.common.ComponentContainer;
import org.andromda.core.common.Merger;
import org.andromda.core.common.ResourceFinder;
import org.andromda.core.common.ResourceUtils;
import org.andromda.core.common.XmlObjectFactory;
import org.andromda.core.configuration.Namespaces;
import org.andromda.core.profile.Profile;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;

/**
 * The registry for namespace components. Namespace components are components
 * that reside within a namespace and can be configured by a namespace.
 *
 * @author Chad Brandon
 */
public class NamespaceComponents
{
    /**
     * The shared registry instance.
     */
    private static NamespaceComponents instance;

    /**
     * Gets the shared instance of this registry.
     *
     * @return the shared registry instance.
     */
    public static final NamespaceComponents instance()
    {
        if (instance == null)
        {
            final XmlObjectFactory factory = XmlObjectFactory.getInstance(NamespaceComponents.class);
            instance = (NamespaceComponents)factory.getObject(ResourceUtils.getResource(CONFIGURATION_URI));
        }
        return instance;
    }

    /**
     * The URI to the descriptor for this instance.
     */
    private static final String CONFIGURATION_URI = "META-INF/andromda/namespace-components.xml";

    /**
     * This class should not be instantiated through this constructor, it is
     * only here to allow construction by the {@link XmlObjectFactory}. The
     * instance of this class should be retrieved through the call to
     * {@link #instance()}.
     */
    public NamespaceComponents()
    {
    }

    /**
     * Discovers all namespaces found on the classpath.
     */
    public void discover()
    {
        AndroMDALogger.info("- discovering namespaces -");

        final XmlObjectFactory registryFactory = XmlObjectFactory.getInstance(NamespaceRegistry.class);
        final ComponentContainer container = ComponentContainer.instance();

        // - discover all registries and sort them by name
        final Map<NamespaceRegistry, URL> registryMap = this.discoverAllRegistries();
        final List<NamespaceRegistry> registries = new ArrayList<NamespaceRegistry>(registryMap.keySet());
        Collections.sort(
            registries,
            new NamespaceRegistryComparator());
        for (NamespaceRegistry registry : registries)
        {
            final URL resource = registryMap.get(registry);
            final String registryName = registry.getName();

            // - only register if we haven't yet registered the namespace resource
            if (!this.registeredNamespaceResources.contains(resource))
            {
                final Namespaces namespaces = Namespaces.instance();
                final String namespace = registry.isShared() ? Namespaces.DEFAULT : registry.getName();

                // - first merge on the namespace registry descriptor (if needed)
                final Merger merger = Merger.instance();
                boolean requiresMerge = merger.requiresMerge(namespace);
                if (requiresMerge)
                {
                    registry =
                            (NamespaceRegistry) registryFactory.getObject(
                                    merger.getMergedString(
                                            ResourceUtils.getContents(resource),
                                            namespace), resource);
                }

                // - add the resource root
                registry.addResourceRoot(this.getNamespaceResourceRoot(resource));

                // - only log the fact we've found the namespace registry, if we haven't done it yet
                if (!this.registeredRegistries.contains(registryName))
                {
                    AndroMDALogger.info("found namespace --> '" + registryName + '\'');
                    this.registeredRegistries.add(registryName);
                }

                final NamespaceRegistry existingRegistry = namespaces.getRegistry(registryName);
                if (existingRegistry != null)
                {
                    // - if we already have an existing registry with the same name, copy
                    //   over any resources.
                    registry.copy(existingRegistry);
                }

                // - add the registry to the namespaces instance
                namespaces.addRegistry(registry);
                final String[] components = registry.getRegisteredComponents();
                for (final String componentName : components)
                {
                    final Component component = this.getComponent(componentName);
                    if (component == null)
                    {
                        throw new NamespaceComponentsException('\'' + componentName +
                                "' is not a valid namespace component");
                    }

                    // - add any paths defined within the registry
                    component.addPaths(registry.getPaths(component.getName()));
                    if (!container.isRegisteredByNamespace(
                            registryName,
                            component.getType()))
                    {
                        AndroMDALogger.info("  +  registering component '" + componentName + '\'');
                        final XmlObjectFactory componentFactory = XmlObjectFactory.getInstance(component.getType());
                        final URL componentResource =
                                this.getNamespaceResource(
                                        registry.getResourceRoots(),
                                        component.getPaths());
                        if (componentResource == null)
                        {
                            throw new NamespaceComponentsException('\'' + componentName +
                                    "' is not a valid component within namespace '" + namespace + "' (the " +
                                    componentName + "'s descriptor can not be found)");
                        }
                        NamespaceComponent namespaceComponent =
                                (NamespaceComponent) componentFactory.getObject(componentResource);

                        // - now perform a merge of the descriptor (if we require one)
                        if (requiresMerge)
                        {
                            namespaceComponent =
                                    (NamespaceComponent) componentFactory.getObject(
                                            merger.getMergedString(
                                                    ResourceUtils.getContents(componentResource),
                                                    namespace));
                        }

                        namespaceComponent.setNamespace(registryName);
                        namespaceComponent.setResource(componentResource);
                        container.registerComponentByNamespace(
                                registryName,
                                component.getType(),
                                namespaceComponent);
                    }
                }
            }
            this.registeredNamespaceResources.add(resource);
        }

        // - initialize the profile
        Profile.instance().initialize();
    }

    /**
     * Discovers all registries and loads them into a map with the registry as the key
     * and the resource that configured the registry as the value.
     *
     * @return the registries in a Map
     */
    private Map<NamespaceRegistry, URL> discoverAllRegistries()
    {
        final Map<NamespaceRegistry, URL> registries = new HashMap<NamespaceRegistry, URL>();
        final URL[] resources = ResourceFinder.findResources(this.getPath());
        final XmlObjectFactory registryFactory = XmlObjectFactory.getInstance(NamespaceRegistry.class);
        if (resources != null)
        {
            for (final URL resource : resources)
            {
                final NamespaceRegistry registry = (NamespaceRegistry) registryFactory.getObject(resource);
                registries.put(
                        registry,
                        resource);
            }
        }
        return registries;
    }

    /**
     * Keeps track of the namespaces resources that have been already registered.
     */
    private Collection<URL> registeredNamespaceResources = new ArrayList<URL>();

    /**
     * Keeps track of the namespace registries that have been registered.
     */
    private Collection<String> registeredRegistries = new ArrayList<String>();

    /**
     * Attempts to retrieve a resource relative to the given
     * <code>resourceRoots</code> by computing the complete path from the given
     * relative <code>path</code>. Retrieves the first valid one found.
     *
     * @param resourceRoots the resourceRoots from which to perform search.
     * @param paths the relative paths to check.
     * @return the resource found or null if invalid.
     */
    private URL getNamespaceResource(
        final URL[] resourceRoots,
        final String[] paths)
    {
        URL namespaceResource = null;
        if (resourceRoots != null)
        {
            for (final URL resource : resourceRoots)
            {
                for (final String path : paths)
                {
                    InputStream stream = null;
                    try
                    {
                        namespaceResource = new URL(ResourceUtils.normalizePath(resource + path));
                        stream = namespaceResource.openStream();
                    }
                    catch (final Throwable throwable)
                    {
                        namespaceResource = null;
                    }
                    finally
                    {
                        IOUtils.closeQuietly(stream);
                    }

                    // - break if we've found one
                    if (namespaceResource != null)
                    {
                        break;
                    }
                }

                // - break if we've found one
                if (namespaceResource != null)
                {
                    break;
                }
            }
        }
        return namespaceResource;
    }

    /**
     * Attempts to retrieve the resource root of the namespace; that is the
     * directory (whether it be a regular directory or achive root) which this
     * namespace spans.
     *
     * @param resource the resource from which to retrieve the root.
     * @return the namespace root, or null if could not be found.
     */
    private URL getNamespaceResourceRoot(final URL resource)
    {
        final String resourcePath = resource != null ? resource.toString().replace(
                '\\',
                '/') : null;
        return ResourceUtils.toURL(StringUtils.replace(
                resourcePath,
                this.path,
                ""));
    }

    /**
     * The path to search for the namespace descriptor.
     */
    private String path;

    /**
     * Gets the path to the namespace registry descriptor.
     *
     * @return The path to a namespace registry descriptor.
     */
    public String getPath()
    {
        return this.path;
    }

    /**
     * Sets the path to the namespace registry descriptor.
     *
     * @param path The path to a namespace registry descriptor.
     */
    public void setPath(String path)
    {
        this.path = path;
    }

    /**
     * Stores the actual component definitions for this namespace registry.
     */
    private final Map<String, Component> components = new LinkedHashMap<String, Component>();

    /**
     * Adds a new component to this namespace registry.
     *
     * @param component the component to add to this namespace registry.
     */
    public void addComponent(final Component component)
    {
        if (component != null)
        {
            this.components.put(
                component.getName(),
                component);
        }
    }

    /**
     * Shuts down this component registry and reclaims any resources used.
     */
    public void shutdown()
    {
        this.components.clear();
        this.registeredNamespaceResources.clear();
        this.registeredRegistries.clear();
        NamespaceComponents.instance = null;
    }

    /**
     * Retrieves a component by name (or returns null if one can not be found).
     *
     * @param name the name of the component to retrieve.
     * @return the component instance or null.
     */
    private Component getComponent(final String name)
    {
        return this.components.get(name);
    }

    /**
     * Used to sort namespace registries by name.
     */
    private static final class NamespaceRegistryComparator
        implements Comparator<NamespaceRegistry>
    {
        private final Collator collator = Collator.getInstance();

        NamespaceRegistryComparator()
        {
            collator.setStrength(Collator.PRIMARY);
        }

        public int compare(
            final NamespaceRegistry objectA,
            final NamespaceRegistry objectB)
        {
            return collator.compare(
                objectA.getName(),
                objectB.getName());
        }
    }
}