/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */
package org.apache.easyant.core;

import org.apache.commons.cli.*;
import org.apache.easyant.core.ant.ProjectUtils;
import org.apache.easyant.core.configuration.EasyAntConfiguration;
import org.apache.easyant.core.configuration.EasyantConfigurationFactory;
import org.apache.easyant.man.*;
import org.apache.tools.ant.*;
import org.apache.tools.ant.launch.AntMain;
import org.apache.tools.ant.util.FileUtils;

import java.io.*;
import java.util.*;

/**
 * Command line entry point into EasyAnt. This class is entered via the canonical `public static void main` entry point
 * and reads the command line arguments. It then assembles and executes an Ant project.
 * <p>
 * If you integrating EasyAnt into some other tool, this is not the class to use as an entry point. Instead you should
 * have a look at {@link EasyAntEngine}.
 * </p>
 */
public class EasyAntMain implements AntMain {
    /**
     * A Set of args are are handled by the launcher and should not be seen by Main.
     */
    private static final Set<String> LAUNCH_COMMANDS = new HashSet<String>();
    private boolean isLogFileUsed;

    static {
        LAUNCH_COMMANDS.add("-lib");
        LAUNCH_COMMANDS.add("-cp");
        LAUNCH_COMMANDS.add("-noclasspath");
        LAUNCH_COMMANDS.add("--noclasspath");
        LAUNCH_COMMANDS.add("-nouserlib");
        LAUNCH_COMMANDS.add("-main");
    }

    private EasyAntConfiguration easyAntConfiguration;
    private boolean projectHelp;

    private Options options = new Options();

    /**
     * Whether or not this instance has successfully been constructed and is ready to run.
     */
    private boolean readyToRun;
    private List<String> propertyFiles = new ArrayList<String>(1);

    /**
     * Prints the message of the Throwable if it (the message) is not <code>null</code>.
     *
     * @param t Throwable to print the message of. Must not be <code>null</code>.
     */
    private static void printMessage(Throwable t) {
        String message = t.getMessage();
        if (message != null) {
            System.err.println(message);
        }
    }

    /**
     * Creates a new instance of this class using the arguments specified, gives it any extra user properties which have
     * been specified, and then runs the build using the classloader provided.
     *
     * @param args                     Command line arguments. Must not be <code>null</code>.
     * @param additionalUserProperties Any extra properties to use in this build. May be <code>null</code>, which is the equivalent to
     *                                 passing in an empty set of properties.
     * @param coreLoader               Classloader used for core classes. May be <code>null</code> in which case the system classloader is
     *                                 used.
     */
    public static void start(String[] args, Properties additionalUserProperties, ClassLoader coreLoader) {
        EasyAntMain m = new EasyAntMain();
        m.startAnt(args, additionalUserProperties, coreLoader);
    }

    /**
     * Start Ant
     *
     * @param args                     command line args
     * @param additionalUserProperties properties to set beyond those that may be specified on the args list
     * @param coreLoader               - not used
     * @since Ant 1.6
     */
    public void startAnt(String[] args, Properties additionalUserProperties, ClassLoader coreLoader) {
        easyAntConfiguration.setCoreLoader(coreLoader);
        configureOptions();
        CommandLineParser parser = new GnuParser();
        CommandLine line;
        try {
            line = parser.parse(options, args);
            processArgs(line);
        } catch (ParseException exc) {
            if (easyAntConfiguration.getMsgOutputLevel() >= Project.MSG_VERBOSE) {
                exc.printStackTrace();
            }
            handleLogfile();
            printMessage(exc);
            exit(1);
            return;
        }

        if (additionalUserProperties != null) {
            Enumeration<?> properties = additionalUserProperties.propertyNames();
            while (properties.hasMoreElements()) {
                String key = (String) properties.nextElement();
                String property = additionalUserProperties.getProperty(key);
                easyAntConfiguration.getDefinedProps().put(key, property);
            }
        }

        // expect the worst
        int exitCode = 1;
        try {
            try {
                runBuild(line);
                exitCode = 0;
            } catch (ExitStatusException ese) {
                exitCode = ese.getStatus();
                if (exitCode != 0) {
                    throw ese;
                }
            }
        } catch (BuildException be) {
            // do nothing they have been already logged by our logger
        } catch (Throwable exc) {
            exc.printStackTrace();
            printMessage(exc);
        } finally {
            handleLogfile();
        }
        exit(exitCode);
    }

