/*
 *  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.ivy.plugins.resolver;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.Map;

import org.apache.ivy.core.IvyContext;
import org.apache.ivy.core.LogOptions;
import org.apache.ivy.core.RelativeUrlResolver;
import org.apache.ivy.core.cache.ArtifactOrigin;
import org.apache.ivy.core.cache.CacheDownloadOptions;
import org.apache.ivy.core.cache.CacheMetadataOptions;
import org.apache.ivy.core.cache.DownloadListener;
import org.apache.ivy.core.cache.RepositoryCacheManager;
import org.apache.ivy.core.cache.ResolutionCacheManager;
import org.apache.ivy.core.event.EventManager;
import org.apache.ivy.core.event.download.EndArtifactDownloadEvent;
import org.apache.ivy.core.event.download.NeedArtifactEvent;
import org.apache.ivy.core.event.download.StartArtifactDownloadEvent;
import org.apache.ivy.core.module.descriptor.Artifact;
import org.apache.ivy.core.module.descriptor.DependencyDescriptor;
import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
import org.apache.ivy.core.module.id.ModuleId;
import org.apache.ivy.core.module.id.ModuleRevisionId;
import org.apache.ivy.core.module.status.StatusManager;
import org.apache.ivy.core.report.ArtifactDownloadReport;
import org.apache.ivy.core.report.DownloadReport;
import org.apache.ivy.core.report.DownloadStatus;
import org.apache.ivy.core.report.MetadataArtifactDownloadReport;
import org.apache.ivy.core.resolve.DownloadOptions;
import org.apache.ivy.core.resolve.IvyNode;
import org.apache.ivy.core.resolve.ResolveData;
import org.apache.ivy.core.resolve.ResolveOptions;
import org.apache.ivy.core.resolve.ResolvedModuleRevision;
import org.apache.ivy.core.search.ModuleEntry;
import org.apache.ivy.core.search.OrganisationEntry;
import org.apache.ivy.core.search.RevisionEntry;
import org.apache.ivy.core.settings.Validatable;
import org.apache.ivy.plugins.conflict.ConflictManager;
import org.apache.ivy.plugins.latest.ArtifactInfo;
import org.apache.ivy.plugins.latest.LatestStrategy;
import org.apache.ivy.plugins.matcher.PatternMatcher;
import org.apache.ivy.plugins.namespace.NameSpaceHelper;
import org.apache.ivy.plugins.namespace.Namespace;
import org.apache.ivy.plugins.parser.ParserSettings;
import org.apache.ivy.plugins.resolver.ChainResolver.ResolvedModuleRevisionArtifactInfo;
import org.apache.ivy.plugins.resolver.util.HasLatestStrategy;
import org.apache.ivy.plugins.resolver.util.ResolvedResource;
import org.apache.ivy.util.Checks;
import org.apache.ivy.util.Message;

/**
 * This abstract resolver only provides handling for resolver name
 */
