/*
 *  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.services;

import org.apache.easyant.core.EasyAntConstants;
import org.apache.easyant.core.EasyAntMagicNames;
import org.apache.easyant.core.ant.ProjectUtils;
import org.apache.easyant.core.ant.listerners.TaskCollectorFromImplicitTargetListener;
import org.apache.easyant.core.descriptor.EasyAntModuleDescriptor;
import org.apache.easyant.core.descriptor.PluginType;
import org.apache.easyant.core.descriptor.PropertyDescriptor;
import org.apache.easyant.core.parser.DefaultEasyAntXmlModuleDescriptorParser;
import org.apache.easyant.core.parser.EasyAntModuleDescriptorParser;
import org.apache.easyant.core.report.*;
import org.apache.easyant.tasks.*;
import org.apache.ivy.Ivy;
import org.apache.ivy.ant.IvyAntSettings;
import org.apache.ivy.core.IvyContext;
import org.apache.ivy.core.module.id.ModuleId;
import org.apache.ivy.core.module.id.ModuleRevisionId;
import org.apache.ivy.core.report.ArtifactDownloadReport;
import org.apache.ivy.core.report.ResolveReport;
import org.apache.ivy.core.resolve.IvyNode;
import org.apache.ivy.core.resolve.ResolveOptions;
import org.apache.ivy.core.resolve.ResolvedModuleRevision;
import org.apache.ivy.core.settings.IvySettings;
import org.apache.ivy.plugins.matcher.PatternMatcher;
import org.apache.ivy.plugins.parser.ModuleDescriptorParserRegistry;
import org.apache.ivy.plugins.repository.url.URLResource;
import org.apache.ivy.plugins.resolver.DependencyResolver;
import org.apache.ivy.util.Message;
import org.apache.tools.ant.*;
import org.apache.tools.ant.property.ParseNextProperty;
import org.apache.tools.ant.property.PropertyExpander;
import org.apache.tools.ant.taskdefs.Property;
import org.apache.tools.ant.types.FileSet;
import org.apache.tools.ant.types.Path;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.text.ParsePosition;
import java.util.Enumeration;
import java.util.Map;
import java.util.Properties;

public class DefaultPluginService implements PluginService {

    private final EasyAntModuleDescriptorParser parser;

    private final Ivy ivyInstance;
    private final IvyAntSettings easyantIvySettings;

    private boolean offlineMode;

    /**
     * This is the default constructor, the IvyContext should be the IvyContext configured to the easyant ivy instance
     *
     * @param easyantIvySettings the easyant ivy instance
     */
    public DefaultPluginService(final IvyAntSettings easyantIvySettings) {
        this(easyantIvySettings, new DefaultEasyAntXmlModuleDescriptorParser());
    }

    /**
     * A custom constructor if you want to specify your own parser / configuration service, you should use this
     * constructor the IvyContext should be the IvyContext configured to the easyant ivy instance
     *
     * @param easyantIvySetings the easyant ivy instance
     * @param parser            a valid easyantModuleDescriptor
     */
    public DefaultPluginService(final IvyAntSettings easyantIvySetings, EasyAntModuleDescriptorParser parser) {
        this.easyantIvySettings = easyantIvySetings;
        this.ivyInstance = easyantIvySetings.getConfiguredIvyInstance(easyantIvySetings);
        if (parser == null) {
            throw new IllegalArgumentException("You must set a valid easyant module descriptor parser");
        }
        this.parser = parser;
        ModuleDescriptorParserRegistry.getInstance().addParser(parser);
    }

    public EasyAntReport getPluginInfo(File pluginIvyFile, File sourceDirectory, String conf) throws Exception {
        IvyContext.pushNewContext().setIvy(ivyInstance);
        EasyAntReport eaReport = null;
        try {

            ResolveOptions resolveOptions = buildResolveOptions(conf);
            ResolveReport report = IvyContext.getContext().getIvy().getResolveEngine()
                    .resolve(pluginIvyFile.toURI().toURL(), resolveOptions);
            eaReport = new EasyAntReport();
            eaReport.setResolveReport(report);
            eaReport.setModuleDescriptor(report.getModuleDescriptor());

            Project project = buildProject();

            // expose resolve report for import deferred
            project.addReference(EasyAntMagicNames.IMPORTED_MODULES_RESOLVE_REPORT_REF, report);

            // emulate top level project
            ImportTestModule importTestModule = new ImportTestModule();
            importTestModule.setModuleIvy(pluginIvyFile);
            importTestModule.setSourceDirectory(sourceDirectory);
            importTestModule.setOwningTarget(ProjectUtils.createTopLevelTarget());
            importTestModule.setLocation(new Location(ProjectUtils.emulateMainScript(project).getAbsolutePath()));
            importTestModule.setProject(project);
            importTestModule.execute();

            analyseProject(project, eaReport, conf);
        } catch (Exception e) {
            throw new Exception("An error occured while fetching plugin informations : " + e.getMessage(), e);
        } finally {
            IvyContext.popContext();
        }
        return eaReport;

    }

    private ResolveOptions buildResolveOptions(String conf) {
        ResolveOptions resolveOptions = new ResolveOptions();
        resolveOptions.setLog(ResolveOptions.LOG_QUIET);
        resolveOptions.setConfs(conf.split(","));
        resolveOptions.setUseCacheOnly(offlineMode);
        return resolveOptions;
    }

    public EasyAntReport getPluginInfo(final ModuleRevisionId moduleRevisionId, String conf) throws Exception {
        IvyContext.pushNewContext().setIvy(ivyInstance);
        EasyAntReport eaReport = null;
        try {

            ResolveOptions resolveOptions = buildResolveOptions(conf);
            final ResolveReport report = IvyContext.getContext().getIvy().getResolveEngine()
                    .resolve(moduleRevisionId, resolveOptions, false);
            eaReport = new EasyAntReport();
            eaReport.setResolveReport(report);
            eaReport.setModuleDescriptor(report.getModuleDescriptor());

            Project project = buildProject();
            // expose resolve report for import deferred
            project.addReference(EasyAntMagicNames.IMPORTED_MODULES_RESOLVE_REPORT_REF, report);

            AbstractImport abstractImport = new AbstractImport() {
                @Override
                public void execute() throws BuildException {
                    Path path = createModulePath(moduleRevisionId.getModuleId());
                    File antFile = null;
                    for (ArtifactDownloadReport artifact : report.getConfigurationReport(getMainConf()).getAllArtifactsReports()) {
                        if ("ant".equals(artifact.getType())) {
                            antFile = artifact.getLocalFile();
                        } else if (shouldBeAddedToClasspath(artifact)) {
                            path.createPathElement().setLocation(artifact.getLocalFile());
                        } else {
                            handleOtherResourceFile(moduleRevisionId, artifact.getName(), artifact.getExt(),
                                    artifact.getLocalFile());
                        }
                    }
                    if (antFile != null && antFile.exists()) {
                        ProjectHelper.configureProject(getProject(), antFile);
                    }
                }
            };

            abstractImport.setProject(project);
            // location ?
            abstractImport.execute();

            analyseProject(project, eaReport, conf);
        } catch (Exception e) {
            throw new Exception("An error occured while fetching plugin informations : " + e.getMessage(), e);
        } finally {
            IvyContext.popContext();
        }
        return eaReport;

    }

    private Project buildProject() {
        Project project = new Project();
        project.setNewProperty(EasyAntMagicNames.AUDIT_MODE, "true");
        project.setNewProperty(EasyAntMagicNames.SKIP_CORE_REVISION_CHECKER, "true");
        project.addReference(EasyAntMagicNames.EASYANT_IVY_INSTANCE, easyantIvySettings);

        TaskCollectorFromImplicitTargetListener listener = new TaskCollectorFromImplicitTargetListener();
        listener.addClassToCollect(ParameterTask.class);
        listener.addClassToCollect(Property.class);
        listener.addClassToCollect(Import.class);
        listener.addClassToCollect(ImportDeferred.class);
        listener.addClassToCollect(Path.class);
        listener.addClassToCollect(PathTask.class);
        listener.addClassToCollect(FileSet.class);
        project.addBuildListener(listener);

        // add a property helper to ignore basedir property on reports
        PropertyHelper propertyHelper = PropertyHelper.getPropertyHelper(project);
        propertyHelper.add(new BypassDefaultPropertyExpander());

        project.init();
        ProjectUtils.configureProjectHelper(project);
        return project;
    }

    private void analyseProject(Project project, EasyAntReport eaReport, String conf) throws Exception {

        // handle tasks from implicit target
        // When using import/include, ant create a "implicit target" to process root tasks. When tasks are declared
        // outside of a target in root project we are able to parse them "normally" as this implicit target is added to
        // the project. However this is not the case for tasks declared outside any target in imported build script.
        // So we use a listener to collect required informations
        for (BuildListener buildListener : project.getBuildListeners()) {
            if (buildListener instanceof TaskCollectorFromImplicitTargetListener) {
                TaskCollectorFromImplicitTargetListener taskCollectorFromImplicitTargetListener = (TaskCollectorFromImplicitTargetListener) buildListener;
                for (Task task : taskCollectorFromImplicitTargetListener.getTasksCollected()) {
                    handleTask(project, eaReport, conf, task);
                }
            }
        }

        // handle tasks declared in targets
        Map<String, Target> targets = ProjectUtils.removeDuplicateTargets(project.getTargets());
        for (Target target : targets.values()) {
            if (!"".equals(target.getName())) {
                // gather root module location from target if no task at root level was defined
                TaskCollectorFromImplicitTargetListener.gatherRootModuleLocation(target.getProject(),
                        target.getLocation());
                handleTarget(target, eaReport);
                for (int i = 0; i < target.getTasks().length; i++) {
                    Task task = target.getTasks()[i];
                    handleTask(project, eaReport, conf, task);
                }
            }
        }
    }

    private Object maybeConfigureTask(Task task) {
        if (task.getRuntimeConfigurableWrapper().getProxy() instanceof UnknownElement) {
            UnknownElement ue = (UnknownElement) task.getRuntimeConfigurableWrapper().getProxy();
            ue.maybeConfigure();
            return ue.getRealThing();
        } else if (task instanceof UnknownElement) {
            UnknownElement ue = (UnknownElement) task;
            ue.maybeConfigure();
            return ue.getRealThing();
        } else {
            return task;
        }
    }

    private void handleTask(Project project, EasyAntReport eaReport, String conf, Task task) throws Exception {
        Class<?> taskClass = ComponentHelper.getComponentHelper(project).getComponentClass(task.getTaskType());
        if (taskClass != null) {
            if (ParameterTask.class.isAssignableFrom(taskClass)) {
                ParameterTask parameterTask = (ParameterTask) maybeConfigureTask(task);
                handleParameterTask(parameterTask, eaReport);
            }
            if (Property.class.isAssignableFrom(taskClass)) {
                Property propertyTask = (Property) maybeConfigureTask(task);
                handleProperty(propertyTask, eaReport);
            }
            if (Import.class.isAssignableFrom(taskClass)) {
                Import importTask = (Import) maybeConfigureTask(task);
                handleImport(importTask, eaReport, conf);
            }

            if (ImportDeferred.class.isAssignableFrom(taskClass)) {
                ImportDeferred importTask = (ImportDeferred) maybeConfigureTask(task);
                handleImportDeferred(importTask, eaReport, conf);
            }
            if (Path.class.isAssignableFrom(taskClass)) {
                Path path = (Path) maybeConfigureTask(task);
                handlePathParameter(task.getRuntimeConfigurableWrapper().getId(), path, task.getOwningTarget(),
                        eaReport);
            }
            if (PathTask.class.isAssignableFrom(taskClass)) {
                PathTask pathTask = (PathTask) maybeConfigureTask(task);
                handlePathParameter(pathTask, eaReport);
            }
            if (FileSet.class.isAssignableFrom(taskClass)) {
                FileSet fileSet = (FileSet) maybeConfigureTask(task);
                handleFilesetParameter(task.getRuntimeConfigurableWrapper().getId(), fileSet, task.getOwningTarget(),
                        eaReport);
            }
        }
    }

    private boolean isCurrentModule(Project project, Location location) {
        String rootModuleLocation = project.getProperty(TaskCollectorFromImplicitTargetListener.ROOT_MODULE_LOCATION);
        if (rootModuleLocation == null) {
            throw new IllegalStateException(
                    "rootModuleLocation not found, looks like TaskCollectorFromImplicitTargetListener is not properly configured");
        }
        return location != null && location.getFileName().equals(rootModuleLocation);
    }

    private void handleImport(Import importTask, EasyAntReport eaReport, String conf) throws Exception {
        ImportedModuleReport importedModuleReport = new ImportedModuleReport();

        importedModuleReport.setModuleMrid(importTask.getMrid());
        importedModuleReport.setOrganisation(importTask.getOrganisation());
        importedModuleReport.setModule(importTask.getModule());
        importedModuleReport.setRevision(importTask.getRevision());
        importedModuleReport.setMandatory(importTask.isMandatory());
        importedModuleReport.setMode(importTask.getMode());
        importedModuleReport.setAs(importTask.getAs());

        EasyAntReport pluginInfo = getPluginInfo(ModuleRevisionId.parse(importedModuleReport.getModuleMrid()), conf);
        importedModuleReport.setEasyantReport(pluginInfo);
        eaReport.addImportedModuleReport(importedModuleReport,
                isCurrentModule(importTask.getProject(), importTask.getLocation()));

        Message.debug("Ant file import another module called : " + importedModuleReport.getModuleMrid() + " with mode "
                + importedModuleReport.getMode());
    }

    private void handleImportDeferred(ImportDeferred importTask, EasyAntReport eaReport, String conf) throws Exception {
        ImportedModuleReport importedModuleReport = new ImportedModuleReport();

        importedModuleReport.setOrganisation(importTask.getOrganisation());
        importedModuleReport.setModule(importTask.getModule());
        ResolveReport resolveReport = importTask.getProject().getReference(
                EasyAntMagicNames.IMPORTED_MODULES_RESOLVE_REPORT_REF);
        if (resolveReport != null) {
            for (Object o : resolveReport.getDependencies()) {
                IvyNode dependency = (IvyNode) o;
                if (dependency.getResolvedId().getOrganisation().equals(importTask.getOrganisation()) //
                        && dependency.getResolvedId().getName().equals(importTask.getModule())) {
                    importedModuleReport.setRevision(dependency.getResolvedId().getRevision());
                }

            }
        }

        importedModuleReport.setMandatory(importTask.isMandatory());
        importedModuleReport.setMode(importTask.getMode());
        importedModuleReport.setAs(importTask.getAs());

        EasyAntReport pluginInfo = getPluginInfo(ModuleRevisionId.parse(importedModuleReport.getModuleMrid()), conf);
        importedModuleReport.setEasyantReport(pluginInfo);
        eaReport.addImportedModuleReport(importedModuleReport,
                isCurrentModule(importTask.getProject(), importTask.getLocation()));

        Message.debug("Ant file import another module called : " + importedModuleReport.getModuleMrid() + " with mode "
                + importedModuleReport.getMode());
    }

    private void handleProperty(Property property, EasyAntReport eaReport) throws IOException {
        boolean isCurrentModule = isCurrentModule(property.getProject(), property.getLocation());
        if (property.getFile() != null) {
            Properties propToLoad = new Properties();
            File f = property.getFile();
            if (f.exists()) {
                FileInputStream fis = null;

                try {
                    fis = new FileInputStream(f);
                    propToLoad.load(fis);
                    for (Object o : propToLoad.keySet()) {
                        String key = (String) o;
                        PropertyDescriptor propertyDescriptor = new PropertyDescriptor(key);
                        propertyDescriptor.setValue(propToLoad.getProperty(key));
                        if (property.getOwningTarget() != null) {
                            propertyDescriptor.setOwningTarget(property.getOwningTarget().getName());
                        }
                        eaReport.addPropertyDescriptor(propertyDescriptor.getName(), propertyDescriptor,
                                isCurrentModule);
                    }

                } catch (IOException e) {
                    IOException ioe = new IOException("Unable to parse the property file :" + property.getFile());
                    ioe.initCause(e);
                    throw ioe;
                } finally {
                    if (fis != null) {
                        fis.close();
                    }
                }
            }

        }
        if (property.getName() != null) {
            PropertyDescriptor propertyDescriptor = new PropertyDescriptor(property.getName());
            propertyDescriptor.setValue(property.getValue());
            if (property.getOwningTarget() != null) {
                propertyDescriptor.setOwningTarget(property.getOwningTarget().getName());
            }
            eaReport.addPropertyDescriptor(property.getName(), propertyDescriptor, isCurrentModule);
        }
    }

    private void handleParameterTask(ParameterTask parameterTask, EasyAntReport eaReport) {
        boolean isCurrentModule = isCurrentModule(parameterTask.getProject(), parameterTask.getLocation());

        if (parameterTask.getProperty() != null) {
            PropertyDescriptor propertyDescriptor = new PropertyDescriptor(parameterTask.getProperty());
            propertyDescriptor.setDefaultValue(parameterTask.getDefault());
            // Use unsafe version since we are in audit mode and we want the real value of the required field 
            // (#isRequired method will always return false in audit mode)
            propertyDescriptor.setRequired(parameterTask.isRequiredUnsafe());
            propertyDescriptor.setDescription(parameterTask.getDescription());
            if (parameterTask.getOwningTarget() != null) {
                propertyDescriptor.setOwningTarget(parameterTask.getOwningTarget().getName());
            }
            Message.debug("Ant file has a property called : " + propertyDescriptor.getName());
            eaReport.addPropertyDescriptor(propertyDescriptor.getName(), propertyDescriptor, isCurrentModule);
        } else if (parameterTask.getPath() != null) {
            ParameterReport parameterReport = new ParameterReport(ParameterType.PATH);
            parameterReport.setName(parameterTask.getPath());
            // Use unsafe version since we are in audit mode and we want the real value of the required field 
            // (#isRequired method will always return false in audit mode)
            parameterReport.setRequired(parameterTask.isRequiredUnsafe());
            parameterReport.setDescription(parameterTask.getDescription());
            if (parameterTask.getOwningTarget() != null) {
                parameterReport.setOwningTarget(parameterTask.getOwningTarget().getName());
            }
            eaReport.addParameterReport(parameterReport, isCurrentModule);
            Message.debug("Ant file has a path called : " + parameterReport.getName());
        }
    }

    private void handleFilesetParameter(String id, FileSet fileSet, Target target, EasyAntReport eaReport) {
        ParameterReport parameterReport = new ParameterReport(ParameterType.FILESET);
        if (id != null) {
            parameterReport.setName(id);
            parameterReport.setRequired(false);
            parameterReport.setDescription(fileSet.getDescription());
            if (target != null) {
                parameterReport.setOwningTarget(target.getName());
            }
            eaReport.addParameterReport(parameterReport, isCurrentModule(fileSet.getProject(), fileSet.getLocation()));
            Message.debug("Ant file has a fileset called : " + parameterReport.getName());
        }

    }

    private void handlePathParameter(String pathid, Path path, Target target, EasyAntReport eaReport) {
        ParameterReport parameterReport = new ParameterReport(ParameterType.PATH);
        if (pathid != null) {
            parameterReport.setName(pathid);
            parameterReport.setRequired(false);
            parameterReport.setDescription(path.getDescription());
            if (target != null) {
                parameterReport.setOwningTarget(target.getName());
            }
            eaReport.addParameterReport(parameterReport, isCurrentModule(path.getProject(), path.getLocation()));
            Message.debug("Ant file has a path called : " + parameterReport.getName());
        }
    }

    private void handlePathParameter(PathTask pathTask, EasyAntReport eaReport) {
        ParameterReport parameterReport = new ParameterReport(ParameterType.PATH);
        if (pathTask.getPathid() != null) {
            parameterReport.setName(pathTask.getPathid());
            parameterReport.setRequired(false);
            parameterReport.setDescription(pathTask.getDescription());
            if (pathTask.getOwningTarget() != null) {
                parameterReport.setOwningTarget(pathTask.getOwningTarget().getName());
            }
            eaReport.addParameterReport(parameterReport, isCurrentModule(pathTask.getProject(), pathTask.getLocation()));
            Message.debug("Ant file has a path called : " + parameterReport.getName());
        }
    }

    private void handleTarget(Target target, EasyAntReport eaReport) {
        boolean isCurrentModule = isCurrentModule(target.getProject(), target.getLocation());
        boolean isExtensionPoint = target instanceof ExtensionPoint;
        if (!isExtensionPoint) {
            TargetReport targetReport = new TargetReport();
            targetReport.setName(target.getName());
            StringBuilder sb = new StringBuilder();
            Enumeration<?> targetDeps = target.getDependencies();
            while (targetDeps.hasMoreElements()) {
                String t = (String) targetDeps.nextElement();
                sb.append(t);
                if (targetDeps.hasMoreElements()) {
                    sb.append(",");
                }
            }
            targetReport.setDepends(sb.toString());
            targetReport.setDescription(target.getDescription());
            targetReport.setIfCase(target.getIf());
            targetReport.setUnlessCase(target.getUnless());
            for (Target currentTarget : target.getProject().getTargets().values()) {
                if (currentTarget instanceof ExtensionPoint) {
                    Enumeration<?> dependencies = currentTarget.getDependencies();
                    while (dependencies.hasMoreElements()) {
                        String dep = (String) dependencies.nextElement();
                        if (dep.equals(target.getName())) {
                            targetReport.setExtensionPoint(currentTarget.getName());
                        }
                    }

                }
            }

            eaReport.addTargetReport(targetReport, isCurrentModule);

            Message.debug("Ant file has a target called : " + targetReport.getName());
        } else {
            ExtensionPointReport extensionPoint = new ExtensionPointReport(target.getName());
            StringBuilder sb = new StringBuilder();
            Enumeration<?> targetDeps = target.getDependencies();
            while (targetDeps.hasMoreElements()) {
                String t = (String) targetDeps.nextElement();
                sb.append(t);
                if (targetDeps.hasMoreElements()) {
                    sb.append(",");
                }
            }
            extensionPoint.setDepends(sb.toString());
            extensionPoint.setDescription(target.getDescription());
            eaReport.addExtensionPointReport(extensionPoint, isCurrentModule);
            Message.debug("Ant file has an extensionPoint called : " + extensionPoint.getName());
        }
    }

    public EasyAntReport getPluginInfo(ModuleRevisionId moduleRevisionId) throws Exception {
        return getPluginInfo(moduleRevisionId, "default");
    }

    public EasyAntReport getPluginInfo(String moduleRevisionId) throws Exception {
        ModuleRevisionId module = buildModuleRevisionId(moduleRevisionId, PluginType.PLUGIN);
        return getPluginInfo(module);
    }

    public EasyAntReport getBuildTypeInfo(String moduleRevisionId) throws Exception {
        ModuleRevisionId module = buildModuleRevisionId(moduleRevisionId, PluginType.BUILDTYPE);
        return getPluginInfo(module);
    }

    public EasyAntModuleDescriptor getEasyAntModuleDescriptor(File moduleDescriptor) throws Exception {
        if (moduleDescriptor == null) {
            throw new Exception("moduleDescriptor cannot be null");
        }
        if (!moduleDescriptor.exists()) {
            throw new Exception("imposible to find the specified module descriptor"
                    + moduleDescriptor.getAbsolutePath());
        }
        IvyContext.pushNewContext().setIvy(ivyInstance);
        // First we need to parse the specified file to retrieve all the easyant
        // stuff
        parser.parseDescriptor(ivyInstance.getSettings(), moduleDescriptor.toURI().toURL(), new URLResource(
                moduleDescriptor.toURI().toURL()), true);
        EasyAntModuleDescriptor md = parser.getEasyAntModuleDescriptor();
        IvyContext.popContext();
        return md;
    }

    public EasyAntReport generateEasyAntReport(File moduleDescriptor, File optionalAntModule, File overrideAntModule)
            throws Exception {
        EasyAntReport eaReport = new EasyAntReport();
        EasyAntModuleDescriptor md = getEasyAntModuleDescriptor(moduleDescriptor);
        eaReport.setModuleDescriptor(md.getIvyModuleDescriptor());

        Project p = buildProject();
        Target implicitTarget = ProjectUtils.createTopLevelTarget();
        p.addTarget(implicitTarget);

        // calculate basedir
        if (moduleDescriptor != null) {
            p.setBaseDir(moduleDescriptor.getParentFile());
        } else if (optionalAntModule != null) {
            p.setBaseDir(optionalAntModule.getParentFile());
        } else if (overrideAntModule != null) {
            p.setBaseDir(overrideAntModule.getParentFile());
        }

        LoadModule loadModule = new LoadModule();
        loadModule.setBuildModule(moduleDescriptor);
        loadModule.setBuildFile(optionalAntModule);
        loadModule.setOwningTarget(implicitTarget);
        loadModule.setLocation(new Location(ProjectUtils.emulateMainScript(p).getAbsolutePath()));
        loadModule.setProject(p);
        loadModule.setTaskName("load-module");
        loadModule.execute();
        ProjectHelper projectHelper = ProjectUtils.getConfiguredProjectHelper(p);
        projectHelper.resolveExtensionOfAttributes(p);
        analyseProject(p, eaReport, "default");

        return eaReport;
    }

    public ModuleRevisionId[] search(String organisation, String moduleName, String revision, String branch,
                                     String matcher, String resolver) throws Exception {
        IvySettings settings = ivyInstance.getSettings();

        if (moduleName == null && PatternMatcher.EXACT.equals(matcher)) {
            throw new Exception("no module name provided for ivy repository graph task: "
                    + "It can either be set explicitely via the attribute 'module' or "
                    + "via 'ivy.module' property or a prior call to <resolve/>");
        } else if (moduleName == null && !PatternMatcher.EXACT.equals(matcher)) {
            moduleName = PatternMatcher.ANY_EXPRESSION;
        }
        ModuleRevisionId mrid = ModuleRevisionId.newInstance(organisation, moduleName, revision);

        ModuleRevisionId criteria;

        if ((revision == null) || settings.getVersionMatcher().isDynamic(mrid)) {
            criteria = new ModuleRevisionId(new ModuleId(organisation, moduleName), branch, "*");
        } else {
            criteria = new ModuleRevisionId(new ModuleId(organisation, moduleName), branch, revision);
        }

        PatternMatcher patternMatcher = settings.getMatcher(matcher);
        if (PatternMatcher.ANY_EXPRESSION.equals(resolver)) {
            // search in all resolvers. this can be quite slow for complex
            // repository configurations
            // with ChainResolvers, since resolvers in chains will be searched
            // multiple times.
            return ivyInstance.listModules(criteria, patternMatcher);
        } else {
            // limit search to the specified resolver.
            DependencyResolver dependencyResolver = resolver == null ? settings.getDefaultResolver() : settings
                    .getResolver(resolver);
            if (dependencyResolver == null) {
                throw new IllegalArgumentException("Unknown dependency resolver for search: " + resolver);
            }

            ivyInstance.pushContext();
            try {
                return ivyInstance.getSearchEngine().listModules(dependencyResolver, criteria, patternMatcher);
            } finally {
                ivyInstance.popContext();
            }
        }
    }

    public ModuleRevisionId[] search(String organisation, String moduleName) throws Exception {
        return search(organisation, moduleName, null, null, PatternMatcher.EXACT_OR_REGEXP, null);
    }

    public String[] searchModule(String organisation, String moduleName) throws Exception {
        ModuleRevisionId[] mrids = search(organisation, moduleName);
        String[] result = new String[mrids.length];
        for (int i = 0; i < mrids.length; i++) {
            result[i] = mrids[i].toString();
        }
        return result;
    }

    public String getDescription(ModuleRevisionId mrid) {
        ResolvedModuleRevision rmr = ivyInstance.findModule(mrid);
        return rmr.getDescriptor().getDescription();
    }

    public String getPluginDescription(String moduleRevisionId) {
        ModuleRevisionId module = buildModuleRevisionId(moduleRevisionId, PluginType.PLUGIN);
        return getDescription(module);
    }

    public String getBuildTypeDescription(String moduleRevisionId) {
        ModuleRevisionId module = buildModuleRevisionId(moduleRevisionId, PluginType.BUILDTYPE);

        return getDescription(module);
    }

    private ModuleRevisionId buildModuleRevisionId(String moduleRevisionId, PluginType pluginType) {
        String mrid = moduleRevisionId;
        if (!mrid.matches(".*#.*")) {
            if (pluginType.equals(PluginType.BUILDTYPE)) {
                Message.debug("No organisation specified for buildtype " + mrid + " using the default one");

                mrid = EasyAntConstants.EASYANT_BUILDTYPES_ORGANISATION + "#" + mrid;

            } else {
                Message.debug("No organisation specified for plugin " + mrid + " using the default one");

                mrid = EasyAntConstants.EASYANT_PLUGIN_ORGANISATION + "#" + mrid;
            }
        }
        return ModuleRevisionId.parse(mrid);
    }

    public EasyAntReport generateEasyAntReport(File moduleDescriptor) throws Exception {
        return generateEasyAntReport(moduleDescriptor, null, null);
    }

    /**
     * Don't try to expand property on reports. Bypassing default property expander allow us to show real static value
     * of properties on reports.
     */
    private class BypassDefaultPropertyExpander implements PropertyExpander {

        public String parsePropertyName(String s, ParsePosition pos, ParseNextProperty notUsed) {
            int index = pos.getIndex();
            // directly check near, triggering characters:
            if (s.length() - index >= 3 && '$' == s.charAt(index) && '{' == s.charAt(index + 1)) {
                int start = index;

                // defer to String.indexOf() for protracted check:
                int end = s.indexOf('}', start);
                if (end < 0) {
                    throw new BuildException("Syntax error in property: " + s.substring(index));
                }

                // set marker after "}"
                pos.setIndex(end + 1);

                // allow to resolve path to property files
                // this is mandatory if we want report to contains properties loaded by
                // property file like done on buildtypes
                // in that case property needs to be really expanded so we need to strips "${" and "}" characters
                String strippedPropertyName = s.substring(start + 2, end);
                if (strippedPropertyName.endsWith("properties.file")) {

                    return strippedPropertyName;
                }

                // in other cases return the whole property with "${" and "}"
                return start == end ? "" : s.substring(start, end + 1);
            }
            return null;
        }
    }

    public void setOfflineMode(boolean offlineMode) {
        this.offlineMode = offlineMode;
    }
}