    /**
     * This operation is expected to call {@link System#exit(int)}, which is what the base version does. However, it is
     * possible to do something else.
     *
     * @param exitCode code to exit with
     */
    protected void exit(int exitCode) {
        System.exit(exitCode);
    }

    /**
     * Close logfiles, if we have been writing to them.
     *
     * @since Ant 1.6
     */
    private void handleLogfile() {
        if (isLogFileUsed && easyAntConfiguration != null) {
            FileUtils.close(easyAntConfiguration.getOut());
            FileUtils.close(easyAntConfiguration.getErr());
        }
    }

    /**
     * Command line entry point. This method kicks off the building of a project object and executes a build using
     * either a given target or the default target.
     *
     * @param args Command line arguments. Must not be <code>null</code>.
     */
    public static void main(String[] args) {
        start(args, null, null);
    }

    /**
     * Constructor used when creating Main for later arg processing and startup
     */
    public EasyAntMain() {
        easyAntConfiguration = EasyantConfigurationFactory.getInstance().createDefaultConfiguration();
    }

    /**
     * Process command line arguments. When ant is started from Launcher, launcher-only arguments do not get passed
     * through to this routine.
     *
     * @since Ant 1.6
     */
    private void processArgs(CommandLine line) {
        String searchForThis;
        PrintStream logTo = null;

        if (line.hasOption("help")) {
            printUsage();
            return;
        }
        if (easyAntConfiguration.getMsgOutputLevel() >= Project.MSG_VERBOSE || line.hasOption("version")) {
            printVersion();
            if (line.hasOption("version")) {
                return;
            }
        }
        if (line.hasOption("showMemoryDetails")) {
            easyAntConfiguration.setShowMemoryDetails(true);
        }
        if (line.hasOption("diagnostics")) {
            Diagnostics.doReport(System.out, easyAntConfiguration.getMsgOutputLevel());
            return;
        }
        if (line.hasOption("quiet")) {
            easyAntConfiguration.setMsgOutputLevel(Project.MSG_WARN);
        }
        if (line.hasOption("verbose")) {
            easyAntConfiguration.setMsgOutputLevel(Project.MSG_VERBOSE);
        }
        if (line.hasOption("debug")) {
            easyAntConfiguration.setMsgOutputLevel(Project.MSG_DEBUG);
        }
        if (line.hasOption("noinput")) {
            easyAntConfiguration.setAllowInput(false);
        }
        if (line.hasOption("logfile")) {
            try {
                File logFile = new File(line.getOptionValue("logfile"));
                logTo = new PrintStream(new FileOutputStream(logFile));
                isLogFileUsed = true;
            } catch (IOException ioe) {
                String msg = "Cannot write on the specified log file. "
                        + "Make sure the path exists and you have write " + "permissions.";
                throw new BuildException(msg);
            } catch (ArrayIndexOutOfBoundsException aioobe) {
                String msg = "You must specify a log file when " + "using the -log argument";
                throw new BuildException(msg);
            }
        }
        if (line.hasOption("buildmodule")) {
            File buildModule = new File(line.getOptionValue("buildmodule").replace('/', File.separatorChar));
            easyAntConfiguration.setBuildModule(buildModule);
        }
        if (line.hasOption("buildfile")) {
            File buildFile = new File(line.getOptionValue("buildfile").replace('/', File.separatorChar));
            easyAntConfiguration.setBuildFile(buildFile);
        }
        if (line.hasOption("buildconf")) {
            easyAntConfiguration.getActiveBuildConfigurations().add(line.getOptionValue("buildconf"));
        }

        File easyantConfFile = null;

        if (line.hasOption("configfile")) {
            easyantConfFile = new File(line.getOptionValue("configfile").replace('/', File.separatorChar));
        } else {
            // if no command line switch is specified check the default location

            File easyantHome = new File(System.getProperty(EasyAntMagicNames.EASYANT_HOME).replace('/',
                    File.separatorChar));
            File defaultGlobalEasyantConfFile = new File(easyantHome, EasyAntConstants.DEFAULT_GLOBAL_EASYANT_CONF_FILE);

            if (defaultGlobalEasyantConfFile.exists()) {
                easyantConfFile = defaultGlobalEasyantConfFile;
            }
        }

        if (easyantConfFile != null) {
            try {
                easyAntConfiguration = EasyantConfigurationFactory.getInstance().createConfigurationFromFile(
                        easyAntConfiguration, easyantConfFile.toURI().toURL());
            } catch (Exception e) {
                throw new BuildException(e);
            }
        }

        if (line.hasOption("listener")) {
            easyAntConfiguration.getListeners().add(line.getOptionValue("listener"));
        }
        if (line.hasOption("D")) {
            easyAntConfiguration.getDefinedProps().putAll(line.getOptionProperties("D"));
        }
        if (line.hasOption("logger")) {
            if (easyAntConfiguration.getLoggerClassname() != null) {
                throw new BuildException("Only one logger class may be specified.");
            }
            easyAntConfiguration.setLoggerClassname(line.getOptionValue("logger"));
        }
        if (line.hasOption("inputhandler")) {
            if (easyAntConfiguration.getInputHandlerClassname() != null) {
                throw new BuildException("Only one input handler class may " + "be specified.");
            }
            easyAntConfiguration.setInputHandlerClassname(line.getOptionValue("inputhandler"));
        }
        if (line.hasOption("emacs")) {
            easyAntConfiguration.setEmacsMode(true);
        }
        if (line.hasOption("projecthelp")) {
            // set the flag to display the targets and quit
            projectHelp = true;
        }
        if (line.hasOption("find")) {
            // eat up next arg if present, default to module.ivy
            if (line.getOptionValues("find").length > 0) {
                searchForThis = line.getOptionValue("find");

            } else {
                searchForThis = EasyAntConstants.DEFAULT_BUILD_MODULE;
            }
            easyAntConfiguration.setBuildModule(new File(searchForThis));
            easyAntConfiguration.setBuildModuleLookupEnabled(true);
        }
        if (line.hasOption("propertyfile")) {
            propertyFiles.add(line.getOptionValue("propertyfile"));
        }
        if (line.hasOption("keep-going")) {
            easyAntConfiguration.setKeepGoingMode(true);
        }
        if (line.hasOption("offline")) {
            easyAntConfiguration.setOffline(true);
        }
        if (line.hasOption("nice")) {
            easyAntConfiguration.setThreadPriority(Integer.decode(line.getOptionValue("nice")));

            if (easyAntConfiguration.getThreadPriority() < Thread.MIN_PRIORITY
                    || easyAntConfiguration.getThreadPriority() > Thread.MAX_PRIORITY) {
                throw new BuildException("Niceness value is out of the range 1-10");
            }
        }
        if (line.hasOption("autoproxy")) {
            easyAntConfiguration.setProxy(true);
        }
        if (!line.getArgList().isEmpty()) {
            for (Object o : line.getArgList()) {
                String target = (String) o;
                easyAntConfiguration.getTargets().add(target);
            }
        }

        // Load the property files specified by -propertyfile
        loadPropertyFiles();

        if (logTo != null) {
            easyAntConfiguration.setOut(logTo);
            easyAntConfiguration.setErr(logTo);
            System.setOut(easyAntConfiguration.getOut());
            System.setErr(easyAntConfiguration.getErr());
        }
        readyToRun = true;
    }

