/*
 * Copyright (c) 2001-2004 Ant-Contrib project.  All rights reserved.
 *
 * Licensed 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 net.sf.antcontrib.logic;

import java.io.File;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Hashtable;
import java.util.Vector;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.taskdefs.Parallel;
import org.apache.tools.ant.taskdefs.Sequential;
import org.apache.tools.ant.taskdefs.condition.Condition;
import org.apache.tools.ant.types.Mapper;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.util.FileNameMapper;
import org.apache.tools.ant.util.FileUtils;

import org.apache.tools.ant.types.EnumeratedAttribute;

/**
* Task to help in calling tasks if generated files are older
* than source files.
* Sets a given property or runs an internal task.
*
* Based on
*  org.apache.org.apache.tools.ant.taskdefs.UpToDate
*
* @author peter reilly
*/

public class OutOfDate extends Task implements Condition {

    /**
     * Enumerated type for collection attribute
     *
     * @see EnumeratedAttribute
     */
    public static class CollectionEnum extends EnumeratedAttribute {
        /** Constants for the enumerations */
        public static final int
            SOURCES = 0, TARGETS = 1, ALLSOURCES = 2, ALLTARGETS = 3;

        /**
         * get the values
         * @return an array of the allowed values for this attribute.
         */
        public String[] getValues() {
            return new String[] {"sources", "targets", "allsources", "alltargets"};
        }
    }

    // attributes and nested elements
    private Task doTask = null;
    private String property;
    private String value                = "true";
    private boolean force               = false;
    private int    verbosity            = Project.MSG_VERBOSE;
    private Vector mappers              = new Vector();
    private Path targetpaths            = null;
    private Path sourcepaths            = null;
    private String outputSources        = null;
    private String outputSourcesPath    = null;
    private String outputTargets        = null;
    private String outputTargetsPath    = null;
    private String allTargets           = null;
    private String allTargetsPath       = null;
    private String separator            = " ";
    private DeleteTargets deleteTargets = null;
    private int    collection     = CollectionEnum.SOURCES;

    // variables
    private Hashtable targetSet = new Hashtable();
    private Hashtable sourceSet = new Hashtable();
    private Hashtable allTargetSet = new Hashtable();
    private Hashtable allSourceSet = new Hashtable();

    /**
     * Set the collection attribute, controls what is
     * returned by the iterator method.
     * <dl>
     * <li>"sources" the sources that are newer than the corresponding targets.</li>
     * <li>"targets" the targets that are older or not present than the corresponding
     *               sources.</li>
     * <li>"allsources" all the sources</li>
     * <li>"alltargets" all the targets</li>
     * </dl>
     * @param collection "sources" the changes
     */
    public void setCollection(CollectionEnum collection) {
        this.collection = collection.getIndex();
    }

    /**
     * Defines the FileNameMapper to use (nested mapper element).
     * @return Mappper to be configured
     */
    public Mapper createMapper() {
        MyMapper mapper = new MyMapper(getProject());
        mappers.addElement(mapper);
        return mapper;
    }

    /**
     * The property to set if any of the target files are outofdate with
     * regard to any of the source files.
     *
     * @param property the name of the property to set if Target is outofdate.
     */
    public void setProperty(String property) {
        this.property = property;
    }

    /**
     * The separator to use to separate the files
     * @param separator separator used in outout properties
     */

    public void setSeparator(String separator) {
        this.separator = separator;
    }

    /**
     * The value to set the named property to the target files
     * are outofdate
     *
     * @param value the value to set the property
     */
    public void setValue(String value) {
        this.value = value;
    }

    /**
     * whether to allways be outofdate
     * @param force true means that outofdate is always set, default
     *              false
     */
    public void setForce(boolean force) {
        this.force = force;
    }

    /**
     * whether to have verbose output
     * @param verbose true means that outofdate outputs debug info
     */
    public void setVerbose(boolean verbose) {
        if (verbose) {
            this.verbosity = Project.MSG_INFO;
        } else {
            this.verbosity = Project.MSG_VERBOSE;
        }
    }

    /**
     * Add to the target files
     *
     * @return a path to be configured
     */
    public Path createTargetfiles() {
        if (targetpaths == null) {
            targetpaths = new Path(getProject());
        }
        return targetpaths;
    }

