package org.jruby.maven;

import org.apache.maven.plugin.AbstractMojo;

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.DependencyResolutionRequiredException;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
import org.apache.tools.ant.BuildEvent;
import org.apache.tools.ant.BuildListener;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Java;
import org.apache.tools.ant.types.Commandline.Argument;
import org.apache.tools.ant.types.Environment.Variable;
import org.apache.tools.ant.types.Path;
import org.codehaus.plexus.util.StringUtils;

/**
 * Base for all JRuby mojos.
 *
 * @requiresDependencyResolution compile
 */
public abstract class AbstractJRubyMojo extends AbstractMojo {

    protected boolean shouldFork = true;

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

    /**
     * @parameter expression="${project.basedir}"
     * @required
     */
    protected File launchDirectory;

    /**
     * @parameter expression="${jruby.home}"
     */
    protected String jrubyHome;

    /**
     * The amount of memory to use when forking JRuby. Default is "384m".
     *
     * @parameter expression="${jruby.launch.memory}"
     */
     protected String jrubyLaunchMemory = "384m";

    /**
     * @parameter expression="${jruby.launch.jvmArgs}"
     */
    protected String jvmArgs = null;

    /**
     * The project compile classpath.
     *
     * @parameter default-value="${project.compileClasspathElements}"
     * @required
     * @readonly
     */
    private List compileClasspathElements;

    /**
     * The plugin dependencies.
     *
     * @parameter expression="${plugin.artifacts}"
     * @required
     * @readonly
     */
    private List pluginArtifacts;

    protected Java jruby(String[] args) throws MojoExecutionException {
        launchDirectory.mkdirs();
        Project project = null;
        try {
            project = getProject();
        } catch (DependencyResolutionRequiredException e) {
            throw new MojoExecutionException("error resolving dependencies", e);
        }

        Java java = new Java();
        java.setProject(project);
        java.setClassname("org.jruby.Main");
        java.setFailonerror(true);

        Argument arg;

        if (shouldFork) {
            java.setFork(true);
            java.setDir(launchDirectory);

            if (jvmArgs != null) {
                String[] splitArgs = jvmArgs.split("\\s+");
                for (int i = 0; i < splitArgs.length; i++) {
                    arg = java.createJvmarg();
                    arg.setValue(splitArgs[i]);
                    if (splitArgs[i].startsWith("-Xmx")) {
                        jrubyLaunchMemory = null;
                    }
                }
            }

            if (jrubyLaunchMemory != null) {
                arg = java.createJvmarg();
                arg.setValue("-Xmx" + jrubyLaunchMemory);
            }

            Variable classpath = new Variable();

            Path p = new Path(java.getProject());
            p.add((Path) project.getReference("maven.plugin.classpath"));
            p.add((Path) project.getReference("maven.compile.classpath"));
            classpath.setKey("JRUBY_PARENT_CLASSPATH");
            classpath.setValue(p.toString());

            java.addEnv(classpath);
        }

        if (jrubyHome != null) {
            Variable v = new Variable();
            v.setKey("jruby.home");
            v.setValue(jrubyHome);
            java.addSysproperty(v);
        }

        Path p = java.createClasspath();
        p.add((Path) project.getReference("maven.plugin.classpath"));
        p.add((Path) project.getReference("maven.compile.classpath"));
        getLog().debug("java classpath: " + p.toString());

        for (int i = 0; i < args.length; i++) {
            arg = java.createArg();
            arg.setValue(args[i]);
        }

        return java;
    }

    protected void ensureGems(String[] gemNames) throws MojoExecutionException {
        List args = new ArrayList();
        args.add("-S");
        args.add("maybe_install_gems");
        for (int i = 0; i < gemNames.length; i++) {
            args.add(gemNames[i]);
        }

        Java jruby = jruby((String[]) args.toArray(new String[args.size()]));
        jruby.execute();
    }

    protected void ensureGem(String gemName) throws MojoExecutionException {
        ensureGems(new String[] {gemName});
    }

    protected Project getProject() throws DependencyResolutionRequiredException {
        Project project = new Project();
        project.setBaseDir(mavenProject.getBasedir());
        project.addBuildListener(new LogAdapter());
        addReference(project, "maven.compile.classpath", compileClasspathElements);
        addReference(project, "maven.plugin.classpath", pluginArtifacts);
        return project;
    }

    protected void addReference(Project project, String reference, List artifacts) throws DependencyResolutionRequiredException {
        List list = new ArrayList(artifacts.size());

        for (Iterator i = artifacts.iterator(); i.hasNext();) {
            Object elem = i.next();
            String path;
            if (elem instanceof Artifact) {
                Artifact a = (Artifact) elem;
                File file = a.getFile();
                if (file == null) {
                    throw new DependencyResolutionRequiredException(a);
                }
                path = file.getPath();
            } else {
                path = elem.toString();
            }
            list.add(path);
        }

        Path p = new Path(project);
        p.setPath(StringUtils.join(list.iterator(), File.pathSeparator));
        project.addReference(reference, p);
    }

    public class LogAdapter implements BuildListener {
        public void buildStarted(BuildEvent event) {
            log(event);
        }

        public void buildFinished(BuildEvent event) {
            log(event);
        }

        public void targetStarted(BuildEvent event) {
            log(event);
        }

        public void targetFinished(BuildEvent event) {
            log(event);
        }

        public void taskStarted(BuildEvent event) {
            log(event);
        }

        public void taskFinished(BuildEvent event) {
            log(event);
        }

        public void messageLogged(BuildEvent event) {
            log(event);
        }

        private void log(BuildEvent event) {
            int priority = event.getPriority();
            Log log = getLog();
            switch (priority) {
            case Project.MSG_ERR:
                log.error(event.getMessage());
                break;

            case Project.MSG_WARN:
                log.warn(event.getMessage());
                break;

            case Project.MSG_INFO:
                log.info(event.getMessage());
                break;

            case Project.MSG_VERBOSE:
                log.debug(event.getMessage());
                break;

            case Project.MSG_DEBUG:
                log.debug(event.getMessage());
                break;

            default:
                log.info(event.getMessage());
            break;
            }
        }
    }
}