    // --------------------------------------------------------
    // other methods
    // --------------------------------------------------------

    /**
     * Load the property files specified by -propertyfile
     */
    private void loadPropertyFiles() {
        for (String filename : propertyFiles) {
            Properties props = new Properties();
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(filename);
                props.load(fis);
            } catch (IOException e) {
                System.out.println("Could not load property file " + filename + ": " + e.getMessage());
            } finally {
                FileUtils.close(fis);
            }

            // ensure that -D properties take precedence
            Enumeration<?> properties = props.propertyNames();
            while (properties.hasMoreElements()) {
                String name = (String) properties.nextElement();
                if (easyAntConfiguration.getDefinedProps().getProperty(name) == null) {
                    easyAntConfiguration.getDefinedProps().put(name, props.getProperty(name));
                }
            }
        }
    }

    /**
     * Executes the build. If the constructor for this instance failed (e.g. returned after issuing a warning), this
     * method returns immediately.
     *
     * @throws BuildException if the build fails
     */
    private void runBuild(CommandLine line) throws BuildException {
        if (!readyToRun) {
            return;
        }
        if (projectHelp) {
            displayProjectHelp();
        } else {
            EasyAntEngine eaEngine = new EasyAntEngine(easyAntConfiguration);
            Project project = new Project();
            eaEngine.configureEasyAnt(project);
            eaEngine.loadProject(project);
            // handle other easyant option (-listTargets,-describe,etc..)
            for (int i = 0; i < line.getOptions().length; i++) {
                if (line.getOptions()[i] instanceof EasyantOption) {
                    EasyantOption eaoption = (EasyantOption) line.getOptions()[i];
                    eaoption.setProject(project);
                    eaoption.execute();
                    if (eaoption.isStopBuild()) {
                        return;
                    }
                }
            }
            eaEngine.doBuild(project);
        }

    }

    /**
     * Prints the description of a project (if there is one) to <code>System.out</code>.
     *
     * @param project The project to display a description of. Must not be <code>null</code>.
     */
    protected void printDescription(Project project) {
        if (project.getDescription() != null) {
            project.log(project.getDescription());
        }
    }

    /**
     * Searches for the correct place to insert a name into a list so as to keep the list sorted alphabetically.
     *
     * @param names The current list of names. Must not be <code>null</code>.
     * @param name  The name to find a place for. Must not be <code>null</code>.
     * @return the correct place in the list for the given name
     */
    private static int findTargetPosition(List<String> names, String name) {
        int res = names.size();
        for (int i = 0; i < names.size() && res == names.size(); i++) {
            if (name.compareTo(names.get(i)) < 0) {
                res = i;
            }
        }
        return res;
    }

    /**
     * Writes a formatted list of target names to <code>System.out</code> with an optional description.
     *
     * @param project      the project instance.
     * @param names        The names to be printed. Must not be <code>null</code>.
     * @param descriptions The associated target descriptions. May be <code>null</code>, in which case no descriptions are
     *                     displayed. If non- <code>null</code>, this should have as many elements as <code>names</code>.
     * @param heading      The heading to display. Should not be <code>null</code>.
     * @param maxlen       The maximum length of the names of the targets. If descriptions are given, they are padded to this
     *                     position so they line up (so long as the names really <i>are</i> shorter than this).
     */
    private static void printTargets(Project project, List<String> names, List<String> descriptions, String heading,
                                     int maxlen) {
        if (!names.isEmpty()) {
            // now, start printing the targets and their descriptions
            String lSep = System.getProperty("line.separator");
            String spaces = String.format("%" + maxlen + "s", ' ');
            StringBuilder msg = new StringBuilder();
            msg.append(lSep).append(heading).append(lSep).append(lSep);
            for (int i = 0; i < names.size(); i++) {
                msg.append(" ");
                msg.append(names.get(i));
                if (descriptions != null) {
                    msg.append(spaces.substring(0, maxlen - (names.get(i)).length() + 2));
                    msg.append(descriptions.get(i));
                }
                msg.append(lSep);
            }
            project.log(msg.toString(), Project.MSG_WARN);
        }
    }

    /**
     * Prints a list of all targets in the specified project to <code>System.out</code>, optionally including
     * subtargets.
     *
     * @param project         The project to display a description of. Must not be <code>null</code>.
     * @param printSubTargets Whether or not subtarget names should also be printed.
     */
    protected static void printTargets(Project project, boolean printSubTargets) {
        // find the target with the longest name
        int maxLength = 0;
        Map<String, Target> ptargets = ProjectUtils.removeDuplicateTargets(project.getTargets());
        String targetName;
        String targetDescription;
        // split the targets in top-level and sub-targets depending
        // on the presence of a description
        List<String> topNames = new ArrayList<String>();
        List<String> topDescriptions = new ArrayList<String>();
        List<String> subNames = new ArrayList<String>();

        List<String> highLevelTargets = new ArrayList<String>();
        List<String> highLevelTargetsDescriptions = new ArrayList<String>();
        for (Target currentTarget : ptargets.values()) {
            targetName = currentTarget.getName();
            if (targetName.equals("")) {
                continue;
            }
            targetDescription = currentTarget.getDescription();
            // maintain a sorted list of targets
            if (currentTarget instanceof ExtensionPoint && !currentTarget.getName().contains(":")) {
                int pos = findTargetPosition(highLevelTargets, targetName);
                highLevelTargets.add(pos, targetName);
                highLevelTargetsDescriptions.add(pos, targetDescription);
            } else if (targetDescription != null) {
                int pos = findTargetPosition(topNames, targetName);
                topNames.add(pos, targetName);
                topDescriptions.add(pos, targetDescription);
            } else {
                int pos = findTargetPosition(subNames, targetName);
                subNames.add(pos, targetName);
            }
            if (targetName.length() > maxLength) {
                maxLength = targetName.length();
            }

        }

        printTargets(project, highLevelTargets, highLevelTargetsDescriptions, "High level targets:", maxLength);
        printTargets(project, topNames, topDescriptions, "Main targets:", maxLength);
        // if there were no main targets, we list all subtargets
        // as it means nothing has a description
        if (topNames.isEmpty()) {
            printSubTargets = true;
        }
        if (printSubTargets) {
            printTargets(project, subNames, null, "Other targets:", maxLength);
        } else {
            project.log("Run easyant with '-v' or '--verbose' option to have the whole list of available targets / extension points");
        }

        String defaultTarget = project.getDefaultTarget();
        if (defaultTarget != null && !"".equals(defaultTarget)) {
            // shouldn't need to check but...
            project.log("Default target: " + defaultTarget);
        }
    }

    private void displayProjectHelp() {
        final Project project = new Project();
        Throwable error = null;

        try {

            EasyAntEngine.configureAndLoadProject(project, easyAntConfiguration);
            printDescription(project);
            printTargets(project, easyAntConfiguration.getMsgOutputLevel() > Project.MSG_INFO);

        } catch (RuntimeException exc) {
            error = exc;
            throw exc;
        } finally {
            if (error != null) {
                project.log(error.toString(), Project.MSG_ERR);
            }
        }
    }

    /**
     * Configure command line options
     */
    @SuppressWarnings("static-access")
    public void configureOptions() {
        options.addOption("h", "help", false, "print this message");

        options.addOption("p", "projecthelp", false, "print project help information");
        options.addOption("version", false, "print the version information and exit");
        options.addOption("diagnostics", false,
                "print information that might be helpful to diagnose or report problems");
        options.addOption("showMemoryDetails", false, "print memory details (used/free/total)");
        options.addOption("q", "quiet", false, "be extra quiet");
        options.addOption("v", "verbose", false, "be extra verbose");
        options.addOption("d", "debug", false, "print debugging information");
        options.addOption("e", "emacs", false, "produce logging information without adornments");
        Option lib = OptionBuilder.withArgName("path").hasArg()
                .withDescription("specifies a path to search for jars and classes").create("lib");
        options.addOption(lib);
        Option logfile = OptionBuilder.withArgName("file").hasArg().withDescription("use given file for log")
                .create("logfile");
        options.addOption(logfile);
        Option logger = OptionBuilder.withArgName("classname").hasArg()
                .withDescription("the class which it to perform " + "logging").create("logger");
        options.addOption(logger);
        Option listener = OptionBuilder.withArgName("classname").hasArg()
                .withDescription("add an instance of class as " + "a project listener").create("listener");
        options.addOption(listener);
        Option buildfile = OptionBuilder.withArgName("file").hasArg().withDescription("use given buildfile")
                .create("buildfile");
        options.addOption(buildfile);
        Option find = OptionBuilder.withArgName("file").hasOptionalArg()
                .withDescription("search for buildfile towards the " + "root of the filesystem and use it")
                .withLongOpt("find").create("s");
        options.addOption(find);
        options.addOption("noinput", false, "do not allow interactive input");
        Option buildmodule = OptionBuilder.withArgName("file").hasArg().withDescription("use given buildmodule")
                .withLongOpt("buildmodule").create("f");
        options.addOption(buildmodule);

        Option buildconf = OptionBuilder.withArgName("confs").hasArg()
                .withDescription("specify build configurations (profiles)").withLongOpt("buildconf").create("C");
        options.addOption(buildconf);
        Option configFile = OptionBuilder.withArgName("file").hasArg()
                .withDescription("use given easyant configuration").create("configfile");
        options.addOption(configFile);
        Option property = OptionBuilder.withArgName("property=value").hasArgs(2).withValueSeparator()
                .withDescription("use value for given property").create("D");
        options.addOption(property);
        options.addOption("k", "keep-going", false, "execute all targets that do not depend on failed target(s)");
        Option propertiesfile = OptionBuilder.withArgName("file").hasArg()
                .withDescription("load all properties from file with -D properties taking precedence")
                .create("propertyfile");
        options.addOption(propertiesfile);
        Option inputhandler = OptionBuilder.withArgName("classname").hasArg()
                .withDescription("the class which will handle input requests").create("inputhandler");
        options.addOption(inputhandler);
        Option nice = OptionBuilder.withArgName("number").hasArg()
                .withDescription("A niceness value for the main thread: 1 (lowest) to 10 (highest); 5 is the default")
                .create("nice");
        options.addOption(nice);
        options.addOption("nouserlib", false, "Run ant without using the jar files from ${user.home}/.ant/lib");
        options.addOption("noclasspath", false, "Run ant without using CLASSPATH");
        options.addOption("autoproxy", false, "Java1.5+: use the OS proxy settings");
        Option main = OptionBuilder.withArgName("classname").hasArg()
                .withDescription("override EasyAnt's normal entry point").create("main");
        options.addOption(main);
        options.addOption("o", "offline", false, "turns EasyAnt in offline mode");
        options.addOption(new Describe());
        options.addOption(new ListExtensionPoints());
        options.addOption(new ListTargets());
        options.addOption(new ListProps());
        options.addOption(new ListParameters());
        options.addOption(new ListPlugins());
    }

    /**
     * Prints the usage information for this class to <code>System.out</code>.
     */
    private void printUsage() {

        HelpFormatter help = new HelpFormatter();
        help.printHelp("easyant [options] [target [target2 [target3] ...]]", options);

    }

    /**
     * Prints the EasyAnt version information to <code>System.out</code>.
     *
     * @throws BuildException if the version information is unavailable
     */
    private static void printVersion() throws BuildException {
        System.out.println(EasyAntEngine.getEasyAntVersion());
        System.out.println(getAntVersion());
    }

    /**
     * Cache of the Ant version information when it has been loaded.
     */
    private static String antVersion = null;

    /**
     * Returns the Ant version information, if available. Once the information has been loaded once, it's cached and
     * returned from the cache on future calls.
     *
     * @return the Ant version information as a String (always non- <code>null</code>)
     * @throws BuildException if the version information is unavailable
     */
    public static synchronized String getAntVersion() throws BuildException {
        if (antVersion == null) {
            InputStream in = null;
            try {
                Properties props = new Properties();
                in = Main.class.getResourceAsStream("/org/apache/tools/ant/version.txt");
                if (in == null) {
                    throw new BuildException("Could not load the version information.");
                }
                props.load(in);

                antVersion = "Apache Ant version " + props.getProperty("VERSION") + " compiled on " + props.getProperty("DATE");
            } catch (IOException ioe) {
                throw new BuildException("Could not load the version information", ioe);
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        // do nothing
                    }
                }
            }
        }
        return antVersion;
    }

}