    /**
     * Add to the source files
     *
     * @return a path to be configured
     */
    public Path createSourcefiles() {
        if (sourcepaths == null) {
            sourcepaths = new Path(getProject());
        }
        return sourcepaths;
    }

    /**
     * A property to contain the output source files
     *
     * @param outputSources the name of the property
     */
    public void setOutputSources(String outputSources) {
        this.outputSources = outputSources;
    }

    /**
     * A property to contain the output target files
     *
     * @param outputTargets the name of the property
     */
    public void setOutputTargets(String outputTargets) {
        this.outputTargets = outputTargets;
    }

    /**
     * A reference to contain the path of target files that
     * are outofdate
     *
     * @param outputTargetsPath the name of the reference
     */
    public void setOutputTargetsPath(String outputTargetsPath) {
        this.outputTargetsPath = outputTargetsPath;
    }

    /**
     * A refernce to contain the path of all the targets
     *
     * @param allTargetsPath the name of the reference
     */
    public void setAllTargetsPath(String allTargetsPath) {
        this.allTargetsPath = allTargetsPath;
    }

    /**
     * A property to contain all the target filenames
     *
     * @param allTargets the name of the property
     */
    public void setAllTargets(String allTargets) {
        this.allTargets = allTargets;
    }

    /**
     * A reference to the path containing all the sources files.
     *
     * @param outputSourcesPath the name of the reference
     */
    public void setOutputSourcesPath(String outputSourcesPath) {
        this.outputSourcesPath = outputSourcesPath;
    }

    /**
     * optional nested delete element
     * @return an element to be configured
     */
    public DeleteTargets createDeleteTargets() {
        deleteTargets = new DeleteTargets();
        return deleteTargets;
    }

    /**
     * Embedded do parallel
     * @param doTask the parallel to embed
     */
    public void addParallel(Parallel doTask) {
        if (this.doTask != null) {
            throw new BuildException(
                "You must not nest more that one <parallel> or <sequential>"
                + " into <outofdate>");
        }
        this.doTask = doTask;
    }

    /**
     * Embedded do sequential.
     * @param doTask the sequential to embed
     */
    public void addSequential(Sequential doTask) {
        if (this.doTask != null) {
            throw new BuildException(
                "You must not nest more that one <parallel> or <sequential>"
                + " into <outofdate>");
        }
        this.doTask = doTask;
    }

    /**
     * Evaluate (all) target and source file(s) to
     * see if the target(s) is/are outoutdate.
     * @return true if any of the targets are outofdate
     */
    public boolean eval() {
        boolean ret = false;
        FileUtils fileUtils = FileUtils.newFileUtils();
        if (sourcepaths == null) {
            throw new BuildException(
                "You must specify a <sourcefiles> element.");
        }

        if (targetpaths == null && mappers.size() == 0) {
            throw new BuildException(
                "You must specify a <targetfiles> or <mapper> element.");
        }

        // Source Paths
        String[] spaths = sourcepaths.list();

        for (int i = 0; i < spaths.length; i++) {
            File sourceFile = new File(spaths[i]);
            if (!sourceFile.exists()) {
                throw new BuildException(sourceFile.getAbsolutePath()
                                         + " not found.");
            }
        }

        // Target Paths

        if (targetpaths != null) {
            String[] paths = targetpaths.list();
            if (paths.length == 0) {
            	ret = true;
            }
            else {
            	for (int i = 0; i < paths.length; ++i) {
            		if (targetNeedsGen(paths[i], spaths)) {
            			ret = true;
            		}
            	}
            }
        }

        // Mapper Paths
        for (Enumeration e = mappers.elements(); e.hasMoreElements();) {
            MyMapper mapper = (MyMapper) e.nextElement();

            File   relativeDir = mapper.getDir();
            File   baseDir = new File(getProject().getProperty("basedir"));
            if (relativeDir == null) {
                relativeDir = baseDir;
            }
            String[] rpaths = new String[spaths.length];
            for (int i = 0; i < spaths.length; ++i) {
                rpaths[i] = fileUtils.removeLeadingPath(relativeDir, new File(spaths[i]));
            }

            FileNameMapper fileNameMapper = mapper.getImplementation();
            for (int i = 0; i < spaths.length; ++i) {
                String[] mapped = fileNameMapper.mapFileName(rpaths[i]);
                if (mapped != null) {
                    for (int j = 0; j < mapped.length; ++j) {
                        if (outOfDate(new File(spaths[i]),
                                      fileUtils.resolveFile(
                                          baseDir, mapped[j]))) {
                            ret = true;
                        }
                    }
                }
            }
        }

        if (allTargets != null) {
            this.getProject().setNewProperty(
                allTargets, setToString(allTargetSet));
        }

        if (allTargetsPath != null) {
            this.getProject().addReference(
                allTargetsPath, setToPath(allTargetSet));
        }

        if (outputSources != null) {
            this.getProject().setNewProperty(
                outputSources, setToString(sourceSet));
        }

        if (outputTargets != null) {
            this.getProject().setNewProperty(
                outputTargets, setToString(targetSet));
        }

        if (outputSourcesPath != null) {
            this.getProject().addReference(
                outputSourcesPath, setToPath(sourceSet));
        }

        if (outputTargetsPath != null) {
            this.getProject().addReference(
                outputTargetsPath, setToPath(targetSet));
        }

        if (force) {
            ret = true;
        }

        if (ret && deleteTargets != null) {
            deleteTargets.execute();
        }

        if (ret) {
            if (property != null) {
                this.getProject().setNewProperty(property, value);
            }
        }

        return ret;
    }

