/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

package com.nokia.ivy;

import java.io.*;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import java.util.Map;

import org.apache.ivy.core.IvyPatternHelper;

import org.apache.ivy.core.module.descriptor.Artifact;

import org.apache.ivy.core.module.descriptor.DefaultArtifact;

import org.apache.ivy.core.module.descriptor.DependencyDescriptor;

import org.apache.ivy.core.module.descriptor.ModuleDescriptor;

import org.apache.ivy.core.module.id.ModuleRevisionId;

import org.apache.ivy.core.resolve.ResolveData;

import org.apache.ivy.core.settings.IvyPattern;

import org.apache.ivy.plugins.latest.LatestStrategy;

import org.apache.ivy.plugins.repository.BasicResource;

import org.apache.ivy.plugins.repository.Resource;

import org.apache.ivy.plugins.resolver.BasicResolver;

import org.apache.ivy.plugins.resolver.util.MDResolvedResource;

import org.apache.ivy.plugins.resolver.util.ResolvedResource;

import org.apache.ivy.plugins.resolver.util.ResourceMDParser;

import org.apache.ivy.plugins.version.VersionMatcher;

import org.apache.ivy.util.Message;

/**

 * Ivy plugin to read tool versions

 */

public class ToolResolver extends BasicResolver

{

    private static final Map<String, String> IVY_ARTIFACT_ATTRIBUTES = new HashMap<String, String>();

    static {

        IVY_ARTIFACT_ATTRIBUTES.put(IvyPatternHelper.ARTIFACT_KEY, "ivy");

        IVY_ARTIFACT_ATTRIBUTES.put(IvyPatternHelper.TYPE_KEY, "ivy");

        IVY_ARTIFACT_ATTRIBUTES.put(IvyPatternHelper.EXT_KEY, "xml");

    }

    private List<String> ivyPatterns = new ArrayList<String>(); // List (String pattern)

    private List<String> artifactPatterns = new ArrayList<String>();  // List (String pattern)

    private boolean m2compatible;

    public ResolvedResource findIvyFileRef(DependencyDescriptor dd, ResolveData data) {

        ModuleRevisionId mrid = dd.getDependencyRevisionId();

        if (isM2compatible()) {

            mrid = convertM2IdForResourceSearch(mrid);

        }

        return findResourceUsingPatterns(mrid, ivyPatterns, DefaultArtifact.newIvyArtifact(mrid, data.getDate()), getRMDParser(dd, data), data.getDate());

    }

    protected ResolvedResource findArtifactRef(Artifact artifact, Date date) {

        ModuleRevisionId mrid = artifact.getModuleRevisionId();

        if (isM2compatible()) {

            mrid = convertM2IdForResourceSearch(mrid);

        }

        return findResourceUsingPatterns(mrid, artifactPatterns, artifact, getDefaultRMDParser(artifact.getModuleRevisionId().getModuleId()), date);

    }

    @SuppressWarnings("unchecked")

    protected ResolvedResource findResourceUsingPatterns(ModuleRevisionId moduleRevision, List patternList, Artifact artifact, ResourceMDParser rmdparser, Date date) {

        ResolvedResource rres = null;

        List<ResolvedResource> resolvedResources = new ArrayList<ResolvedResource>();

        boolean dynamic = getSettings().getVersionMatcher().isDynamic(moduleRevision);

        boolean stop = false;

        for (Iterator iter = patternList.iterator(); iter.hasNext() && !stop;) {

            String pattern = (String)iter.next();

            rres = findResourceUsingPattern(moduleRevision, pattern, artifact, rmdparser, date);

            if (rres != null) {

                resolvedResources.add(rres);

                stop = !dynamic; // stop iterating if we are not searching a dynamic revision

            }

        }

        if (resolvedResources.size() > 1) {

            ResolvedResource[] rress = (ResolvedResource[]) resolvedResources.toArray(new ResolvedResource[resolvedResources.size()]);

            rres = findResource(rress, getName(), getLatestStrategy(), getSettings().getVersionMatcher(), rmdparser, moduleRevision, date);

        }

        return rres;

    }

    @SuppressWarnings("unchecked")

