/*
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 1999, 2000 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowlegement:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowlegement may appear in the software itself,
 *    if and wherever such third-party acknowlegements normally appear.
 *
 * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
 *    Foundation" must not be used to endorse or promote products derived
 *    from this software without prior written permission. For written
 *    permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache"
 *    nor may "Apache" appear in their names without prior written
 *    permission of the Apache Group.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */
package org.apache.ant.engine;


import java.util.*;
import org.apache.ant.AntException;
import org.apache.ant.tasks.Task;

/**
 * The engine that actually invokes each Task. In addition to specifying a Task
 * to execute, it may be desirable to specify the root Task that will define
 * an execution cycle.
 */
public class TaskEngineImpl implements TaskEngine {
    
    /**
     * Analagous to a call stack, but with Tasks.
     */
    protected Stack taskStack       = new Stack();;
    
    /**
     * As the task stack is built, a mirror representation will also be
     * contructed that will hold property values.
     */
    protected Stack propertyStack   = new Stack();
    
    /**
     * Keeps track of AntEngineListeners. We don't have to use Vector because we
     * take care of synchronization on the add, remove, and iteration operations.
     */
    protected ArrayList listenerList = new ArrayList();
    
    private int engineLevel = 0;
    
    /**
     * Constructor is private so it cannot be instantiated. Users of this class
     * will get an instance by using the getTaskEngine() method. This will allow
     * us to have a simple Factory implementation. We may use a Singleton
     * implementation, or a collection pool. The choice is up to us.
     */
    private TaskEngineImpl() {
        super();
    }
    
    /**
     * Return a usable instance of a TaskEngine to the requestor. Nothing
     * sophisticated yet, simple doles out a new instance each time.
     */
    public static TaskEngine getTaskEngine() {
        return new TaskEngineImpl();
    }
    
    /**
     * Walk the list of Tasks backwards until the root is reached. Keep track of
     * the Tasks along the way in a Stack. Return null if the root Task is not a
     * parent of the provided Task.
     */
    protected Stack getTaskStack(Task root, Task task) {
        Stack stack = new Stack();
        while (task != null) {
            stack.push(task);
            if (task == root) {
                return stack;
            }
            task = task.getParent();
        }
        return null;
    }
    
    /**
     * Returns the next Task to be executed from the taskStack. The task is not
     * removed from the Stack.
     */
    public Task getNextExecuteTask() {
        try {
            return (Task)taskStack.peek();
        } catch (EmptyStackException esx) {
            return null;
        }
    }
    
    /**
     * If no root is specified, we will assume that the user wants to execute
     * the Task with no root. This is accomplished by using the Task parameter
     * as its own root.
     */
    public void execute(Task task) throws AntException {
        execute(task, task);
    }
    
    /**
     * This is the workhorse, however it has been made to be very simple. Given
     * the ability to specify a path between root and the target Task, we build
     * a trail of Tasks to connect the two. Next we execute each Task on the way
     * between the two Tasks. Once we arrive at the Task to execute, we execute
     * all of its chlidren.
     */
    public void execute(Task root, Task task) throws AntException {
        fireEngineStart();
        try {
            taskStack = getTaskStack(root, task);;
            if (taskStack == null) {
                throw new AntException(
                                       "The execution root Task is not an ancestor of the execution Task.");
            }
            
            // Pop thru the stack and execute each Task we come across.
            while (!taskStack.isEmpty()) {
                executeTask(taskStack);
            }
        } finally {
            fireEngineFinish();
        }
    }
    
    /**
     * A recursive routine that allows all Tasks in the stack to be executed. At
     * the same time, the stack may grow to include new Tasks.
     */
    protected void executeTask(Stack taskStack) throws AntException {
        Task task = (Task)taskStack.pop();
        
        fireTaskStart(task);
        try {
            // Add a new property holder for this task to the property stack. Note
            // that the parent of the new holder is the current stack head.
            if (task.isPropertyContainer()) {
                if (propertyStack.isEmpty()) {
                    propertyStack.push(new HierarchicalHashtable());
                } else {
                    propertyStack.push(new HierarchicalHashtable(
                                                                 (HierarchicalHashtable)propertyStack.peek()));
                }
                
            }
            
            // Allow Task to do whatever it may need to do before touching its
            // children.
            task.init(this);
            
            // Iterate the Task's children and execute any priority Tasks.
            Task[] tasks = task.getChildren();
            for (int i = 0, c = tasks.length; i < c; i++) {
                if (tasks[i].getExecutionMode() == Task.EXECUTION_MODE_PRIORITY) {
                    taskStack.push(tasks[i]);
                    executeTask(taskStack);
                }
            }
            
            // Allow the Task to validate.
            task.validate();
            
            // Finally, execute the Task.
            fireTaskExecute(task);
            task.execute(this);
            
            // We can discard the no londer needed property holder.
            if (task.isPropertyContainer()) {
                propertyStack.pop();
            }
            
        } catch (AntException ax) {
            fireTaskException(task, ax);
        } finally {
            fireTaskFinish(task);
        }
    }
    
    /**
     * Causes an AntEvent to be generated and fired to all listeners.
     */
    public void message(Task task, String message) {
        fireTaskMessage(task, message);
    }
    
    ////////////////////////////////////////////////////////////////////////////
    //                            Listener Support                            //
    ////////////////////////////////////////////////////////////////////////////
    
    public synchronized void addAntEngineListener(AntEngineListener listener) {
        if (!listenerList.contains(listener)) {
            listenerList.add(listener);
        }
    }
    