    private boolean targetNeedsGen(String target, String[] spaths) {
        boolean ret = false;
        File targetFile = new File(target);
        for (int i = 0; i < spaths.length; i++) {
            if (outOfDate(new File(spaths[i]), targetFile)) {
                ret = true;
            }
        }
        // Special case : there are no source files, make sure the
        //                targets exist
        if (spaths.length == 0) {
            if (outOfDate(null, targetFile)) {
                ret = true;
            }
        }
        return ret;
    }

    /**
     * Call evalute and return an iterator over the result
     * @return an iterator over the result
     */
    public Iterator iterator() {
        // Perhaps should check the result and return
        // an empty set if it returns false
        eval();

        switch (collection) {
            case CollectionEnum.SOURCES:
                return sourceSet.values().iterator();
            case CollectionEnum.TARGETS:
                return targetSet.values().iterator();
            case CollectionEnum.ALLSOURCES:
                return allSourceSet.values().iterator();
            case CollectionEnum.ALLTARGETS:
                return allTargetSet.values().iterator();
            default:
                return sourceSet.values().iterator();
        }
    }

    /**
     * Sets property to true and/or executes embedded do
     * if any of the target file(s) do not have a more recent timestamp
     * than (each of) the source file(s).
     */
    public void execute() {
        if (!eval()) {
            return;
        }

        if (doTask != null) {
            doTask.perform();
        }

    }


    private boolean outOfDate(File sourceFile, File targetFile) {
        boolean ret  = false;
        if (sourceFile != null) {
            allSourceSet.put(sourceFile, sourceFile);
        }
        allTargetSet.put(targetFile, targetFile);
        if (!targetFile.exists()) {
            ret = true;
        }
        if ((!ret)  && (sourceFile != null)) {
            ret = sourceFile.lastModified() > targetFile.lastModified();
        }
        if (ret) {
            if ((sourceFile != null && sourceSet.get(sourceFile) == null)
                || targetSet.get(targetFile) == null) {
                log("SourceFile " + sourceFile + " outofdate "
                    + "with regard to " + targetFile, verbosity);
            }
            if (sourceFile != null) {
                sourceSet.put(sourceFile, sourceFile);
            }
            targetSet.put(targetFile, targetFile);
        }
        return ret;
    }

    private String setToString(Hashtable set) {
        StringBuffer b = new StringBuffer();
        for (Enumeration e = set.keys(); e.hasMoreElements();) {
            File v = (File) e.nextElement();
            if (b.length() != 0) {
                b.append(separator);
            }
            String s = v.getAbsolutePath();
            // DOTO: The following needs more work!
            // Handle paths contains sep
            if (s.indexOf(separator) != -1) {
                if (s.indexOf("\"") != -1) {
                    s = "'" + s + "'";
                } else {
                    s = "\"" + s + "\"";
                }
            }
            b.append(s);
        }
        return b.toString();
    }

