package org.andromda.andromdapp;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.andromda.core.common.AndroMDALogger;
import org.andromda.core.common.ResourceFinder;
import org.andromda.core.common.ResourceUtils;
import org.andromda.core.common.XmlObjectFactory;
import org.apache.commons.lang.StringUtils;

/**
 * Represents an instance of the AndroMDA application
 * generator.
 *
 * @author Chad Brandon
 */
public class AndroMDApp
{
    /**
     * An AndroMDApp configuration that contains some internal configuration information (like the AndroMDA
     * version, and other common properties).
     */
    private static final String INTERNAL_CONFIGURATION_URI = "META-INF/andromdapp/configuration.xml";

    /**
     * Runs the AndroMDApp generation process.
     */
    public void run()
    {
        try
        {
            AndroMDALogger.initialize();
            final URL internalConfiguration = ResourceUtils.getResource(INTERNAL_CONFIGURATION_URI);
            if (internalConfiguration == null)
            {
                throw new AndroMDAppException("No configuration could be loaded from --> '" +
                    INTERNAL_CONFIGURATION_URI + '\'');
            }
            this.addConfigurationUri(internalConfiguration.toString());
            this.initialize();
            this.chooseTypeAndRun(true);
        }
        catch (final Throwable throwable)
        {
            if (throwable instanceof AndroMDAppException)
            {
                throw (AndroMDAppException)throwable;
            }
            throw new AndroMDAppException(throwable);
        }
    }

    /**
     * The name of the AndroMDApp descriptor.
     */
    static final String DESCRIPTOR = "andromdapp.xml";

    /**
     * The directory in which the descriptors are kept.
     */
    private static final String DESCRIPTOR_DIRECTORY = "META-INF/andromdapp";

    /**
     * All types of discovered AndroMDApps
     */
    private final Map<String, AndroMDAppType> types = new LinkedHashMap<String, AndroMDAppType>();

    /**
     * Performs any required initialization.
     * @throws Exception
     */
    private void initialize()
        throws Exception
    {
        final URL[] descriptorDirectories = ResourceFinder.findResources(DESCRIPTOR_DIRECTORY);
        if (descriptorDirectories != null && descriptorDirectories.length > 0)
        {
            final int numberOfDescriptorDirectories = descriptorDirectories.length;
            for (int ctr = 0; ctr < numberOfDescriptorDirectories; ctr++)
            {
                final List<String> directoryContents =
                    ResourceUtils.getDirectoryContents(
                        descriptorDirectories[ctr],
                        true,
                        null);
                for (final String uri : directoryContents)
                {
                    if (uri.replaceAll(".*(\\\\+|/)","").equals(DESCRIPTOR))
                    {
                        final XmlObjectFactory factory = XmlObjectFactory.getInstance(AndroMDApp.class);
                        final URL descriptorUri = ResourceUtils.toURL(uri);
                        final AndroMDAppType andromdapp = (AndroMDAppType) factory.getObject(descriptorUri);
                        andromdapp.setResource(descriptorUri);
                        final String type = andromdapp.getType();
                        AndroMDALogger.info("discovered andromdapp type --> '" + type + '\'');
                        this.types.put(
                                type,
                                andromdapp);
                    }
                }
            }
        }
    }

    /**
     * Stores the optional configuration instance.
     */
    private final List<Configuration> configurations = new ArrayList<Configuration>();

    /**
     * Adds the URI for an optional configuration  These are useful if you want
     * to preconfigure the andromdapp when any properties, etc.
     *
     * @param configurationUri the URI to the configuration.
     */
    public void addConfigurationUri(final String configurationUri)
    {
        if (StringUtils.isNotBlank(configurationUri))
        {
            final XmlObjectFactory factory = XmlObjectFactory.getInstance(Configuration.class);
            final URL configurationUrl = ResourceUtils.toURL(configurationUri);
            if (configurationUrl == null)
            {
                throw new AndroMDAppException("configuriationUri is invalid --> '" + configurationUri + '\'');
            }
            this.configurations.add((Configuration)factory.getObject(configurationUrl));
        }
    }

    /**
     * Adds the configuration contents stored as a String.
     *
     * @param configuration the configuration contents as a string.
     */
    public void addConfiguration(final String configuration)
    {
        if (StringUtils.isNotBlank(configuration))
        {
            final XmlObjectFactory factory = XmlObjectFactory.getInstance(Configuration.class);
            this.configurations.add((Configuration)factory.getObject(configuration));
        }
    }

