package org.andromda.maven.plugin.andromdapp;

import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.net.URL;
import java.util.List;
import java.util.Properties;
import org.andromda.core.common.ResourceUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.settings.Settings;
import org.apache.maven.shared.filtering.PropertyUtils;
import org.codehaus.plexus.util.InterpolationFilterReader;

/**
 * The abstract AndroMDAapp mojo (this should be extended by any Mojo that
 * executes AndroMDApp.
 *
 * @author Chad Brandon
 * @author Bob Fields
 */
public abstract class AbstractAndroMDAppMojo
    extends AbstractMojo
{
    /**
     * The URI to an optional AndroMDApp configuration file.
     *
     * @parameter expression="${configuration.uri}"
     */
    private String configurationUri;

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

    /**
     * The current user system settings for use in Maven. (allows us to pass the user
     * settings to the AndroMDA configuration).
     *
     * @parameter expression="${settings}"
     * @required
     * @readonly
     */
    protected Settings settings;

    /**
     * @parameter expression="${project.build.filters}"
     */
    protected List<String> propertyFiles;

    /**
     * Set this to 'true' to bypass cartridge tests entirely. Its use is NOT RECOMMENDED, but quite convenient on occasion.
     *
     * @parameter expression="${maven.test.skip}"
     */
    protected boolean skip;

    /**
     *  Set this to 'true' to skip running tests, but still compile them. Its use is NOT RECOMMENDED, but quite convenient on occasion.
     *
     * @parameter expression="${skipTests}"
     */
    protected boolean skipTests;

    /**
     * Set this to true to ignore a failure during testing. Its use is NOT RECOMMENDED, but quite convenient on occasion.
     *
     * @parameter expression="${maven.test.failure.ignore}" default-value="false"
     */
    protected boolean testFailureIgnore;

    /**
     * Whether or not processing should be skipped (this is if you want to completely skip code generation, i.e. if
     * code is already generated and you are creating the site from already generated source code).
     *
     * @parameter expression="${andromdapp.run.skip}"
     */
    protected boolean skipProcessing = false;

    /**
     * Collects and returns all properties as a Properties instance.
     *
     * @return the properties including those from the project, settings, etc.
     * @throws IOException
     */
    private Properties getProperties()
        throws IOException
    {
        // System properties
        final Properties properties = new Properties();

        properties.put(
            "settings",
            this.settings);

        // - project properties
        properties.putAll(this.project.getProperties());
        if (this.propertyFiles != null)
        {
            for (final String propertiesFile : this.propertyFiles)
            {
                final Properties projectProperties = PropertyUtils.loadPropertyFile(
                        new File(propertiesFile),
                        true,
                        true);
                properties.putAll(projectProperties);
            }
        }

        for (final Object propertyObject : properties.keySet())
        {
            final String property = (String)propertyObject;
            final String value = this.replaceProperties(properties, ObjectUtils.toString(properties.get(property)));
            properties.put(property, value);
        }

        properties.putAll(System.getProperties());

        return properties;
    }

    /**
     * Replaces all properties having the style
     * <code>${some.property}</code> with the value
     * of the specified property if there is one.
     *
     * @param string the string to perform replacement on.
     * @return this.replaceProperties(this.getProperties(), string);
     * @throws IOException
     */
    protected String replaceProperties(final String string)
        throws IOException
    {
        return this.replaceProperties(this.getProperties(), string);
    }

    /**
     * Retrieves the interpolated {#configurationUri} contents as a String.
     *
     * @return the contents of the configuration as a string.
     * @throws MojoExecutionException
     * @throws IOException
     */
    protected String getConfigurationContents() throws MojoExecutionException, IOException
    {
        String contents = null;
        if (StringUtils.isNotBlank(this.configurationUri))
        {
            final URL configuration = ResourceUtils.toURL(this.configurationUri);
            if (configuration == null)
            {
                throw new MojoExecutionException("No configuration could be loaded from --> '" + this.configurationUri + '\'');
            }
            contents = this.replaceProperties(ResourceUtils.getContents(configuration));
        }
        return contents;
    }

    /**
     * The begin token for interpolation (we need it different
     * than what Maven uses so that Maven variables aren't replaced).
     */
    private static final String BEGIN_TOKEN = "$${";

    /**
     * The end token for interpolation.
     */
    private static final String END_TOKEN = "}";

    /**
     * Replaces all properties having the style
     * <code>${some.property}</code> with the value
     * of the specified property if there is one.
     *
     * @param properties the properties used to perform the replacement.
     * @param string the fileContents to perform replacement on.
     */
    @SuppressWarnings("resource")
    private String replaceProperties(final Properties properties, final String string) throws IOException
    {
        String replacement = null;
        final StringReader stringReader = new StringReader(string);
        InterpolationFilterReader reader = new InterpolationFilterReader(stringReader, properties, "${", "}");
        reader.reset();
        try
        {
            reader = new InterpolationFilterReader(
                    reader,
                    new BeanProperties(this.project),
                    BEGIN_TOKEN,
                    END_TOKEN);
            reader = new InterpolationFilterReader(
                    reader,
                    new BeanProperties(this.project),
                    BEGIN_TOKEN,
                    END_TOKEN);
            replacement = ResourceUtils.getContents(reader);
        }
        finally
        {
            reader.close();
        }
        return replacement;
    }

}