public abstract class AbstractResolver implements DependencyResolver, HasLatestStrategy,
        Validatable {

    /**
     * True if parsed ivy files should be validated against xsd, false if they should not, null if
     * default behavior should be used
     */
    private Boolean validate = null;

    private String name;

    private ResolverSettings settings;

    private EventManager eventManager = null; // may remain null

    /**
     * The latest strategy to use to find latest among several artifacts
     */
    private LatestStrategy latestStrategy;

    private String latestStrategyName;

    /**
     * The namespace to which this resolver belongs
     */
    private Namespace namespace;

    private String namespaceName;

    private String cacheManagerName;

    private RepositoryCacheManager repositoryCacheManager;

    // used to store default values for nested cache
    private String changingMatcherName;

    private String changingPattern;

    private Boolean checkmodified;

    public ResolverSettings getSettings() {
        return settings;
    }

    public ParserSettings getParserSettings() {
        return new ResolverParserSettings();
    }

    public void setSettings(ResolverSettings ivy) {
        settings = ivy;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * this method should remove sensitive information from a location to be displayed in a log
     * 
     * @param name
     *            location
     * @return location with sensitive data replaced by stars
     */
    public String hidePassword(String name) {
        return name;
    }

    protected boolean doValidate(ResolveData data) {
        if (validate != null) {
            return validate.booleanValue();
        } else {
            return data.isValidate();
        }
    }

    public boolean isValidate() {
        return validate == null ? true : validate.booleanValue();
    }

    public void setValidate(boolean validate) {
        this.validate = Boolean.valueOf(validate);
    }

    protected void checkInterrupted() {
        IvyContext.getContext().getIvy().checkInterrupted();
    }

    public void reportFailure() {
        Message.verbose("no failure report implemented by " + getName());
    }

    public void reportFailure(Artifact art) {
        Message.verbose("no failure report implemented by " + getName());
    }

    public String[] listTokenValues(String token, Map otherTokenValues) {
        return new String[0];
    }

    public Map[] listTokenValues(String[] tokens, Map criteria) {
        return new Map[0];
    }

    public OrganisationEntry[] listOrganisations() {
        return new OrganisationEntry[0];
    }

    public ModuleEntry[] listModules(OrganisationEntry org) {
        return new ModuleEntry[0];
    }

    public RevisionEntry[] listRevisions(ModuleEntry module) {
        return new RevisionEntry[0];
    }

    public String toString() {
        return getName();
    }

    public void dumpSettings() {
        Message.verbose("\t" + getName() + " [" + getTypeName() + "]");
        Message.debug("\t\tcache: " + cacheManagerName);
    }

    public String getTypeName() {
        return getClass().getName();
    }

    /**
     * Default implementation downloads the artifact without taking advantage of its location
     */
    public ArtifactDownloadReport download(ArtifactOrigin artifact, DownloadOptions options) {
        DownloadReport r = download(new Artifact[] {artifact.getArtifact()}, options);
        return r.getArtifactReport(artifact.getArtifact());
    }

    public boolean exists(Artifact artifact) {
        return locate(artifact) != null;
    }

    /**
     * Default implementation actually download the artifact Subclasses should overwrite this to
     * avoid the download
     */
    public ArtifactOrigin locate(Artifact artifact) {
        DownloadReport dr = download(new Artifact[] {artifact}, new DownloadOptions());
        if (dr == null) {
            /*
             * according to IVY-831, it seems that this actually happen sometime, while the contract
             * of DependencyResolver says that it should never return null
             */
            throw new IllegalStateException("null download report returned by " + getName() + " ("
                    + getClass().getName() + ")" + " when trying to download " + artifact);
        }
        ArtifactDownloadReport adr = dr.getArtifactReport(artifact);
        return adr.getDownloadStatus() == DownloadStatus.FAILED ? null : adr.getArtifactOrigin();
    }

    public LatestStrategy getLatestStrategy() {
        if (latestStrategy == null) {
            initLatestStrategyFromSettings();
        }
        return latestStrategy;
    }

    private void initLatestStrategyFromSettings() {
        if (getSettings() != null) {
            if (latestStrategyName != null && !"default".equals(latestStrategyName)) {
                latestStrategy = getSettings().getLatestStrategy(latestStrategyName);
                if (latestStrategy == null) {
                    throw new IllegalStateException("unknown latest strategy '"
                            + latestStrategyName + "'");
                }
            } else {
                latestStrategy = getSettings().getDefaultLatestStrategy();
                Message.debug(getName() + ": no latest strategy defined: using default");
            }
        } else {
            throw new IllegalStateException("no ivy instance found: "
                    + "impossible to get a latest strategy without ivy instance");
        }
    }

    public void setLatestStrategy(LatestStrategy latestStrategy) {
        this.latestStrategy = latestStrategy;
    }

    public void setLatest(String strategyName) {
        latestStrategyName = strategyName;
    }

    public String getLatest() {
        if (latestStrategyName == null) {
            latestStrategyName = "default";
        }
        return latestStrategyName;
    }

    public Namespace getNamespace() {
        if (namespace == null) {
            initNamespaceFromSettings();
        }
        return namespace;
    }

    private void initNamespaceFromSettings() {
        if (getSettings() != null) {
            if (namespaceName != null) {
                namespace = getSettings().getNamespace(namespaceName);
                if (namespace == null) {
                    throw new IllegalStateException("unknown namespace '" + namespaceName + "'");
                }
            } else {
                namespace = getSettings().getSystemNamespace();
                Message.debug(getName() + ": no namespace defined: using system");
            }
        } else {
            Message.verbose(getName()
                    + ": no namespace defined nor ivy instance: using system namespace");
            namespace = Namespace.SYSTEM_NAMESPACE;
        }
    }

    public void setNamespace(String namespaceName) {
        this.namespaceName = namespaceName;
    }

    // Namespace conversion methods
    protected ModuleDescriptor toSystem(ModuleDescriptor md) {
        return NameSpaceHelper.toSystem(md, getNamespace());
    }

    protected Artifact fromSystem(Artifact artifact) {
        return NameSpaceHelper.transform(artifact, getNamespace().getFromSystemTransformer());
    }

    protected Artifact toSystem(Artifact artifact) {
        return NameSpaceHelper.transform(artifact, getNamespace().getToSystemTransformer());
    }

    protected MetadataArtifactDownloadReport toSystem(MetadataArtifactDownloadReport report) {
        return NameSpaceHelper.transform(report, getNamespace().getToSystemTransformer());
    }

    protected ResolvedModuleRevision toSystem(ResolvedModuleRevision rmr) {
        return NameSpaceHelper.toSystem(rmr, getNamespace());
    }

    protected ModuleRevisionId toSystem(ModuleRevisionId resolvedMrid) {
        return getNamespace().getToSystemTransformer().transform(resolvedMrid);
    }

    protected DependencyDescriptor fromSystem(DependencyDescriptor dd) {
        return NameSpaceHelper.transform(dd, getNamespace().getFromSystemTransformer(), true);
    }

    protected DependencyDescriptor toSystem(DependencyDescriptor dd) {
        return NameSpaceHelper.transform(dd, getNamespace().getToSystemTransformer(), true);
    }

    protected IvyNode getSystemNode(ResolveData data, ModuleRevisionId resolvedMrid) {
        return data.getNode(toSystem(resolvedMrid));
    }

    protected ResolvedModuleRevision findModuleInCache(DependencyDescriptor dd, ResolveData data) {
        return findModuleInCache(dd, data, false);
    }

    protected ResolvedModuleRevision findModuleInCache(DependencyDescriptor dd, ResolveData data,
            boolean anyResolver) {
        ResolvedModuleRevision rmr = getRepositoryCacheManager().findModuleInCache(dd,
            dd.getDependencyRevisionId(), getCacheOptions(data), anyResolver ? null : getName());
        if (rmr == null) {
            return null;
        }
        if (data.getReport() != null
                && data.isBlacklisted(data.getReport().getConfiguration(), rmr.getId())) {
            Message.verbose("\t" + getName() + ": found revision in cache: " + rmr.getId()
                    + " for " + dd + ", but it is blacklisted");
            return null;
        }
        return rmr;
    }

    public void setChangingMatcher(String changingMatcherName) {
        this.changingMatcherName = changingMatcherName;
    }

    protected String getChangingMatcherName() {
        return changingMatcherName;
    }

    public void setChangingPattern(String changingPattern) {
        this.changingPattern = changingPattern;
    }

    protected String getChangingPattern() {
        return changingPattern;
    }

    public void setCheckmodified(boolean check) {
        checkmodified = Boolean.valueOf(check);
    }

    public RepositoryCacheManager getRepositoryCacheManager() {
        if (repositoryCacheManager == null) {
            initRepositoryCacheManagerFromSettings();
        }
        return repositoryCacheManager;
    }

    private void initRepositoryCacheManagerFromSettings() {
        if (cacheManagerName == null) {
            repositoryCacheManager = settings.getDefaultRepositoryCacheManager();
            if (repositoryCacheManager == null) {
                throw new IllegalStateException(
                        "no default cache manager defined with current settings");
            }
        } else {
            repositoryCacheManager = settings.getRepositoryCacheManager(cacheManagerName);
            if (repositoryCacheManager == null) {
                throw new IllegalStateException("unknown cache manager '" + cacheManagerName
                        + "'. Available caches are "
                        + Arrays.asList(settings.getRepositoryCacheManagers()));
            }
        }
    }

    public void setRepositoryCacheManager(RepositoryCacheManager repositoryCacheManager) {
        this.cacheManagerName = repositoryCacheManager.getName();
        this.repositoryCacheManager = repositoryCacheManager;
    }

    public void setCache(String cacheName) {
        cacheManagerName = cacheName;
    }

    public void setEventManager(EventManager eventManager) {
        this.eventManager = eventManager;
    }

    public EventManager getEventManager() {
        return eventManager;
    }

    public void validate() {
        initRepositoryCacheManagerFromSettings();
        initNamespaceFromSettings();
        initLatestStrategyFromSettings();
    }

    protected CacheMetadataOptions getCacheOptions(ResolveData data) {
        return (CacheMetadataOptions) new CacheMetadataOptions()
                .setChangingMatcherName(getChangingMatcherName())
                .setChangingPattern(getChangingPattern())
                .setCheckTTL(!data.getOptions().isUseCacheOnly())
                .setCheckmodified(
                    data.getOptions().isUseCacheOnly() ? Boolean.FALSE : checkmodified)
                .setValidate(doValidate(data)).setNamespace(getNamespace())
                .setForce(data.getOptions().isRefresh())
                .setListener(getDownloadListener(getDownloadOptions(data.getOptions())));
    }

    protected CacheDownloadOptions getCacheDownloadOptions(DownloadOptions options) {
        CacheDownloadOptions cacheDownloadOptions = new CacheDownloadOptions();
        cacheDownloadOptions.setListener(getDownloadListener(options));
        return cacheDownloadOptions;
    }

    protected DownloadOptions getDownloadOptions(ResolveOptions options) {
        return (DownloadOptions) new DownloadOptions().setLog(options.getLog());
    }

    public void abortPublishTransaction() throws IOException {
        /* Default implementation is a no-op */
    }

    public void commitPublishTransaction() throws IOException {
        /* Default implementation is a no-op */
    }

    public void beginPublishTransaction(ModuleRevisionId module, boolean overwrite)
            throws IOException {
        /* Default implementation is a no-op */
    }

    private DownloadListener getDownloadListener(final DownloadOptions options) {
        return new DownloadListener() {
            public void needArtifact(RepositoryCacheManager cache, Artifact artifact) {
                if (eventManager != null) {
                    eventManager
                            .fireIvyEvent(new NeedArtifactEvent(AbstractResolver.this, artifact));
                }
            }

            public void startArtifactDownload(RepositoryCacheManager cache, ResolvedResource rres,
                    Artifact artifact, ArtifactOrigin origin) {
                if (artifact.isMetadata() || LogOptions.LOG_QUIET.equals(options.getLog())) {
                    Message.verbose("downloading " + rres.getResource() + " ...");
                } else {
                    Message.info("downloading " + rres.getResource() + " ...");
                }
                if (eventManager != null) {
                    eventManager.fireIvyEvent(new StartArtifactDownloadEvent(AbstractResolver.this,
                            artifact, origin));
                }
            }

            public void endArtifactDownload(RepositoryCacheManager cache, Artifact artifact,
                    ArtifactDownloadReport adr, File archiveFile) {
                if (eventManager != null) {
                    eventManager.fireIvyEvent(new EndArtifactDownloadEvent(AbstractResolver.this,
                            artifact, adr, archiveFile));
                }
            }
        };
    }

    /**
     * Returns true if rmr1 is after rmr2, using the latest strategy to determine which is the
     * latest
     * 
     * @param rmr1
     * @param rmr2
     * @return
     */
    protected boolean isAfter(ResolvedModuleRevision rmr1, ResolvedModuleRevision rmr2, Date date) {
        ArtifactInfo[] ais = new ArtifactInfo[] {new ResolvedModuleRevisionArtifactInfo(rmr1),
                new ResolvedModuleRevisionArtifactInfo(rmr2)};
        return getLatestStrategy().findLatest(ais, date) == ais[0];
    }

    protected ResolvedModuleRevision checkLatest(DependencyDescriptor dd,
            ResolvedModuleRevision newModuleFound, ResolveData data) {
        Checks.checkNotNull(dd, "dd");
        Checks.checkNotNull(data, "data");

        // check if latest is asked and compare to return the most recent
        ResolvedModuleRevision previousModuleFound = data.getCurrentResolvedModuleRevision();
        String newModuleDesc = describe(newModuleFound);
        Message.debug("\tchecking " + newModuleDesc + " against " + describe(previousModuleFound));
        if (previousModuleFound == null) {
            Message.debug("\tmodule revision kept as first found: " + newModuleDesc);
            saveModuleRevisionIfNeeded(dd, newModuleFound);
            return newModuleFound;
        } else if (isAfter(newModuleFound, previousModuleFound, data.getDate())) {
            Message.debug("\tmodule revision kept as younger: " + newModuleDesc);
            saveModuleRevisionIfNeeded(dd, newModuleFound);
            return newModuleFound;
        } else if (!newModuleFound.getDescriptor().isDefault()
                && previousModuleFound.getDescriptor().isDefault()) {
            Message.debug("\tmodule revision kept as better (not default): " + newModuleDesc);
            saveModuleRevisionIfNeeded(dd, newModuleFound);
            return newModuleFound;
        } else {
            Message.debug("\tmodule revision discarded as older: " + newModuleDesc);
            return previousModuleFound;
        }
    }

    protected void saveModuleRevisionIfNeeded(DependencyDescriptor dd,
            ResolvedModuleRevision newModuleFound) {
        if (newModuleFound != null
                && getSettings().getVersionMatcher().isDynamic(dd.getDependencyRevisionId())) {
            getRepositoryCacheManager().saveResolvedRevision(dd.getDependencyRevisionId(),
                newModuleFound.getId().getRevision());
        }
    }

    private String describe(ResolvedModuleRevision rmr) {
        if (rmr == null) {
            return "[none]";
        }
        return rmr.getId() + (rmr.getDescriptor().isDefault() ? "[default]" : "") + " from "
                + rmr.getResolver().getName();
    }

    private class ResolverParserSettings implements ParserSettings {

        public ConflictManager getConflictManager(String name) {
            return AbstractResolver.this.getSettings().getConflictManager(name);
        }

        public Namespace getContextNamespace() {
            return AbstractResolver.this.getNamespace();
        }

        public String getDefaultBranch(ModuleId moduleId) {
            return AbstractResolver.this.getSettings().getDefaultBranch(moduleId);
        }

        public PatternMatcher getMatcher(String matcherName) {
            return AbstractResolver.this.getSettings().getMatcher(matcherName);
        }

        public Namespace getNamespace(String namespace) {
            return AbstractResolver.this.getSettings().getNamespace(namespace);
        }

        public RelativeUrlResolver getRelativeUrlResolver() {
            return AbstractResolver.this.getSettings().getRelativeUrlResolver();
        }

        public ResolutionCacheManager getResolutionCacheManager() {
            return AbstractResolver.this.getSettings().getResolutionCacheManager();
        }

        public DependencyResolver getResolver(ModuleRevisionId mRevId) {
            return AbstractResolver.this.getSettings().getResolver(mRevId);
        }

        public StatusManager getStatusManager() {
            return AbstractResolver.this.getSettings().getStatusManager();
        }

        public File resolveFile(String filename) {
            return AbstractResolver.this.getSettings().resolveFile(filename);
        }

        public Map substitute(Map strings) {
            return AbstractResolver.this.getSettings().substitute(strings);
        }

        public String substitute(String value) {
            return AbstractResolver.this.getSettings().substitute(value);
        }

    }
}