    /**
     * Prompts the user to choose the type of application, and then runs that AndroMDAppType.
     * @throws Exception
     */
    private List<File> chooseTypeAndRun(final boolean write)
        throws Exception
    {
        if (this.types.isEmpty())
        {
            throw new AndroMDAppException("No '" + DESCRIPTOR + "' descriptor files could be found");
        }
        final Map<String, String> properties = new LinkedHashMap<String, String>();
        for (Configuration configuration : this.configurations)
        {
            properties.putAll(configuration.getAllProperties());
        }
        final String applicationType = properties.get(APPLICATION_TYPE);
        final Set<String> validTypes = this.types.keySet();
        AndroMDAppType andromdapp = this.types.get(applicationType);
        if (andromdapp == null)
        {
            if (this.types.size() > 1)
            {
                final StringBuilder typesChoice = new StringBuilder("[");
                for (final Iterator<String> iterator = validTypes.iterator(); iterator.hasNext();)
                {
                    final String type = iterator.next();
                    typesChoice.append(type);
                    if (iterator.hasNext())
                    {
                        typesChoice.append(", ");
                    }
                }
                typesChoice.append(']');
                this.printText("Please choose the type of application to generate " + typesChoice);
                String selectedType = this.readLine();
                while (!this.types.containsKey(selectedType))
                {
                    selectedType = this.readLine();
                }
                andromdapp = this.types.get(selectedType);
            }
            else if (!this.types.isEmpty())
            {
                andromdapp = this.types.entrySet().iterator().next().getValue();
            }
        }

        if (andromdapp == null)
        {
            throw new AndroMDAppException("AndromdaPP is null " + this.types.entrySet());
        }
        andromdapp.setConfigurations(this.configurations);
        andromdapp.initialize();

        final Map templateContext = andromdapp.getTemplateContext();

        final XmlObjectFactory factory = XmlObjectFactory.getInstance(AndroMDApp.class);
        final String contents = andromdapp.promptUser();
        // - evaluate all properties in the descriptor and recreate the AndroMDAppType
        andromdapp = (AndroMDAppType)factory.getObject(contents);
        andromdapp.setConfigurations(this.configurations);
        andromdapp.addToTemplateContext(templateContext);
        return andromdapp.processResources(write);
    }

    /**
     * Identifies the AndroMDApp type (used to override the prompting of the type).
     */
    private static final String APPLICATION_TYPE = "andromdappType";

    /**
     * Removes all structure generated from the previous run.
     */
    public void clean()
    {
        try
        {
            AndroMDALogger.initialize();
            this.initialize();
            final List<File> list = this.chooseTypeAndRun(false);
            for (final File file : list)
            {
                this.deleteFile(file);
            }
        }
        catch (final Throwable throwable)
        {
            if (throwable instanceof AndroMDAppException)
            {
                throw (AndroMDAppException)throwable;
            }
            throw new AndroMDAppException(throwable);
        }
    }

    /**
     * Deletes the given file and any empty parent directories
     * that the file might be contained within.
     *
     * @param file the file to remove.
     * @throws MalformedURLException
     */
    private void deleteFile(final File file) throws MalformedURLException
    {
        if (file != null && file.exists())
        {
            final File[] children = file.listFiles();
            if (children == null || children.length == 0)
            {
                if (file.delete())
                {
                    AndroMDALogger.info("Removed: '" + file.toURI().toURL() + '\'');
                }
                this.deleteFile(file.getParentFile());
            }
        }
    }

    /**
     * Prints text to the console.
     *
     * @param text the text to print to the console;
     */
    private void printText(final String text)
    {
        System.out.println();  // NOPMD - have to print to console prompt
        System.out.println(text);  // NOPMD - have to print to console prompt
        System.out.flush();
    }

    /**
     * Reads a line from standard input and returns the value.
     *
     * @return the value read from standard input.
     */
    private String readLine()
    {
        final BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        String inputString = null;
        try
        {
            inputString = input.readLine();
        }
        catch (final IOException exception)
        {
            AndroMDALogger.info("AndroMDApp Error reading inputLine from System.in");
        }
        return StringUtils.trimToNull(inputString);
    }
}