package org.andromda.core;

import java.io.EOFException;
import java.io.InputStream;
import java.net.ConnectException;
import java.net.URL;
import org.andromda.core.common.AndroMDALogger;
import org.andromda.core.common.ComponentContainer;
import org.andromda.core.common.ExceptionUtils;
import org.andromda.core.configuration.Configuration;
import org.andromda.core.engine.Engine;
import org.andromda.core.metafacade.ModelValidationMessage;
import org.andromda.core.server.Client;
import org.apache.log4j.Logger;

/**
 * The main entry point to the framework. Handles the processing of models.
 * Facilitates Model Driven Architecture by enabling the generation of source
 * code, configuration files, and other such artifacts from a single or multiple
 * models.
 *
 * @see Engine
 * @author Chad Brandon
 */
public final class AndroMDA
{
    /**
     * The logger instance.
     */
    private static final Logger LOGGER = Logger.getLogger(AndroMDA.class);

    /**
     * The AndroMDA engine instance.
     */
    private Engine engine;

    /**
     * Gets a new instance of AndroMDA.
     *
     * @return the new instance of AndroMDA.
     */
    public static AndroMDA newInstance()
    {
        return new AndroMDA();
    }

    /**
     * Hidden constructor.
     */
    private AndroMDA()
    {
        AndroMDALogger.initialize();
        this.engine = Engine.newInstance();
    }

    /**
     * Runs AndroMDA with the given configuration.
     *
     * @param configurationUri the URI to the configuration file that configures
     *        AndroMDA.
     */
    public void run(final URL configurationUri)
    {
        ExceptionUtils.checkNull(
            "configurationUri",
            configurationUri);
        this.run(Configuration.getInstance(configurationUri), false, null);
    }

    /**
     * Runs AndroMDA with the given configuration.
     *
     * @param configurationStream the InputStream that contains the
     *        configuration contents for configuring AndroMDA.
     */
    public void run(final InputStream configurationStream)
    {
        ExceptionUtils.checkNull(
            "configurationStream",
            configurationStream);
        this.run(Configuration.getInstance(configurationStream), false, null);
    }

    /**
     * Runs AndroMDA with the given configuration.
     *
     * @param configuration the String that contains the configuration contents
     *        for configuring AndroMDA.
     */
    public void run(final String configuration)
    {
        ExceptionUtils.checkEmpty(
            "configuration",
            configuration);
        this.run(Configuration.getInstance(configuration), false, null);
    }

    /**
     * Initializes AndroMDA without running the engine.
     *
     * @param configuration the configuration from which to initialize AndroMDA
     */
    public void initialize(final Configuration configuration)
    {
        ExceptionUtils.checkNull(
            "configuration",
            configuration);
        this.engine.initialize(configuration);
    }

    /**
     * Initializes AndroMDA without running the engine.
     *
     * @param configurationStream the InputStream that contains the
     *        configuration contents for configuring AndroMDA.
     */
    public void initialize(final InputStream configurationStream)
    {
        ExceptionUtils.checkNull(
            "configurationStream",
            configurationStream);
        this.engine.initialize(Configuration.getInstance(configurationStream));
    }

    /**
     * Initializes AndroMDA without running the engine.
     *
     * @param configuration the String that contains the configuration contents
     *        for configuring AndroMDA.
     */
    public void initialize(final String configuration)
    {
        ExceptionUtils.checkEmpty(
            "configuration",
            configuration);
        this.engine.initialize(Configuration.getInstance(configuration));
    }

    /**
     * Initializes AndroMDA without running the engine.
     *
     * @param configurationUri the URI to the configuration file that configures
     *        AndroMDA.
     */
    public void initialize(final URL configurationUri)
    {
        ExceptionUtils.checkNull(
            "configurationUri",
            configurationUri);
        this.run(Configuration.getInstance(configurationUri), false, null);
    }

    /**
     * Runs AndroMDA with the given configuration. Determines whether or not
     * AndroMDA should be run in client/server mode (if the client can contact
     * the AndroMDA server), or just stand-alone mode if the server can NOT be
     * contacted.
     *
     * @param configuration the configuration instance that configures AndroMDA.
     * @param lastModifiedCheck true=don't regenerate code if no changes made since last model update.
     * @param historyDir Output location for model generation history file (i.e. /target/history)
     * @return an array of model validation messages (if there have been any collected
     *         during AndroMDA execution).
     */
    public ModelValidationMessage[] run(final Configuration configuration,
        boolean lastModifiedCheck, final String historyDir)
    {
        ModelValidationMessage[] messages = null;
        if (configuration != null)
        {
            final Client serverClient = (Client)ComponentContainer.instance().findRequiredComponent(Client.class);
            boolean client = true;

            // only attempt to run with the client, if they
            // have a server defined in their configuration
            if (configuration.getServer() != null)
            {
                try
                {
                    serverClient.start(configuration);
                }
                catch (final Throwable throwable)
                {
                    final Throwable cause = ExceptionUtils.getRootCause(throwable);
                    if (cause instanceof ConnectException ||
                        cause instanceof EOFException)
                    {
                        // - if we can't connect to the server, it means
                        //   we aren't running in client mode
                        client = false;
                    }
                    else
                    {
                        throw new RuntimeException(throwable);
                    }
                }
            }
            else
            {
                client = false;
            }

            // - since we aren't running in 'client' mode, run the engine as usual
            if (!client)
            {
                this.engine.initialize(configuration);
                messages = this.engine.run(configuration, lastModifiedCheck, historyDir);
            }
        }
        else
        {
            LOGGER.warn("AndroMDA could not run because no configuration was defined");
        }
        return messages == null ? new ModelValidationMessage[0] : messages;
    }

    /**
     * Shuts down AndroMDA.
     */
    public void shutdown()
    {
        this.engine.shutdown();
    }
}