    public synchronized void removeAntEngineListener(AntEngineListener listener) {
        if (listenerList.contains(listener)) {
            listenerList.remove(listener);
        }
    }
    
    protected synchronized void fireEngineStart() {
        if (engineLevel++ > 0) return;
        AntEvent e = new AntEvent(this);
        for (int i = 0; i < listenerList.size(); i++) {
            ((AntEngineListener)listenerList.get(i)).engineStart(e);
        }
        
    }
    
    protected synchronized void fireEngineFinish() {
        if (--engineLevel > 0) return;
        AntEvent e = new AntEvent(this);
        for (int i = 0; i < listenerList.size(); i++) {
            ((AntEngineListener)listenerList.get(i)).engineFinish(e);
        }
        
    }
    
    protected synchronized void fireTaskStart(Task task) {
        AntEvent e = new AntEvent(this, task);
        for (int i = 0; i < listenerList.size(); i++) {
            ((AntEngineListener)listenerList.get(i)).taskStart(e);
        }
        
    }
    
    protected synchronized void fireTaskExecute(Task task) {
        AntEvent e = new AntEvent(this, task);
        for (int i = 0; i < listenerList.size(); i++) {
            ((AntEngineListener)listenerList.get(i)).taskExecute(e);
        }
        
    }
    
    protected synchronized void fireTaskFinish(Task task) {
        AntEvent e = new AntEvent(this, task);
        for (int i = 0; i < listenerList.size(); i++) {
            ((AntEngineListener)listenerList.get(i)).taskFinish(e);
        }
        
    }
    
    protected synchronized void fireTaskMessage(Task task, String message) {
        AntEvent e = new AntEvent(this, task);
        for (int i = 0; i < listenerList.size(); i++) {
            ((AntEngineListener)listenerList.get(i)).taskMessage(e, message);
        }
        
    }
    
    protected synchronized void fireTaskException(Task task, AntException exception) {
        AntEvent e = new AntEvent(this, task);
        for (int i = 0; i < listenerList.size(); i++) {
            ((AntEngineListener)listenerList.get(i)).taskException(e, exception);
        }
        
    }
    
    ////////////////////////////////////////////////////////////////////////////
    //                        Property Support Methods                        //
    ////////////////////////////////////////////////////////////////////////////
    
    /**
     * This is the routine that will perform key substitution. Phrase will come
     * in as "src/${someparam}" and be converted to the appropriate "normalized"
     * string. I suppose while I'm doing this we should support phrases with
     * nested keys, such as "src/${build${token}}". Also, we should properly
     * handle cases where ${someparam} will evaluate to ${anotherparam}.
     * <p></p>
     * One thing that will be different from the Ant 1.2 mechanismoccurs when a
     * parameter value is not found. The substitution routine inserts it back in
     * the phrase unchanged. I have opted to insert a zero-length string
     * instead.
     * <p></p>
     * I should add a switch to the engine that will give the user the ability
     * to throw an exception if a key is not found. Pretty easy, except this
     * method is a strange place for an AntException to be thrown. Perhaps I
     * should use a RuntimeException instead...
     * <p></p>
     * A brief rundown on the logic here:
     *     I check for the first instances of a key prefix.
     *     If none found we return the phrase as is.
     *     If key prefix is found get location of next key prefix and suffix.
     *     If suffix is found first, we have found a key.
     *     If there is no suffix, we return the phrase.
     */
    static final String KEY_PREFIX = "${";
    static final String KEY_SUFFIX = "}";
    protected String substitute(String phrase) {
        StringBuffer sb = new StringBuffer(phrase);
        int startPoint = 0;
        while (startPoint >= 0 && startPoint < phrase.length()) {
            int pre1 = startPoint + phrase.substring(startPoint).indexOf(KEY_PREFIX);
            if (pre1 < 0) break;
            int suf1 = phrase.substring(pre1 + KEY_PREFIX.length()).indexOf(KEY_SUFFIX);
            if (suf1 < 0) break;
            suf1 = suf1 + pre1 + KEY_PREFIX.length();
            int pre2 = phrase.substring(pre1 + KEY_PREFIX.length()).indexOf(KEY_PREFIX);
            if (pre2 < 0) {
                pre2 = phrase.length() + 1;
            } else {
                pre2 = pre2 + pre1 + KEY_PREFIX.length();
            }
            
            if (suf1 < pre2) {
                // we have found a token
                String key = sb.substring(pre1 + KEY_PREFIX.length(), suf1);
                sb.delete(pre1, suf1 + 1);
                Object value = getPropertyValueNoSubstitution(key);
                if (value != null) {
                    sb.insert(pre1, value.toString());
                }
                return substitute(sb.toString());
            }
            startPoint = pre2;
        }
        return sb.toString();
    }
    
    public List getPropertyNames() {
        if (propertyStack.isEmpty()) return new ArrayList();
        HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek();
        return hash.getPropertyNames();
    }
    
    public Object getPropertyValue(String name) {
        if (propertyStack.isEmpty()) return null;
        HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek();
        Object result = hash.getPropertyValue(name);
        if (result instanceof String) {
            return substitute((String)result);
        } else {
            return result;
        }
    }
    
    protected Object getPropertyValueNoSubstitution(String name) {
        if (propertyStack.isEmpty()) return null;
        HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek();
        return hash.getPropertyValue(name);
    }
    
    public void setPropertyValue(String name, Object value) {
        if (propertyStack.isEmpty()) return;
        HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek();
        hash.setPropertyValue(name, value);
    }
    
    public void removePropertyValue(String name) {
        if (propertyStack.isEmpty()) return;
        HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek();
        hash.remove(name);
    }
}