    private Path setToPath(Hashtable set) {
        Path ret = new Path(getProject());
        for (Enumeration e = set.keys(); e.hasMoreElements();) {
            File v = (File) e.nextElement();
            Path.PathElement el = ret.createPathElement();
            el.setLocation(v);
        }
        return ret;
    }

    /**
     * nested delete targets
     */
    public class DeleteTargets {
        private boolean all         = false;
        private boolean quiet       = false;
        private boolean failOnError = false;

        private int     myLogging   = Project.MSG_INFO;

        /**
         * whether to delete all the targets
         * or just those that are newer than the
         * corresponding sources.
         * @param all true to delete all, default false
         */
        public void setAll(boolean all) {
            this.all = all;
        }

        /**
         * @param quiet if true suppress messages on deleting files
         */
        public void setQuiet(boolean quiet) {
            this.quiet = quiet;
            myLogging = quiet ? Project.MSG_VERBOSE : Project.MSG_INFO;
        }

        /**
         * @param failOnError if true halt if there is a failure to delete
         */
        public void setFailOnError(boolean failOnError) {
            this.failOnError = failOnError;
        }

        private void execute() {
            if (myLogging != Project.MSG_INFO) {
                myLogging = verbosity;
            }

            // Quiet overrides failOnError
            if (quiet) {
                failOnError = false;
            }

            Path toBeDeleted = null;
            if (all) {
                toBeDeleted = setToPath(allTargetSet);
            } else {
                toBeDeleted = setToPath(targetSet);
            }

            String[] names = toBeDeleted.list();
            for (int i = 0; i < names.length; ++i) {
                File file = new File(names[i]);
                if (!file.exists()) {
                    continue;
                }
                if (file.isDirectory()) {
                    removeDir(file);
                    continue;
                }
                log("Deleting " + file.getAbsolutePath(), myLogging);
                if (!file.delete()) {
                    String message =
                        "Unable to delete file " + file.getAbsolutePath();
                    if (failOnError) {
                        throw new BuildException(message);
                    } else {
                        log(message,  myLogging);
                    }
                }
            }
        }

        private static final int DELETE_RETRY_SLEEP_MILLIS = 10;
        /**
         * Attempt to fix possible race condition when deleting
         * files on WinXP. If the delete does not work,
         * wait a little and try again.
         */
        private boolean delete(File f) {
            if (!f.delete()) {
                try {
                    Thread.sleep(DELETE_RETRY_SLEEP_MILLIS);
                    return f.delete();
                } catch (InterruptedException ex) {
                    return f.delete();
                }
            }
            return true;
        }

        private void removeDir(File d) {
            String[] list = d.list();
            if (list == null) {
                list = new String[0];
            }
            for (int i = 0; i < list.length; i++) {
                String s = list[i];
                File f = new File(d, s);
                if (f.isDirectory()) {
                    removeDir(f);
                } else {
                    log("Deleting " + f.getAbsolutePath(), myLogging);
                    if (!f.delete()) {
                        String message = "Unable to delete file "
                            + f.getAbsolutePath();
                        if (failOnError) {
                            throw new BuildException(message);
                        } else {
                            log(message, myLogging);
                        }
                    }
                }
            }
            log("Deleting directory " + d.getAbsolutePath(), myLogging);
            if (!delete(d)) {
                String message = "Unable to delete directory "
                    + d.getAbsolutePath();
                if (failOnError) {
                    throw new BuildException(message);
                } else {
                    log(message, myLogging);
                }
            }
        }
    }

    /**
     *  Wrapper for mapper - includes dir
     */
    public static class MyMapper extends Mapper {
        private File dir = null;
        /**
         * Creates a new <code>MyMapper</code> instance.
         *
         * @param project the current project
         */
        public MyMapper(Project project) {
            super(project);
        }

        /**
         * @param dir the directory that the from files are relative to
         */
        public void setDir(File dir) {
            this.dir = dir;
        }

        /**
         * @return the directory that the from files are relative to
         */
        public File getDir() {
            return dir;
        }
    }
}