/*

package com.nokia.ant;

import info.bliki.wiki.model.WikiModel;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.tools.ant.BuildException;

import org.apache.tools.ant.Project;

import org.apache.tools.ant.Target;

import org.apache.tools.ant.Task;

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

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

import org.apache.tools.ant.types.resources.FileResource;

import org.dom4j.Attribute;

import org.dom4j.CDATA;

import org.dom4j.Comment;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

import org.dom4j.Node;

import org.dom4j.Text;

import org.dom4j.Visitor;

import org.dom4j.VisitorSupport;

import org.dom4j.XPath;

import org.dom4j.io.OutputFormat;

import org.dom4j.io.SAXReader;

import org.dom4j.io.XMLWriter;

/**

 * Reads the current ant project and a fileset and generates a xml file with a summary of targets,

 * macros and properties.

 */

    private Project project;

    private ResourceCollection rc;

    private Task task;

    private boolean debug;

    private boolean homeFilesOnly = true;

    private HashMap<String, List<String>> globalSignalList = new HashMap<String, List<String>>();

    private HashMap<String, String> map = new HashMap<String, String>();

    private Document signaldoc;

        this.project = project;

        this.rc = rc;

        this.task = task;

        map.put("hlm", "http://www.nokia.com/helium");

    }

    public Project getProject() {

        return project;

    }

    public void setDebug(boolean debug) {

        this.debug = debug;

    }

    public void setHomeFilesOnly(boolean homeFilesOnly) {

        this.homeFilesOnly = homeFilesOnly;

    }

    public void log(String msg, int level) {

        if (task != null) {

            task.log(msg, level);

            project.log(msg, level);

        }

    }

        Object object = r.getReferencedObject();

            throw new BuildException(r.getRefId() + " doesn\'t denote a ResourceCollection");

        }

        rc = (ResourceCollection) object;

    }

    public Document createDOM() throws DocumentException, IOException {

        Element root = DocumentHelper.createElement("antDatabase");

        Document outDoc = DocumentHelper.createDocument(root);

        ArrayList<String> antFiles = getAntFiles(getProject(), homeFilesOnly);

        }

            parseAntFile(root, antFile);

        }

        buildTaskDefs(root);

        return outDoc;

    }

    public void createXMLFile(File outputFile) {

        try {

            Document outDoc = createDOM();

            OutputStream outStream = System.out;

            if (outputFile != null) {

                outStream = new FileOutputStream(outputFile);

            }

            XMLWriter out = new XMLWriter(outStream, OutputFormat.createPrettyPrint());

            out.write(outDoc);

            throw new BuildException(e.getMessage());

            throw new BuildException(e.getMessage());

        }

    }

    @SuppressWarnings("unchecked")

        SAXReader xmlReader = new SAXReader();

        Document antDoc = xmlReader.read(new File(antFile));

        XPath xpath = DocumentHelper.createXPath("//hlm:signalListenerConfig");

        xpath.setNamespaceURIs(map);

        List<Element> signalNodes = xpath.selectNodes(antDoc);

            signaldoc = antDoc;

            String signalid = propertyNode.attributeValue("id");

            String signaltarget = propertyNode.attributeValue("target");

            List<String> existinglist = globalSignalList.get(signaltarget);

            String failbuild = signalType(signalid, signaldoc);

                existinglist = new ArrayList<String>();

            existinglist.add(signalid + "," + failbuild);

            globalSignalList.put(signaltarget, existinglist);

        }

    }

    @SuppressWarnings("unchecked")

        xpath2.setNamespaceURIs(map);

        List<Element> signalNodes3 = xpath2.selectNodes(antDoc);

            String signalinputid = propertyNode3.attributeValue("refid");

            xpath3.setNamespaceURIs(map);

            List<Element> signalNodes4 = xpath3.selectNodes(antDoc);

                return propertyNode4.attributeValue("failbuild");

            }

        }

        return null;

    }

    /**

     * @param root

     * @param antFile

     * @throws DocumentException

     * @throws IOException

     */

    @SuppressWarnings("unchecked")

        log("Processing Ant file: " + antFile, Project.MSG_DEBUG);

        SAXReader xmlReader = new SAXReader();

        Document antDoc = xmlReader.read(new File(antFile));

        // Element targetElement =

        // DocumentHelper.createElement("target");

        Element projectElement = root.addElement("project");

        Element nameElement = projectElement.addElement("name");

        String projectName = antDoc.valueOf("/project/@name");

        nameElement.setText(projectName);

        // Element descriptionElement =

        // projectElement.addElement("description");

        String description = antDoc.valueOf("/project/description");

        insertDocumentation(projectElement, description);

        // descriptionElement.setText(description);

            log("Project has no comment: " + projectName, Project.MSG_WARN);

        }

        Element defaultElement = projectElement.addElement("default");

        defaultElement.setText(antDoc.valueOf("/project/@default"));

        // Project import statements

        List importNodes = antDoc.selectNodes("//import");

            Element importCurrentNode = (Element) iterator.next();

        }

        projectElement.addElement("pythonDependency");

        // Project exec statements

        List<Element> execNodes = antDoc.selectNodes("//exec//arg");

            String argValue = argNode.attributeValue("value");

                argValue = argNode.attributeValue("line");

                Pattern filePattern = Pattern.compile(".pl|.py|.bat|.xml|.txt");

                Matcher fileMatcher = filePattern.matcher(argValue);

                    addTextElement(projectElement, "fileDependency", argValue);

                }

            }

        }

        List<Element> targetNodes = antDoc.selectNodes("//target");

            processTarget(targetNode, projectElement);

        }

        // Process macrodef and scriptdef tasks

        // TODO - maybe scriptdefs should be separate?

        List macroNodes = antDoc.selectNodes("//macrodef | //scriptdef");

            Element macroNode = (Element) iterator.next();

            processMacro(macroNode, projectElement, antFile);

        }

        // Project properties

        List propertyNodes = antDoc.selectNodes("//property");

            Element propertyNode = (Element) iterator.next();

            processProperty(propertyNode, projectElement);

        }

    }

        return getAntFiles(getProject(), true);

    }

        return getAntFiles(project, true);

    }

    /**

     * 

     * @return antFiles a list of ant files to be processed

     */

    @SuppressWarnings("unchecked")

        ArrayList<String> antFiles = new ArrayList<String>();

        Map<String, Target> targets = project.getTargets();

        Iterator<Target> targetsIter = targets.values().iterator();

        String projectHome = null;

        try {

            projectHome = new File(project.getProperty("helium.dir")).getCanonicalPath();

                Target target = targetsIter.next();

                String projectPath = new File(target.getLocation().getFileName()).getCanonicalPath();

                            antFiles.add(projectPath);

                        }

                        antFiles.add(projectPath);

                    }

                }

            }

            e.printStackTrace();

        }

        return antFiles;

    }

    @SuppressWarnings("unchecked")

    private void processMacro(Element macroNode, Element outProjectNode, String antFile)

        String macroName = macroNode.attributeValue("name");

        log("Processing macro: " + macroName, Project.MSG_DEBUG);

        Element outmacroNode = outProjectNode.addElement("macro");

        addTextElement(outmacroNode, "name", macroNode.attributeValue("name"));

        addTextElement(outmacroNode, "description", macroNode.attributeValue("description"));

        // Add location

        // Project project = getProject();

        // Macro antmacro = (Macro) project.getTargets().get(macroName);

        // System.out.println(project.getMacroDefinitions());

        // System.out.println(macroName);

        // MacroInstance antmacro = (MacroInstance)

        // project.getMacroDefinitions().get("http://www.nokia.com/helium:" +

        // macroName);

        // Add the location with just the file path for now and a dummy line

        // number.

        // TODO - Later we should find the line number from the XML input.

        addTextElement(outmacroNode, "location", antFile + ":1:");

        String usage = "";

            String defaultval = statement.valueOf("@default");

                defaultval = "value";

                defaultval = "<i>" + defaultval + "</i>";

            usage = usage + " " + statement.valueOf("@name") + "=\"" + defaultval + "\"";

        }

        String macroElements = "";

            macroElements = "<" + statement.valueOf("@name") + "/>\n" + macroElements;

        }

            addTextElement(outmacroNode, "usage", "<hlm:" + macroName + " " + usage + "/>");

        // Add dependencies

        // Enumeration dependencies = antmacro.getDependencies();

        // while (dependencies.hasMoreElements())

        // {

        // String dependency = (String) dependencies.nextElement();

        // Element dependencyElement = addTextElement(outmacroNode,

        // "dependency", dependency);

        // dependencyElement.addAttribute("type","direct");

        // }

        // Add documentation

        // Get comment element before the macro element to extract macro doc

        List<Node> children = macroNode.selectNodes("preceding-sibling::node()");

            // Scan past the text nodes, which are most likely whitespace

            int index = children.size() - 1;

            Node child = (Node) children.get(index);

                index--;

                child = (Node) children.get(index);

            }

            // Check if there is a comment node

            String commentText = null;

                Comment macroComment = (Comment) child;

                commentText = macroComment.getStringValue().trim();

                log(macroName + " comment: " + commentText, Project.MSG_DEBUG);

            }

                log("Macro has no comment: " + macroName, Project.MSG_WARN);

            }

            insertDocumentation(outmacroNode, commentText);

        }

        // Get names of all properties used in this macro

        ArrayList properties = new ArrayList();

        Visitor visitor = new AntPropertyVisitor(properties);

        macroNode.accept(visitor);

            String property = (String) iterator.next();

            addTextElement(outmacroNode, "propertyDependency", property);

        }

    }

        // Add antcall/runtarget dependencies

        ArrayList<String> antcallTargets = new ArrayList<String>();

        ArrayList<String> logs = new ArrayList<String>();

        ArrayList<String> signals = new ArrayList<String>();

        ArrayList<String> executables = new ArrayList<String>();

        Visitor visitorTarget = new AntTargetVisitor(antcallTargets, logs, signals, executables);

        targetNode.accept(visitorTarget);

            Element dependencyElement = addTextElement(outTargetNode, "dependency", antcallTarget);

            dependencyElement.addAttribute("type", "exec");

        }

            addTextElement(outTargetNode, "log", log);

        }

            signals.addAll(globalSignalList.get(targetNode.attributeValue("name")));

            addTextElement(outTargetNode, "signal", signal);

        }

            addTextElement(outTargetNode, "executable", executable);

        }

    }

    @SuppressWarnings("unchecked")

        String targetName = targetNode.attributeValue("name");

        log("Processing target: " + targetName, Project.MSG_DEBUG);

        // Add documentation

        // Get comment element before the target element to extract target doc

        String commentText = "";

        List<Node> children = targetNode.selectNodes("preceding-sibling::node()");

            // Scan past the text nodes, which are most likely whitespace

            int index = children.size() - 1;

            Node child = children.get(index);

                index--;

                child = (Node) children.get(index);

            }

            // Check if there is a comment node

                Comment targetComment = (Comment) child;

                commentText = targetComment.getStringValue().trim();

                log(targetName + " comment: " + commentText, Project.MSG_DEBUG);

            }

                log("Target has no comment: " + targetName, Project.MSG_WARN);

            }

        }

            Element outTargetNode = outProjectNode.addElement("target");

            addTextElement(outTargetNode, "name", targetNode.attributeValue("name"));

            addTextElement(outTargetNode, "ifDependency", targetNode.attributeValue("if"));

            addTextElement(outTargetNode, "unlessDependency", targetNode.attributeValue("unless"));

            addTextElement(outTargetNode, "description", targetNode.attributeValue("description"));

            addTextElement(outTargetNode, "tasks", String.valueOf(targetNode.elements().size()));

            // Add location

            Project project = getProject();

            Target antTarget = (Target) project.getTargets().get(targetName);