package org.andromda.maven.plugin.site;

import java.io.File;
import java.io.FilenameFilter;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;

/**
 * Goal that copies the required AndroMDA site files to suitable locations preparing
 * for deployment.
 *
 * @phase site
 * @goal copy-documentation
 * @description Goal to copy required site files prior to site deployment
 * @author vancek
 */
public class CopyDocumentationMojo
    extends AbstractSiteMojo
{
    /**
     * Path to the mapping source directory containing the mappings
     *
     * @parameter expression="${basedir}/../andromda-etc/mappings"
     */
    private File mappingsSourceDirectory;

    /**
     * Path to the mapping destination directory
     *
     * @parameter expression="${project.reporting.outputDirectory}/mappings"
     */
    private File mappingsOutputDirectory;

    /**
     * Path to the car-rental-system model
     *
     * @parameter expression="${basedir}/../samples/car-rental-system/mda/src/main/uml/CarRentalSystem.xml.zip"
     */
    private File carRentalSystemSourcePath;

    /**
     * Path to the destination directory to copy the car-rental-system model
     *
     * @parameter expression="${project.reporting.outputDirectory}"
     */
    private File carRentalSystemOutputDirectory;

    /**
     * Path to the animal-quiz model
     *
     * @parameter expression="${basedir}/../samples/animal-quiz/mda/src/main/uml/AnimalQuiz.xml.zip"
     */
    private File animalQuizSourcePath;

    /**
     * Path to the destination directory to copy the animal-quiz model
     *
     * @parameter expression="${project.reporting.outputDirectory}"
     */
    private File animalQuizOutputDirectory;

    /**
     * The directory containing the documentation site reporting artifacts
     *
     * @parameter expression="${project.reporting.outputDirectory}"
     */
    private File documentationSourceDirectory;

    /**
     * The documentation output directory used to copy the generated site reporting artifacts
     *
     * @parameter expression="${project.reporting.outputDirectory}"
     */
    private File documentationOutputDirectory;

    /**
     * The name of the project injected from pom.xml. Not used.
     *
     * @parameter default-value="${project.name}"
     */
    @SuppressWarnings("unused")
    private String projectName;

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

    /**
     * @see org.apache.maven.plugin.Mojo#execute()
     */
    public void execute()
        throws MojoExecutionException, MojoFailureException
    {
        this.getLog().info("-----------------------------------------------------------------------------");
        this.getLog().info("  A n d r o M D A   S i t e   D o c   C o p y");
        this.getLog().info("-----------------------------------------------------------------------------");

        this.copyAnimalQuizModel();
        this.copyCarRentalSystemModel();
        this.copyMappings();
        this.copyDocumentationReportArtifacts();

        this.getLog().info("SITE DOCUMENTATION COPY SUCCESSFUL");
    }

    /**
     * Copy the animal-quiz model for site reference
     *
     * @throws MojoExecutionException
     * @throws MojoFailureException
     */
    private void copyAnimalQuizModel()
        throws MojoExecutionException, MojoFailureException
    {
        try
        {
            if (!this.animalQuizSourcePath.exists())
            {
                throw new MojoExecutionException("The animal-quiz model location is invalid");
            }

            this.copyFile(
                    this.animalQuizSourcePath,
                    new File(
                            this.animalQuizOutputDirectory,
                            this.animalQuizSourcePath.getName()));
        }
        catch (final Throwable throwable)
        {
            if (throwable instanceof MojoExecutionException)
            {
                throw (MojoExecutionException)throwable;
            }
            throw new MojoExecutionException("An error occurred copying the animal-quiz model '" +
                this.project.getArtifactId() + '\'',
                ExceptionUtils.getRootCause(throwable));
        }
    }

    /**
     * Copy the car-rental-system model for site reference
     *
     * @throws MojoExecutionException
     * @throws MojoFailureException
     */
    private void copyCarRentalSystemModel()
        throws MojoExecutionException, MojoFailureException
    {
        try
        {
            if (!this.carRentalSystemSourcePath.exists())
            {
                throw new MojoExecutionException("The car-rental-system model location is invalid");
            }

            this.copyFile(
                    this.carRentalSystemSourcePath,
                    new File(
                            this.carRentalSystemOutputDirectory,
                            this.carRentalSystemSourcePath.getName()));
        }
        catch (final Throwable throwable)
        {
            if (throwable instanceof MojoExecutionException)
            {
                throw (MojoExecutionException)throwable;
            }
            throw new MojoExecutionException("An error occurred copying the car-rental-system model '" +
                this.project.getArtifactId() + '\'',
                ExceptionUtils.getRootCause(throwable));
        }
    }

    /**
     * Copy the mapping files to site documentation location
     *
     * @throws MojoExecutionException
     * @throws MojoFailureException
     */
    private void copyMappings()
        throws MojoExecutionException, MojoFailureException
    {
        try
        {
            if (!this.mappingsSourceDirectory.exists())
            {
                throw new MojoExecutionException("Mapping source location is invalid");
            }

            final File[] files = this.mappingsSourceDirectory.listFiles();
            for (File file : files)
            {
                // Ignore SVN dir/files
                if (!".svn".equalsIgnoreCase(file.getName()))
                {
                    this.copyFile(
                            file,
                            new File(this.mappingsOutputDirectory, file.getName()));
                }
            }
        }
        catch (final Throwable throwable)
        {
            if (throwable instanceof MojoExecutionException)
            {
                throw (MojoExecutionException)throwable;
            }
            throw new MojoExecutionException("An error occurred copying mappings '" +
                this.project.getArtifactId() + '\'',
                ExceptionUtils.getRootCause(throwable));
        }
    }

    /**
     * Copy the documentation reporting artifacts
     *
     * @throws MojoExecutionException
     * @throws MojoFailureException
     */
    private void copyDocumentationReportArtifacts()
        throws MojoExecutionException, MojoFailureException
    {
        try
        {
            if (!this.documentationSourceDirectory.exists())
            {
                throw new MojoExecutionException("Documentation source location is invalid");
            }

            /**
             * Retrieve a directory listing with a filename filter
             */
            FilenameFilter filter = new FilenameFilter()
            {
                final String[] filteredReports =
                {
                        ".svn",
                        "integration.html",
                        "dependencies.html",
                        "dependency-convergence.html",
                        "issue-tracking.html",
                        "mailing-lists.html",
                        "license.html",
                        "project-summary.html",
                        "team-list.html",
                        "source-repository.html"
                };

                public boolean accept(File dir, String name)
                {
                    boolean accept = true;
                    for (String filteredReport : filteredReports)
                    {
                        if (name.equalsIgnoreCase(filteredReport))
                        {
                            accept = false;
                        }
                    }
                    return accept;
                }
            };
            final File[] files = this.documentationSourceDirectory.listFiles(filter);
            for (File file : files)
            {
                this.copyFile(
                        file,
                        new File(
                                this.documentationOutputDirectory,
                                file.getName()));
            }
        }
        catch (final Throwable throwable)
        {
            if (throwable instanceof MojoExecutionException)
            {
                throw (MojoExecutionException)throwable;
            }
            throw new MojoExecutionException("An error occurred copying documentation/reporting artifacts '" +
                this.project.getArtifactId() + '\'',
                ExceptionUtils.getRootCause(throwable));
        }
    }
}