/*
 * 
 * Copyright 2002-2004 The Ant-Contrib project
 *
 *  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.cpptasks;
import java.io.File;
import java.lang.reflect.Method;
import java.util.Vector;
import net.sf.antcontrib.cpptasks.compiler.LinkType;
import net.sf.antcontrib.cpptasks.compiler.Processor;
import net.sf.antcontrib.cpptasks.compiler.ProcessorConfiguration;
import net.sf.antcontrib.cpptasks.types.CommandLineArgument;
import net.sf.antcontrib.cpptasks.types.ConditionalFileSet;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DirectoryScanner;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.types.DataType;
import org.apache.tools.ant.types.Environment;
import org.apache.tools.ant.types.Reference;
/**
 * An abstract compiler/linker definition.
 * 
 * @author Curt Arnold
 */
public abstract class ProcessorDef extends DataType {
    /**
     * Returns the equivalent Boolean object for the specified value
     * 
     * Equivalent to Boolean.valueOf in JDK 1.4
     * 
     * @param val
     *            boolean value
     * @return Boolean.TRUE or Boolean.FALSE
     */
    protected static Boolean booleanValueOf(boolean val) {
        if (val) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }
    /**
     * if true, targets will be built for debugging
     */
    private Boolean debug;
    private Environment env = null;
    /**
     * Reference for "extends" processor definition
     */
    private Reference extendsRef = null;
    /**
     * Name of property that must be present or definition will be ignored. May
     * be null.
     */
    private String ifProp;
    /**
     * if true, processor definition inherits values from containing cc
     * element
     */
    private boolean inherit;
    private Boolean libtool = null;
    protected boolean newEnvironment = false;
    /**
     * Processor.
     */
    private Processor processor;
    /**
     * Collection of <compilerarg>or <linkerarg>contained by definition
     */
    private final Vector processorArgs = new Vector();
    /**
     * Collection of <compilerparam>or <linkerparam>contained by definition
     */
    private final Vector processorParams = new Vector();
    /**
     * if true, all targets will be unconditionally rebuilt
     */
    private Boolean rebuild;
    /**
     * Collection of <fileset>contained by definition
     */
    private final Vector srcSets = new Vector();
    /**
     * Name of property that if present will cause definition to be ignored.
     * May be null.
     */
    private String unlessProp;
    /**
     * Constructor
     *  
     */
    protected ProcessorDef() throws NullPointerException {
        inherit = true;
    }
    /**
     * Adds a <compilerarg>or <linkerarg>
     * 
     * @param arg
     *            command line argument, must not be null
     * @throws NullPointerException
     *             if arg is null
     * @throws BuildException
     *             if this definition is a reference
     */
    protected void addConfiguredProcessorArg(CommandLineArgument arg)
            throws NullPointerException, BuildException {
        if (arg == null) {
            throw new NullPointerException("arg");
        }
        if (isReference()) {
            throw noChildrenAllowed();
        }
        processorArgs.addElement(arg);
    }
    /**
     * Adds a <compilerarg>or <linkerarg>
     * 
     * @param arg
     *            command line argument, must not be null
     * @throws NullPointerException
     *             if arg is null
     * @throws BuildException
     *             if this definition is a reference
     */
    protected void addConfiguredProcessorParam(ProcessorParam param)
            throws NullPointerException, BuildException {
        if (param == null) {
            throw new NullPointerException("param");
        }
        if (isReference()) {
            throw noChildrenAllowed();
        }
        processorParams.addElement(param);
    }
    /**
     * Add an environment variable to the launched process.
     */
    public void addEnv(Environment.Variable var) {
        if (env == null) {
            env = new Environment();
        }
        env.addVariable(var);
    }
    /**
     * Adds a source file set.
     * 
     * Files in these set will be processed by this configuration and will not
     * participate in the auction.
     * 
     * @param srcSet
     *            Fileset identifying files that should be processed by this
     *            processor
     * @throws BuildException
     *             if processor definition is a reference
     */
    public void addFileset(ConditionalFileSet srcSet) throws BuildException {
        if (isReference()) {
            throw noChildrenAllowed();
        }
        srcSet.setProject(getProject());
        srcSets.addElement(srcSet);
    }
    /**
     * Creates a configuration
     * 
     * @param baseDef
     *            reference to def from containing cc element, may be null
     * @return configuration
     *  
     */
    public ProcessorConfiguration createConfiguration(CCTask task,
            LinkType linkType, ProcessorDef baseDef, 
			TargetDef targetPlatform, VersionInfo versionInfo) {
        if (isReference()) {
            return ((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).createConfiguration(task, linkType,
                    baseDef, targetPlatform, versionInfo);
        }
        ProcessorDef[] defaultProviders = getDefaultProviders(baseDef);
        Processor proc = getProcessor(linkType);
        return proc.createConfiguration(task, linkType, defaultProviders, this, targetPlatform, versionInfo);
    }
    /**
     * Prepares list of processor arguments ( compilerarg, linkerarg ) that
     * are active for the current project settings.
     * 
     * @return active compiler arguments
     */
    public CommandLineArgument[] getActiveProcessorArgs() {
    	Project p = getProject();
        if (p == null) {
            throw new java.lang.IllegalStateException("project must be set");
        }
        if (isReference()) {
            return ((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).getActiveProcessorArgs();
        }
        Vector activeArgs = new Vector(processorArgs.size());
        for (int i = 0; i < processorArgs.size(); i++) {
            CommandLineArgument arg = (CommandLineArgument) processorArgs
                    .elementAt(i);
            if (arg.isActive(p)) {
                activeArgs.addElement(arg);
            }
        }
        CommandLineArgument[] array = new CommandLineArgument[activeArgs.size()];
        activeArgs.copyInto(array);
        return array;
    }
    /**
     * Prepares list of processor arguments ( compilerarg, linkerarg) that
     * are active for the current project settings.
     * 
     * @return active compiler arguments
     */
    public ProcessorParam[] getActiveProcessorParams() {
    	Project p = getProject();
        if (p == null) {
            throw new java.lang.IllegalStateException("project must be set");
        }
        if (isReference()) {
            return ((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).getActiveProcessorParams();
        }
        Vector activeParams = new Vector(processorParams.size());
        for (int i = 0; i < processorParams.size(); i++) {
            ProcessorParam param = (ProcessorParam) processorParams
                    .elementAt(i);
            if (param.isActive(p)) {
                activeParams.addElement(param);
            }
        }
        ProcessorParam[] array = new ProcessorParam[activeParams.size()];
        activeParams.copyInto(array);
        return array;
    }
    /**
     * Gets boolean indicating debug build
     * 
     * @param defaultProviders
     *            array of ProcessorDef's in descending priority
     * @param index
     *            index to first element in array that should be considered
     * @return if true, built targets for debugging
     */
    public boolean getDebug(ProcessorDef[] defaultProviders, int index) {
        if (isReference()) {
            return ((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).getDebug(defaultProviders, index);
        }
        if (debug != null) {
            return debug.booleanValue();
        } else {
            if (defaultProviders != null && index < defaultProviders.length) {
                return defaultProviders[index].getDebug(defaultProviders,
                        index + 1);
            }
        }
        return false;
    }
    /**
     * Creates an chain of objects which provide default values in descending
     * order of significance.
     * 
     * @param baseDef
     *            corresponding ProcessorDef from CCTask, will be last element
     *            in array unless inherit = false
     * @return default provider array
     *  
     */
    protected final ProcessorDef[] getDefaultProviders(ProcessorDef baseDef) {
        ProcessorDef extendsDef = getExtends();
        Vector chain = new Vector();
        while (extendsDef != null && !chain.contains(extendsDef)) {
            chain.addElement(extendsDef);
            extendsDef = extendsDef.getExtends();
        }
        if (baseDef != null && getInherit()) {
            chain.addElement(baseDef);
        }
        ProcessorDef[] defaultProviders = new ProcessorDef[chain.size()];
        chain.copyInto(defaultProviders);
        return defaultProviders;
    }
    /**
     * Gets the ProcessorDef specified by the extends attribute
     * 
     * @return Base ProcessorDef, null if extends is not specified
     * @throws BuildException
     *             if reference is not same type object
     */
    public ProcessorDef getExtends() throws BuildException {
        if (extendsRef != null) {
            Object obj = extendsRef.getReferencedObject(getProject());
            if (!getClass().isInstance(obj)) {
                throw new BuildException("Referenced object "
                        + extendsRef.getRefId() + " not correct type, is "
                        + obj.getClass().getName() + " should be "
                        + getClass().getName());
            }
            return (ProcessorDef) obj;
        }
        return null;
    }
    /**
     * Gets the inherit attribute. If the inherit value is true, this processor
     * definition will inherit default values from the containing cc element.
     * 
     * @return if true then properties from the containing <cc>element are
     *         used.
     */
    public final boolean getInherit() {
        return inherit;
    }
    public boolean getLibtool() {
        if (libtool != null) {
            return libtool.booleanValue();
        }
        if (isReference()) {
            return ((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).getLibtool();
        }
        ProcessorDef extendsDef = getExtends();
        if (extendsDef != null) {
            return extendsDef.getLibtool();
        }
        return false;
    }
    /**
     * Obtains the appropriate processor (compiler, linker)
     * 
     * @return processor
     */
    protected Processor getProcessor() {
        if (isReference()) {
            return ((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).getProcessor();
        }
        //
        //   if a processor has not been explicitly set
        //      then may be set by an extended definition
        if (processor == null) {
            ProcessorDef extendsDef = getExtends();
            if (extendsDef != null) {
                return extendsDef.getProcessor();
            }
        }
        return processor;
    }

    /**
     * Obtains the appropriate processor (compiler, linker) based on the 
     * LinkType.
     *
     * @return processor
     */
    protected Processor getProcessor(LinkType linkType) {
      // by default ignore the linkType.
      return getProcessor();
    }
    /**
     * Gets a boolean value indicating whether all targets must be rebuilt
     * regardless of dependency analysis.
     * 
     * @param defaultProviders
     *            array of ProcessorDef's in descending priority
     * @param index
     *            index to first element in array that should be considered
     * @return true if all targets should be rebuilt.
     */
    public boolean getRebuild(ProcessorDef[] defaultProviders, int index) {
        if (isReference()) {
            return ((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).getRebuild(defaultProviders, index);
        }
        if (rebuild != null) {
            return rebuild.booleanValue();
        } else {
            if (defaultProviders != null && index < defaultProviders.length) {
                return defaultProviders[index].getRebuild(defaultProviders,
                        index + 1);
            }
        }
        return false;
    }
    /**
     * Returns true if the processor definition contains embedded file set
     * definitions
     * 
     * @return true if processor definition contains embedded filesets
     */
    public boolean hasFileSets() {
        if (isReference()) {
            return ((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).hasFileSets();
        }
        return srcSets.size() > 0;
    }
    /**
     * Determine if this def should be used.
     * 
     * Definition will be active if the "if" variable (if specified) is set and
     * the "unless" variable (if specified) is not set and that all reference
     * or extended definitions are active
     * 
     * @return true if processor is active
     * @throws IllegalStateException
     *             if not properly initialized
     * @throws BuildException
     *             if "if" or "unless" variable contains suspicious values
     *             "false" or "no" which indicates possible confusion
     */
    public boolean isActive() throws BuildException, IllegalStateException {
        Project project = getProject();
        if (!CUtil.isActive(project, ifProp, unlessProp)) {
            return false;
        }
        if (isReference()) {
            if (!((ProcessorDef) getCheckedRef(ProcessorDef.class,
                    "ProcessorDef")).isActive()) {
                return false;
            }
        }
        //
        //  walk through any extended definitions
        //
        ProcessorDef[] defaultProviders = getDefaultProviders(null);
        for (int i = 0; i < defaultProviders.length; i++) {
            if (!defaultProviders[i].isActive()) {
                return false;
            }
        }
        return true;
    }
    /**
     * Sets the class name for the adapter. Use the "name" attribute when the
     * tool is supported.
     * 
     * @param className
     *            full class name
     *  
     */
    public void setClassname(String className) throws BuildException {
        Object proc = null;
        try {
            Class implClass = ProcessorDef.class.getClassLoader().loadClass(
                    className);
            try {
                Method getInstance = implClass.getMethod("getInstance",
                        new Class[0]);
                proc = getInstance.invoke(null, new Object[0]);
            } catch (Exception ex) {
                proc = implClass.newInstance();
            }
        } catch (Exception ex) {
            throw new BuildException(ex);
        }
        setProcessor((Processor) proc);
    }
    /**
     * If set true, all targets will be built for debugging.
     * 
     * @param debug
     *            true if targets should be built for debugging
     * @throws BuildException
     *             if processor definition is a reference
     */
    public void setDebug(boolean debug) throws BuildException {
        if (isReference()) {
            throw tooManyAttributes();
        }
        this.debug = booleanValueOf(debug);
    }
    /**
     * Sets a description of the current data type.
     */
    public void setDescription(String desc) {
        super.setDescription(desc);
    }
    /**
     * Specifies that this element extends the element with id attribute with a
     * matching value. The configuration will be constructed from the settings
     * of this element, element referenced by extends, and the containing cc
     * element.
     * 
     * @param extendsRef
     *            Reference to the extended processor definition.
     * @throws BuildException
     *             if this processor definition is a reference
     */
    public void setExtends(Reference extendsRef) throws BuildException {
        if (isReference()) {
            throw tooManyAttributes();
        }
        this.extendsRef = extendsRef;
    }
    /**
     * Sets an id that can be used to reference this element.
     * 
     * @param id
     *            id
     */
    public void setId(String id) {
        //
        //  this is actually accomplished by a different
        //     mechanism, but we can document it
        //
    }
    /**
     * Sets the property name for the 'if' condition.
     * 
     * The configuration will be ignored unless the property is defined.
     * 
     * The value of the property is insignificant, but values that would imply
     * misinterpretation ("false", "no") will throw an exception when
     * evaluated.
     * 
     * @param propName
     *            name of property
     */
    public void setIf(String propName) {
        ifProp = propName;
    }
    /**
     * If inherit has the default value of true, defines, includes and other
     * settings from the containing cc element will be inherited.
     * 
     * @param inherit
     *            new value
     * @throws BuildException
     *             if processor definition is a reference
     */
    public void setInherit(boolean inherit) throws BuildException {
        if (isReference()) {
            throw super.tooManyAttributes();
        }
        this.inherit = inherit;
    }
    /**
     * Set use of libtool.
     * 
     * If set to true, the "libtool " will be prepended to the command line
     * 
     * @param libtool
     *            If true, use libtool.
     */
    public void setLibtool(boolean libtool) {
        if (isReference()) {
            throw tooManyAttributes();
        }
        this.libtool = booleanValueOf(libtool);
    }
    /**
     * Do not propagate old environment when new environment variables are
     * specified.
     */
    public void setNewenvironment(boolean newenv) {
        newEnvironment = newenv;
    }
    /**
     * Sets the processor
     * 
     * @param processor
     *            processor, may not be null.
     * @throws BuildException
     *             if ProcessorDef is a reference
     * @throws NullPointerException
     *             if processor is null
     */
    protected void setProcessor(Processor processor) throws BuildException,
            NullPointerException {
        if (processor == null) {
            throw new NullPointerException("processor");
        }
        if (isReference()) {
            throw super.tooManyAttributes();
        }
        if (env == null && !newEnvironment) {
            this.processor = processor;
        } else {
            this.processor = processor.changeEnvironment(newEnvironment, env);
        }
    }
    /**
     * If set true, all targets will be unconditionally rebuilt.
     * 
     * @param rebuild
     *            if true, rebuild all targets.
     * @throws BuildException
     *             if processor definition is a reference
     */
    public void setRebuild(boolean rebuild) throws BuildException {
        if (isReference()) {
            throw tooManyAttributes();
        }
        this.rebuild = booleanValueOf(rebuild);
    }
    /**
     * Specifies that this element should behave as if the content of the
     * element with the matching id attribute was inserted at this location. If
     * specified, no other attributes or child content should be specified,
     * other than "if", "unless" and "description".
     * 
     * @param ref
     *            Reference to other element
     *  
     */
    public void setRefid(org.apache.tools.ant.types.Reference ref) {
        super.setRefid(ref);
    }
    /**
     * Set the property name for the 'unless' condition.
     * 
     * If named property is set, the configuration will be ignored.
     * 
     * The value of the property is insignificant, but values that would imply
     * misinterpretation ("false", "no") of the behavior will throw an
     * exception when evaluated.
     * 
     * @param propName
     *            name of property
     */
    public void setUnless(String propName) {
        unlessProp = propName;
    }
    /**
     * This method calls the FileVistor's visit function for every file in the
     * processors definition
     * 
     * @param visitor
     *            object whose visit method is called for every file
     */
    public void visitFiles(FileVisitor visitor) {
    	Project p = getProject();
        if (p == null) {
            throw new java.lang.IllegalStateException(
                    "project must be set before this call");
        }
        if (isReference()) {
            ((ProcessorDef) getCheckedRef(ProcessorDef.class, "ProcessorDef"))
                    .visitFiles(visitor);
        }
        //
        //   if this processor extends another,
        //      visit its files first
        //
        ProcessorDef extendsDef = getExtends();
        if (extendsDef != null) {
            extendsDef.visitFiles(visitor);
        }
        
        for (int i = 0; i < srcSets.size(); i++) {
            ConditionalFileSet srcSet = (ConditionalFileSet) srcSets
                    .elementAt(i);
            if (srcSet.isActive()) {
                // Find matching source files
                DirectoryScanner scanner = srcSet.getDirectoryScanner(p);
                // Check each source file - see if it needs compilation
                String[] fileNames = scanner.getIncludedFiles();
                File parentDir = scanner.getBasedir();
                for (int j = 0; j < fileNames.length; j++) {
                    String currentFile = fileNames[j];
                    visitor.visit(parentDir, currentFile);
                }
            }
        }
    }
}