package org.andromda.maven.plugin.andromdapp;

import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.andromda.core.common.AndroMDALogger;
import org.andromda.core.common.ClassUtils;
import org.andromda.core.common.ResourceUtils;
import org.andromda.maven.plugin.andromdapp.hibernate.HibernateCreateSchema;
import org.andromda.maven.plugin.andromdapp.hibernate.HibernateDropSchema;
import org.andromda.maven.plugin.andromdapp.hibernate.HibernateUpdateSchema;
import org.andromda.maven.plugin.andromdapp.hibernate.HibernateValidateSchema;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.model.Dependency;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;

/**
 * Provides the ability to drop database schemas.
 *
 * @goal schema
 * @requiresDependencyResolution runtime
 * @author Chad Brandon
 */
public class SchemaMojo
    extends AbstractMojo
{
    /**
     * The schema task to execute (create, drop, update, validate)
     *
     * @parameter expression="${tasks}"
     */
    private String tasks;

    /**
     * The type of the create schema task to execute.
     *
     * @parameter expression="hibernate"
     * @required
     */
    private String taskType;

    /**
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject project;

    /**
     * Any property files that should be loaded into the schema properties.
     *
     * @parameter
     */
    private String[] propertyFiles;

    /**
     * The properties that can be passed to the schema task.
     *
     * @parameter
     */
    private Properties properties = new Properties();

    /**
     * @component role="org.apache.maven.artifact.factory.ArtifactFactory"
     * @required
     * @readonly
     */
    private ArtifactFactory factory;

    /**
     * Whether or not scripts should be executed (if this is set to false, they will
     * only be generated, but not executed).
     *
     * @parameter expression="${executeScripts}"
     */
    private boolean executeScripts = true;

    /**
     * @parameter expression="${plugin.artifacts}"
     * @required
     */
    private List<Artifact> pluginArtifacts;

    /**
     * Artifact resolver, needed to download source jars for inclusion in
     * classpath.
     *
     * @component role="org.apache.maven.artifact.resolver.ArtifactResolver"
     * @required
     * @readonly
     */
    private ArtifactResolver artifactResolver;

    /**
     * @parameter expression="${localRepository}"
     * @required
     * @readonly
     */
    private ArtifactRepository localRepository;

    /**
     * The name of the JDBC driver class.
     *
     * @parameter
     * @required
     */
    private String jdbcDriver;

    /**
     * The JDBC connection URL.
     *
     * @parameter
     * @required
     */
    private String jdbcConnectionUrl;

    /**
     * The JDBC username for the database.
     *
     * @parameter
     * @required
     */
    private String jdbcUsername;

    /**
     * The JDBC password for the database.
     *
     * @parameter
     */
    private String jdbcPassword = "";

    /**
     * The jar containing the JDBC driver.
     *
     * @parameter
     * @required
     */
    private String jdbcDriverJar;

    /**
     * Defines the location(s) of any SQL scripts to be executed.
     *
     * @parameter
     */
    private List<String> scripts;

    /**
     * @see org.apache.maven.plugin.Mojo#execute()
     */
    public void execute()
        throws MojoExecutionException, MojoFailureException
    {
        Connection connection = null;
        try
        {
            AndroMDALogger.initialize();
            this.initializeClassLoaderWithJdbcDriver();

            final List<String> tasks = this.getTasks();
            if (tasks != null && !tasks.isEmpty())
            {
                final Map<String, Class> tasksMap = SchemaMojo.tasksCache.get(this.taskType);
                if (tasksMap == null)
                {
                    throw new MojoExecutionException('\'' + taskType +
                        "' is not a valid task type, valid task types are: " + tasksMap.keySet());
                }

                this.properties.putAll(this.project.getProperties());
                for (String task : this.getTasks())
                {
                    task = ObjectUtils.toString(task.trim());
                    if (this.propertyFiles != null)
                    {
                        final int numberOfPropertyFiles = propertyFiles.length;
                        for (int ctr2 = 0; ctr2 < numberOfPropertyFiles; ctr2++)
                        {
                            final URL propertyFileUri = ResourceUtils.toURL(propertyFiles[ctr2]);
                            if (propertyFileUri != null)
                            {
                                final InputStream stream = propertyFileUri.openStream();
                                this.properties.load(stream);
                                stream.close();
                            }
                        }
                    }

                    // - load all the fields of this class into the properties
                    final Field[] fields = this.getClass().getDeclaredFields();
                    if (fields != null)
                    {
                        final int numberOfFields = fields.length;
                        for (int ctr = 0; ctr < numberOfFields; ctr++)
                        {
                            final Field field = fields[ctr];
                            final Object value = field.get(this);
                            if (value != null)
                            {
                                this.properties.put(
                                    field.getName(),
                                    value);
                            }
                        }
                    }

                    final Set<String> classpathElements = new LinkedHashSet<String>(this.project.getRuntimeClasspathElements());
                    classpathElements.addAll(this.getProvidedClasspathElements());
                    this.initializeClasspathFromClassPathElements(classpathElements);
                    final Class type = tasksMap.get(task);
                    if (type == null)
                    {
                        throw new MojoExecutionException('\'' + task + "' is not a valid task, valid types are: " +
                            tasksMap.keySet());
                    }

                    final SchemaManagement schemaManagement = (SchemaManagement)ClassUtils.newInstance(type);
                    connection = executeScripts ? this.getConnection() : null;
                    this.executeSql(
                        connection,
                        schemaManagement.execute(
                            connection,
                            this.properties));
                }
            }

            // - execute any additional scripts
            this.executeScripts(connection);
        }
        catch (final Throwable throwable)
        {
            throw new MojoExecutionException("An error occurred while attempting to create the schema", throwable);
        }
        finally
        {
            if (connection != null)
            {
                try
                {
                    connection.close();
                }
                catch (SQLException e)
                {
                    // - ignore
                }
            }
        }
    }

    /**
     * Retrieves the tasks as a List.
     *
     * @return the tasks as a List.
     */
    private List<String> getTasks()
    {
        return this.tasks != null ? Arrays.asList(this.tasks.split(",")) : null;
    }

    /**
     * Executes any scripts found within the {@link #scriptLocations} and
     * included using the {@link #scriptIncludes}
     *
     * @param connection the SQL connection used to execute the scripts.
     * @throws MojoExecutionException
     * @throws Exception
     */
    private void executeScripts(final Connection connection)
        throws MojoExecutionException
    {
        final List<String> tasks = this.getTasks();
        if (this.scripts != null && !this.scripts.isEmpty())
        {
            for (final String location : scripts)
            {
                try
                {
                    this.executeSql(
                        connection,
                        location);
                }
                catch (final Exception exception)
                {
                    throw new MojoExecutionException("Execution failed on script: " + location, exception);
                }
            }
        }
        else if (tasks == null || tasks.isEmpty())
        {
            this.getLog().info("No scripts found to execute");
        }
    }

    /**
     * Sets the current context class loader from the given runtime classpath
     * elements.
     * @param classpathFiles
     * @throws MalformedURLException
     */
    protected void initializeClasspathFromClassPathElements(final Set<String> classpathFiles)
        throws MalformedURLException
    {
        // - for some reason some of the plugin dependencies are being excluded from the classloader,
        //   so we explicitly load them
        if (this.pluginArtifacts != null)
        {
            for (final Artifact artifact : this.pluginArtifacts)
            {
                final File artifactFile = artifact.getFile();
                if (artifactFile != null)
                {
                    classpathFiles.add(artifactFile.toString());
                }
            }
        }

        final List<String> files = new ArrayList<String>(classpathFiles);
        if (!files.isEmpty())
        {
            final URL[] classpathUrls = new URL[classpathFiles.size()];

            for (int ctr = 0; ctr < classpathFiles.size(); ++ctr)
            {
                final File file = new File(files.get(ctr));
                if (this.getLog().isDebugEnabled())
                {
                    getLog().debug("adding to classpath '" + file + '\'');
                }
                classpathUrls[ctr] = file.toURI().toURL();
            }

            final URLClassLoader loader =
                new URLClassLoader(classpathUrls,
                    Thread.currentThread().getContextClassLoader());
            Thread.currentThread().setContextClassLoader(loader);
        }
    }

    /**
     * Initializes the context class loader with the given
     * <code>jdbcDriverJar</code>
     *
     * @throws MalformedURLException
     */
    protected void initializeClassLoaderWithJdbcDriver()
        throws MalformedURLException
    {
        Thread.currentThread().setContextClassLoader(
            new URLClassLoader(
                new URL[] {new File(this.jdbcDriverJar).toURI().toURL()},
                Thread.currentThread().getContextClassLoader()));
    }

    /**
     * Adds any dependencies with a scope of 'provided' to the current project
     * with a scope of runtime.
     * @return classpathElements
     * @throws ArtifactNotFoundException
     * @throws ArtifactResolutionException
     */
    protected List<String> getProvidedClasspathElements()
        throws ArtifactResolutionException, ArtifactNotFoundException
    {
        final List<String> classpathElements = new ArrayList<String>();
        final List<Dependency> dependencies = this.project.getDependencies();
        if (dependencies != null && !dependencies.isEmpty())
        {
            for (final Dependency dependency : dependencies)
            {
                if (Artifact.SCOPE_PROVIDED.equals(dependency.getScope()))
                {
                    final String file = this.getDependencyFile(dependency);
                    if (file != null)
                    {
                        classpathElements.add(file);
                    }
                }
            }
        }
        return classpathElements;
    }

    /**
     * Adds a dependency to the current project's dependencies.
     *
     * @param dependency
     * @throws ArtifactNotFoundException
     * @throws ArtifactResolutionException
     */
    private String getDependencyFile(final Dependency dependency)
        throws ArtifactResolutionException, ArtifactNotFoundException
    {
        String file = null;
        if (dependency != null)
        {
            final Artifact artifact =
                this.factory.createArtifact(
                    dependency.getGroupId(),
                    dependency.getArtifactId(),
                    dependency.getVersion(),
                    null,
                    dependency.getType());

            this.artifactResolver.resolve(
                artifact,
                project.getRemoteArtifactRepositories(),
                this.localRepository);
            file = artifact.getFile() != null ? artifact.getFile().toString() : null;
        }
        return file;
    }

    /**
     * Retrieves a database connection, given the appropriate database
     * information.
     *
     * @return the retrieved connection.
     * @throws Exception
     */
    protected Connection getConnection()
        throws Exception
    {
        Driver driver = (Driver)ClassUtils.loadClass(this.jdbcDriver).newInstance();
        DriverManager.registerDriver(new JdbcDriverWrapper(driver));
        return DriverManager.getConnection(
            this.jdbcConnectionUrl,
            this.jdbcUsername,
            this.jdbcPassword);
    }

    /**
     * The statement end character.
     */
    private static final String STATEMENT_END = ";";

    /**
     * Executes the SQL contained with the file located at the
     * <code>sqlPath</code>.
     *
     * @param connection the connection used to execute the SQL.
     * @param sqlPath the path to the SQL file.
     * @throws Exception
     */
    public void executeSql(
        final Connection connection,
        final String sqlPath)
        throws Exception
    {
        if (StringUtils.isNotBlank(sqlPath))
        {
            final URL sqlUrl = ResourceUtils.toURL(sqlPath);
            if (sqlUrl != null)
            {
                this.successes = 0;
                this.failures = 0;
                Statement statement = null;
                if (connection != null)
                {
                    statement = connection.createStatement();
                }
                final InputStream stream = sqlUrl.openStream();
                final BufferedReader resourceInput = new BufferedReader(new InputStreamReader(stream));
                StringBuilder sql = new StringBuilder();
                for (String line = resourceInput.readLine(); line != null; line = resourceInput.readLine())
                {
                    if (line.startsWith("//"))
                    {
                        continue;
                    }
                    if (line.startsWith("--"))
                    {
                        continue;
                    }
                    sql.append(line);
                    if (line.endsWith(STATEMENT_END))
                    {
                        if (statement != null)
                        {
                            this.executeSql(
                                statement,
                                sql.toString().replaceAll(
                                    STATEMENT_END,
                                    ""));
                        }
                        sql = new StringBuilder();
                    }
                    sql.append('\n');
                }
                resourceInput.close();
                if (statement != null)
                {
                    statement.close();
                }
            }
            this.getLog().info(" Executed script: " + sqlPath);
            final String count = String.valueOf(this.successes + this.failures);
            this.getLog().info(' ' + count + "  SQL statements executed");
            this.getLog().info(" Failures: " + this.failures);
            this.getLog().info(" Successes: " + this.successes);
        }
    }

    /**
     * Stores the count of statements that were executed successfully.
     */
    private int successes;

    /**
     * Stores the count of statements that failed.
     */
    private int failures;

    /**
     * Executes the given <code>sql</code>, using the given
     * <code>statement</code>.
     *
     * @param statement the statement to use to execute the SQL.
     * @param sql the SQL to execute.
     * @throws SQLException
     */
    private void executeSql(
        final Statement statement,
        final String sql)
    {
        this.getLog().info(sql.trim());
        try
        {
            statement.execute(sql);
            this.successes++;
        }
        catch (final SQLException exception)
        {
            this.failures++;
            this.getLog().warn(exception.toString());
        }
    }

    /**
     * Stores the task types.
     */
    private static final HashMap<String, Map<String, Class>> tasksCache = new LinkedHashMap<String, Map<String, Class>>();

    static
    {
        // - initialize the hibernate task types
        final Map<String, Class> hibernateTasks = new LinkedHashMap<String, Class>();
        tasksCache.put(
            "hibernate",
            hibernateTasks);
        hibernateTasks.put(
            "create",
            HibernateCreateSchema.class);
        hibernateTasks.put(
            "drop",
            HibernateDropSchema.class);
        hibernateTasks.put(
            "update",
            HibernateUpdateSchema.class);
        hibernateTasks.put(
            "validate",
            HibernateValidateSchema.class);
    }
}