    public ResolvedResource findResource(

            ResolvedResource[] rress, 

            String name,

            LatestStrategy strategy, 

            VersionMatcher versionMatcher, 

            ResourceMDParser rmdparser,

            ModuleRevisionId mrid, 

            Date date) {

        ResolvedResource found = null;

        List sorted = strategy.sort(rress);

        List rejected = new ArrayList();

        for (ListIterator iter = sorted.listIterator(sorted.size()); iter.hasPrevious();) {

            ResolvedResource rres = (ResolvedResource) iter.previous();

            if (date != null && rres.getLastModified() > date.getTime()) {

                Message.verbose("\t" + name + ": too young: " + rres);

                rejected.add(rres.getRevision() + " (" + rres.getLastModified() + ")");

                continue;

            }

            ModuleRevisionId foundMrid = ModuleRevisionId.newInstance(mrid, rres.getRevision());

            if (!versionMatcher.accept(mrid, foundMrid)) {

                Message.debug("\t" + name + ": rejected by version matcher: " + rres);

                rejected.add(rres.getRevision());

                continue;

            }

            if (versionMatcher.needModuleDescriptor(mrid, foundMrid)) {

                ResolvedResource r = rmdparser.parse(rres.getResource(), rres.getRevision());

                ModuleDescriptor md = ((MDResolvedResource)r).getResolvedModuleRevision().getDescriptor();

                if (md.isDefault()) {

                    Message.debug("\t" + name + ": default md rejected by version matcher requiring module descriptor: " + rres);

                    rejected.add(rres.getRevision() + " (MD)");

                    continue;

                } else if (!versionMatcher.accept(mrid, md)) {

                    Message.debug("\t" + name + ": md rejected by version matcher: " + rres);

                    rejected.add(rres.getRevision() + " (MD)");

                    continue;

                } else {

                    found = r;

                }

            } else {

                found = rres;

            }

            if (found != null) {

                if (!found.getResource().exists()) {

                    Message.debug("\t" + name + ": resource not reachable for " + mrid + ": res=" + found.getResource());

                    logAttempt(found.getResource().toString());

                    continue; 

                }

                break;

            }

        }

        if (found == null && !rejected.isEmpty()) {

            logAttempt(rejected.toString());

        }

        return found;

    }

    @SuppressWarnings("unchecked")

    protected Collection findNames(Map tokenValues, String token) {

        Collection names = new HashSet();

        names.addAll(findIvyNames(tokenValues, token));

        if (isAllownomd()) {

            names.addAll(findArtifactNames(tokenValues, token));

        }

        return names;

    }

    protected Collection<String> findIvyNames(Map<String, String> tokenValues, String token) {

        Collection<String> names = new HashSet<String>();

        tokenValues = new HashMap<String, String>(tokenValues);

        tokenValues.put(IvyPatternHelper.ARTIFACT_KEY, "ivy");

        tokenValues.put(IvyPatternHelper.TYPE_KEY, "ivy");

        tokenValues.put(IvyPatternHelper.EXT_KEY, "xml");

        findTokenValues(names, getIvyPatterns(), tokenValues, token);

        getSettings().filterIgnore(names);

        return names;

    }

    protected Collection<String> findArtifactNames(Map<String, String> tokenValues, String token) {

        Collection<String> names = new HashSet<String>();

        tokenValues = new HashMap<String, String>(tokenValues);

        tokenValues.put(IvyPatternHelper.ARTIFACT_KEY, tokenValues.get(IvyPatternHelper.MODULE_KEY));

        tokenValues.put(IvyPatternHelper.TYPE_KEY, "jar");

        tokenValues.put(IvyPatternHelper.EXT_KEY, "jar");

        findTokenValues(names, getArtifactPatterns(), tokenValues, token);

        getSettings().filterIgnore(names);

        return names;

    }

    // should be overridden by subclasses wanting to have listing features

    protected void findTokenValues(Collection<String> names, List<String> patterns, Map<String, String> tokenValues, String token) {

    }

    /**

     * example of pattern : ~/Workspace/[module]/[module].ivy.xml

     * @param pattern

     */

    public void addIvyPattern(String pattern) {

        ivyPatterns.add(pattern);

    }

    public void addArtifactPattern(String pattern) {

        artifactPatterns.add(pattern);

    }

    public List<String> getIvyPatterns() {

        return Collections.unmodifiableList(ivyPatterns);

    }

    public List<String> getArtifactPatterns() {

        return Collections.unmodifiableList(artifactPatterns);

    }

    protected void setIvyPatterns(List<String> ivyPatterns) {

        this.ivyPatterns = ivyPatterns;

    }

    protected void setArtifactPatterns(List<String> artifactPatterns) {

        this.artifactPatterns = artifactPatterns;

    }

    /*

     * Methods respecting ivy conf method specifications

     */

    public void addConfiguredIvy(IvyPattern p) {

        ivyPatterns.add(p.getPattern());

    }

    public void addConfiguredArtifact(IvyPattern p) {

        artifactPatterns.add(p.getPattern());

    }

    public void dumpSettings() {

        super.dumpSettings();

        Message.debug("\t\tm2compatible: " + isM2compatible());

        Message.debug("\t\tivy patterns:");

        for (ListIterator iter = getIvyPatterns().listIterator(); iter.hasNext();) {

            String p = (String)iter.next();

            Message.debug("\t\t\t" + p);

        }

        Message.debug("\t\tartifact patterns:");

        for (ListIterator iter = getArtifactPatterns().listIterator(); iter.hasNext();) {

            String p = (String)iter.next();

            Message.debug("\t\t\t" + p);

        }

    }

    public boolean isM2compatible() {

        return m2compatible;

    }

    public void setM2compatible(boolean m2compatible) {

        this.m2compatible = m2compatible;

    }

    protected ModuleRevisionId convertM2IdForResourceSearch(ModuleRevisionId mrid) {

        if (mrid.getOrganisation().indexOf('.') == -1) {

            return mrid;

        }

        return ModuleRevisionId.newInstance(mrid.getOrganisation().replace('.', '/'), mrid.getName(), mrid.getBranch(), mrid.getRevision(), mrid.getExtraAttributes());

    }

    public void publish(Artifact artifact, File src, boolean overwrite) throws IOException

    {

        Message.verbose("ToolResolver.publish() start");

    }

    private static File findExecutableOnPath(String executableName) {

        String systemPath = System.getenv("PATH");

        String[] pathDirs = systemPath.split(File.pathSeparator);

        String[] extensions = {""};

        // Using PATHEXT to get the supported extenstions on windows platform

        if (System.getProperty("os.name").toLowerCase().startsWith("win")) {

            extensions = System.getenv("PATHEXT").split(File.pathSeparator);

        }

        for (String extension : extensions) {

            String checkName = executableName;

            if (System.getProperty("os.name").toLowerCase().startsWith("win") && !executableName.toLowerCase().endsWith(extension.toLowerCase())) {

                checkName = executableName + extension;

            }

            File file = new File(checkName);

            if (file.isAbsolute()) {

                Message.verbose("Testing: " + file.getAbsolutePath());

                if (file.isFile()) {

                    return file;

                }

            }

            for (String pathDir : pathDirs) {

                file = new File(pathDir, checkName);

                Message.verbose("Testing: " + file.getAbsolutePath());

                if (file.isFile()) {

                    return file;

                }

            }

        }

        return null;

    }

    protected ResolvedResource findResourceUsingPattern(ModuleRevisionId mrid, String pattern,

            Artifact artifact, ResourceMDParser rmdparser, Date date)

    {

        Message.verbose("ToolResolver.findResourceUsingPattern() start");

        Message.verbose(artifact.getName());

        Message.verbose(mrid.getRevision());

        Message.verbose(artifact.getAttribute("versionArgs"));

        String toolVersion = mrid.getRevision();

        ResolvedResource resolvedResource = null;

        try

        {

            File executable = findExecutableOnPath(artifact.getName());

            if (executable == null) {

                return null;

            }

            Message.verbose("executable: " + executable.getAbsolutePath());

            String versionText = getToolVersion(executable, artifact.getAttribute("versionArgs"));

            Message.verbose(versionText);

            if (versionText.contains(toolVersion) || versionText.matches(artifact.getAttribute("versionExp")))

            {

                BasicResource resource = new BasicResource(executable.getAbsolutePath(), true, 0, 0, true);

                resolvedResource = new ResolvedResource(resource, toolVersion);

            }

        }

        catch (IOException e)

        {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        return resolvedResource;

    }

    @Override

    protected long get(Resource resource, File dest) throws IOException

    {

        Message.verbose("ToolResolver.get() start");

        return 0;

    }

    private String getToolVersion(File executable, String versionArgs) throws IOException

    {

        Runtime runtime = Runtime.getRuntime();

        Message.verbose("'" + executable.getAbsolutePath() + " " + versionArgs + "'");

        //Process toolProcess = runtime.exec(toolName+ "." + toolType + " " + versionArgs);

        Process toolProcess = runtime.exec(executable.getAbsolutePath() + " " + versionArgs);

        InputStream in = toolProcess.getInputStream();

        InputStream err = toolProcess.getErrorStream();

        String outText = toString(in).trim();

        String errText = toString(err).trim();

        Message.verbose("err: " + errText);

        return outText + errText;

    }

    private String toString(InputStream inputStream) throws IOException

    {

        byte[] buffer = new byte[4096];

        OutputStream outputStream = new ByteArrayOutputStream();

        while (true) {

            int read = inputStream.read(buffer);

            if (read == -1) {

                break;

            }

            outputStream.write(buffer, 0, read);

        }

        outputStream.close();

        inputStream.close();

        return outputStream.toString();

    }

    @Override

    protected Resource getResource(String arg0) throws IOException {

        // TODO Auto-generated method stub

        return null;

    }

}