/*
 * 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.eclipse.aether.internal.impl;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;

import org.eclipse.aether.ConfigurationProperties;
import org.eclipse.aether.Keys;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.impl.UpdateCheck;
import org.eclipse.aether.impl.UpdateCheckManager;
import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
import org.eclipse.aether.metadata.Metadata;
import org.eclipse.aether.repository.AuthenticationDigest;
import org.eclipse.aether.repository.Proxy;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.ResolutionErrorPolicy;
import org.eclipse.aether.spi.io.PathProcessor;
import org.eclipse.aether.transfer.ArtifactNotFoundException;
import org.eclipse.aether.transfer.ArtifactTransferException;
import org.eclipse.aether.transfer.MetadataNotFoundException;
import org.eclipse.aether.transfer.MetadataTransferException;
import org.eclipse.aether.util.ConfigUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static java.util.Objects.requireNonNull;

/**
 */
@Singleton
@Named
public class DefaultUpdateCheckManager implements UpdateCheckManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultUpdateCheckManager.class);

    private static final String UPDATED_KEY_SUFFIX = ".lastUpdated";

    private static final String ERROR_KEY_SUFFIX = ".error";

    private static final String NOT_FOUND = "";

    // instance bound private key
    static final Object SESSION_CHECKS = Keys.of(new Object() {
        @Override
        public String toString() {
            return "updateCheckManager.checks";
        }
    });

    // instance bound private key
    static final Object SESSION_NOT_FOUNDS = Keys.of(new Object() {
        @Override
        public String toString() {
            return "updateCheckManager.notFounds";
        }
    });

    /**
     * Manages the session state, i.e. influences if the same download requests to artifacts/metadata will happen
     * multiple times within the same RepositorySystemSession. If "enabled" will enable the session state. If "bypass"
     * will enable bypassing (i.e. store all artifact ids/metadata ids which have been updates but not evaluating
     * those). All other values lead to disabling the session state completely.
     *
     * @configurationSource {@link RepositorySystemSession#getConfigProperties()}
     * @configurationType {@link java.lang.String}
     * @configurationDefaultValue {@link #DEFAULT_SESSION_STATE}
     */
    public static final String CONFIG_PROP_SESSION_STATE =
            ConfigurationProperties.PREFIX_AETHER + "updateCheckManager.sessionState";

    public static final String DEFAULT_SESSION_STATE = "enabled";

    private static final int STATE_ENABLED = 0;

    private static final int STATE_BYPASS = 1;

    private static final int STATE_DISABLED = 2;

    /**
     * This "last modified" timestamp is used when no local file is present, signaling "first attempt" to cache a file,
     * but as it is not present, outcome is simply always "go get it".
     * <p>
     * Its meaning is "we never downloaded it", so go grab it.
     */
    private static final long TS_NEVER = 0L;

    /**
     * This "last modified" timestamp is returned by {@link #getLastUpdated(Properties, String)} method when the
     * timestamp entry is not found (due properties file not present or key not present in properties file, irrelevant).
     * It means that the cached file (artifact or metadata) is present, but we cannot tell when was it downloaded. In
     * this case, it is {@link UpdatePolicyAnalyzer} applying in-effect policy, that decide is update (re-download)
     * needed or not. For example, if policy is "never", we should not re-download the file.
     * <p>
     * Its meaning is "we downloaded it, but have no idea when", so let the policy decide its fate.
     */
    private static final long TS_UNKNOWN = 1L;

    private final TrackingFileManager trackingFileManager;

    private final UpdatePolicyAnalyzer updatePolicyAnalyzer;

    private final PathProcessor pathProcessor;

    @Inject
    public DefaultUpdateCheckManager(
            TrackingFileManager trackingFileManager,
            UpdatePolicyAnalyzer updatePolicyAnalyzer,
            PathProcessor pathProcessor) {
        this.trackingFileManager = requireNonNull(trackingFileManager, "tracking file manager cannot be null");
        this.updatePolicyAnalyzer = requireNonNull(updatePolicyAnalyzer, "update policy analyzer cannot be null");
        this.pathProcessor = requireNonNull(pathProcessor, "path processor cannot be null");
    }

    @Override
    public void checkArtifact(RepositorySystemSession session, UpdateCheck<Artifact, ArtifactTransferException> check) {
        requireNonNull(session, "session cannot be null");
        requireNonNull(check, "check cannot be null");
        final String updatePolicy = check.getArtifactPolicy();
        if (check.getLocalLastUpdated() != 0
                && !isUpdatedRequired(session, check.getLocalLastUpdated(), updatePolicy)) {
            LOGGER.debug("Skipped remote request for {}, locally installed artifact up-to-date", check.getItem());

            check.setRequired(false);
            return;
        }

        Artifact artifact = check.getItem();
        RemoteRepository repository = check.getRepository();

        Path artifactPath =
                requireNonNull(check.getPath(), String.format("The artifact '%s' has no file attached", artifact));

        boolean fileExists = check.isFileValid() && Files.exists(artifactPath);

        Path touchPath = getArtifactTouchFile(artifactPath);
        Properties props = read(touchPath);

        String updateKey = getUpdateKey(session, artifactPath, repository);
        String dataKey = getDataKey(repository);

        String error = getError(props, dataKey);

        long lastUpdated;
        if (error == null) {
            if (fileExists) {
                // last update was successful
                lastUpdated = pathProcessor.lastModified(artifactPath, 0L);
            } else {
                // this is the first attempt ever
                lastUpdated = TS_NEVER;
            }
        } else if (error.isEmpty()) {
            // artifact did not exist
            lastUpdated = getLastUpdated(props, dataKey);
        } else {
            // artifact could not be transferred
            String transferKey = getTransferKey(session, repository);
            lastUpdated = getLastUpdated(props, transferKey);
        }

        if (lastUpdated == TS_NEVER) {
            check.setRequired(true);
        } else if (isAlreadyUpdated(session, updateKey)) {
            LOGGER.debug("Skipped remote request for {}, already updated during this session", check.getItem());

            check.setRequired(false);
            if (error != null) {
                check.setException(newException(error, artifact, repository));
            }
        } else if (isUpdatedRequired(session, lastUpdated, updatePolicy)) {
            check.setRequired(true);
        } else if (fileExists) {
            LOGGER.debug("Skipped remote request for {}, locally cached artifact up-to-date", check.getItem());

            check.setRequired(false);
        } else {
            int errorPolicy = Utils.getPolicy(session, artifact, repository);
            int cacheFlag = getCacheFlag(error);
            if ((errorPolicy & cacheFlag) != 0) {
                check.setRequired(false);
                check.setException(newException(error, artifact, repository));
            } else {
                check.setRequired(true);
            }
        }
    }

    private static int getCacheFlag(String error) {
        if (error == null || error.isEmpty()) {
            return ResolutionErrorPolicy.CACHE_NOT_FOUND;
        } else {
            return ResolutionErrorPolicy.CACHE_TRANSFER_ERROR;
        }
    }

    private ArtifactTransferException newException(String error, Artifact artifact, RemoteRepository repository) {
        if (error == null || error.isEmpty()) {
            return new ArtifactNotFoundException(
                    artifact,
                    repository,
                    artifact
                            + " was not found in " + repository.getUrl()
                            + " during a previous attempt. This failure was"
                            + " cached in the local repository and"
                            + " resolution is not reattempted until the update interval of " + repository.getId()
                            + " has elapsed or updates are forced",
                    true);
        } else {
            return new ArtifactTransferException(
                    artifact,
                    repository,
                    artifact + " failed to transfer from "
                            + repository.getUrl() + " during a previous attempt. This failure"
                            + " was cached in the local repository and"
                            + " resolution is not reattempted until the update interval of " + repository.getId()
                            + " has elapsed or updates are forced. Original error: " + LogSanitizer.sanitize(error),
                    true);
        }
    }

    @Override
    public void checkMetadata(RepositorySystemSession session, UpdateCheck<Metadata, MetadataTransferException> check) {
        requireNonNull(session, "session cannot be null");
        requireNonNull(check, "check cannot be null");
        final String updatePolicy = check.getMetadataPolicy();
        if (check.getLocalLastUpdated() != 0
                && !isUpdatedRequired(session, check.getLocalLastUpdated(), updatePolicy)) {
            LOGGER.debug("Skipped remote request for {} locally installed metadata up-to-date", check.getItem());

            check.setRequired(false);
            return;
        }

        Metadata metadata = check.getItem();
        RemoteRepository repository = check.getRepository();

        Path metadataPath =
                requireNonNull(check.getPath(), String.format("The metadata '%s' has no file attached", metadata));

        boolean fileExists = check.isFileValid() && Files.exists(metadataPath);

        Path touchPath = getMetadataTouchFile(metadataPath);
        Properties props = read(touchPath);

        String updateKey = getUpdateKey(session, metadataPath, repository);
        String dataKey = getDataKey(metadataPath);

        String error = getError(props, dataKey);

        long lastUpdated;
        if (error == null) {
            if (fileExists) {
                // last update was successful
                lastUpdated = getLastUpdated(props, dataKey);
            } else {
                // this is the first attempt ever
                lastUpdated = TS_NEVER;
            }
        } else if (error.isEmpty()) {
            // metadata did not exist
            lastUpdated = getLastUpdated(props, dataKey);
        } else {
            // metadata could not be transferred
            String transferKey = getTransferKey(session, metadataPath, repository);
            lastUpdated = getLastUpdated(props, transferKey);
        }

        if (lastUpdated == TS_NEVER) {
            check.setRequired(true);
        } else if (isAlreadyUpdated(session, updateKey)) {
            LOGGER.debug("Skipped remote request for {}, already updated during this session", check.getItem());

            check.setRequired(false);
            if (error != null) {
                check.setException(newException(error, metadata, repository));
            }
        } else if (isUpdatedRequired(session, lastUpdated, updatePolicy)) {
            check.setRequired(true);
        } else if (fileExists) {
            LOGGER.debug("Skipped remote request for {}, locally cached metadata up-to-date", check.getItem());

            check.setRequired(false);
        } else {
            int errorPolicy = Utils.getPolicy(session, metadata, repository);
            int cacheFlag = getCacheFlag(error);
            if ((errorPolicy & cacheFlag) != 0) {
                check.setRequired(false);
                check.setException(newException(error, metadata, repository));
            } else {
                check.setRequired(true);
            }
        }
    }

    private MetadataTransferException newException(String error, Metadata metadata, RemoteRepository repository) {
        if (error == null || error.isEmpty()) {
            return new MetadataNotFoundException(
                    metadata,
                    repository,
                    metadata + " was not found in "
                            + repository.getUrl() + " during a previous attempt."
                            + " This failure was cached in the local repository and"
                            + " resolution is not be reattempted until the update interval of " + repository.getId()
                            + " has elapsed or updates are forced",
                    true);
        } else {
            return new MetadataTransferException(
                    metadata,
                    repository,
                    metadata + " failed to transfer from "
                            + repository.getUrl() + " during a previous attempt."
                            + " This failure was cached in the local repository and"
                            + " resolution will not be reattempted until the update interval of " + repository.getId()
                            + " has elapsed or updates are forced. Original error: " + LogSanitizer.sanitize(error),
                    true);
        }
    }

    private long getLastUpdated(Properties props, String key) {
        String value = props.getProperty(key + UPDATED_KEY_SUFFIX, "");
        try {
            return (!value.isEmpty()) ? Long.parseLong(value) : TS_UNKNOWN;
        } catch (NumberFormatException e) {
            LOGGER.debug("Cannot parse last updated date {}, ignoring it", value, e);
            return TS_UNKNOWN;
        }
    }

    private String getError(Properties props, String key) {
        return props.getProperty(key + ERROR_KEY_SUFFIX);
    }

    private Path getArtifactTouchFile(Path artifactPath) {
        return artifactPath.getParent().resolve(artifactPath.getFileName() + UPDATED_KEY_SUFFIX);
    }

    private Path getMetadataTouchFile(Path metadataPath) {
        return metadataPath.getParent().resolve("resolver-status.properties");
    }

    private String getDataKey(RemoteRepository repository) {
        Set<String> mirroredUrls = Collections.emptySet();
        if (repository.isRepositoryManager()) {
            mirroredUrls = new TreeSet<>();
            for (RemoteRepository mirroredRepository : repository.getMirroredRepositories()) {
                mirroredUrls.add(normalizeRepoUrl(mirroredRepository.getUrl()));
            }
        }

        StringBuilder buffer = new StringBuilder(1024);

        buffer.append(normalizeRepoUrl(repository.getUrl()));
        for (String mirroredUrl : mirroredUrls) {
            buffer.append('+').append(mirroredUrl);
        }

        return buffer.toString();
    }

    private String getTransferKey(RepositorySystemSession session, RemoteRepository repository) {
        return getRepoKey(session, repository);
    }

    private String getDataKey(Path metadataPath) {
        return metadataPath.getFileName().toString();
    }

    private String getTransferKey(RepositorySystemSession session, Path metadataPath, RemoteRepository repository) {
        return metadataPath.getFileName().toString() + '/' + getRepoKey(session, repository);
    }

    private String getRepoKey(RepositorySystemSession session, RemoteRepository repository) {
        StringBuilder buffer = new StringBuilder(128);

        Proxy proxy = repository.getProxy();
        if (proxy != null) {
            buffer.append(AuthenticationDigest.forProxy(session, repository)).append('@');
            buffer.append(proxy.getHost()).append(':').append(proxy.getPort()).append('>');
        }

        buffer.append(AuthenticationDigest.forRepository(session, repository)).append('@');

        buffer.append(repository.getContentType()).append('-');
        buffer.append(repository.getId()).append('-');
        buffer.append(normalizeRepoUrl(repository.getUrl()));

        return buffer.toString();
    }

    private String normalizeRepoUrl(String url) {
        String result = url;
        if (url != null && !url.isEmpty() && !url.endsWith("/")) {
            result = url + '/';
        }
        return result;
    }

    private String getUpdateKey(RepositorySystemSession session, Path path, RemoteRepository repository) {
        return path.toAbsolutePath() + "|" + getRepoKey(session, repository);
    }

    private int getSessionState(RepositorySystemSession session) {
        String mode = ConfigUtils.getString(session, DEFAULT_SESSION_STATE, CONFIG_PROP_SESSION_STATE);
        if (Boolean.parseBoolean(mode) || "enabled".equalsIgnoreCase(mode)) {
            // perform update check at most once per session, regardless of update policy
            return STATE_ENABLED;
        } else if ("bypass".equalsIgnoreCase(mode)) {
            // evaluate update policy but record update in session to prevent potential future checks
            return STATE_BYPASS;
        } else {
            // no session state at all, always evaluate update policy
            return STATE_DISABLED;
        }
    }

    private boolean isAlreadyUpdated(RepositorySystemSession session, String updateKey) {
        if (getSessionState(session) >= STATE_BYPASS) {
            return false;
        }
        Object checkedFiles = session.getData().get(SESSION_CHECKS);
        if (!(checkedFiles instanceof Map)) {
            return false;
        }
        return ((Map<?, ?>) checkedFiles).containsKey(updateKey);
    }

    @SuppressWarnings("unchecked")
    private void setUpdated(RepositorySystemSession session, String updateKey) {
        if (getSessionState(session) >= STATE_DISABLED) {
            return;
        }
        Object checkedFiles = session.getData().computeIfAbsent(SESSION_CHECKS, () -> new ConcurrentHashMap<>(256));
        ((Map<String, Boolean>) checkedFiles).put(updateKey, Boolean.TRUE);
    }

    private String getNotFoundKey(Path touchPath, String dataKey) {
        return touchPath.toAbsolutePath() + "|" + dataKey;
    }

    /**
     * Records not-found markers written during this session so that an ordinary repository fall-through is not
     * logged as a warning when a sibling repository later provides the artifact.
     */
    @SuppressWarnings("unchecked")
    private void setNotFound(RepositorySystemSession session, String notFoundKey) {
        Object notFounds = session.getData().computeIfAbsent(SESSION_NOT_FOUNDS, ConcurrentHashMap::newKeySet);
        ((Set<String>) notFounds).add(notFoundKey);
    }

    private boolean isNotFoundInSession(RepositorySystemSession session, String notFoundKey) {
        Object notFounds = session.getData().get(SESSION_NOT_FOUNDS);
        return notFounds instanceof Set && ((Set<?>) notFounds).contains(notFoundKey);
    }

    private boolean isUpdatedRequired(RepositorySystemSession session, long lastModified, String policy) {
        return updatePolicyAnalyzer.isUpdatedRequired(session, lastModified, policy);
    }

    private Properties read(Path touchPath) {
        Properties props = trackingFileManager.read(touchPath);
        return (props != null) ? props : new Properties();
    }

    @Override
    public void touchArtifact(RepositorySystemSession session, UpdateCheck<Artifact, ArtifactTransferException> check) {
        requireNonNull(session, "session cannot be null");
        requireNonNull(check, "check cannot be null");
        Path artifactPath = check.getPath();
        Path touchPath = getArtifactTouchFile(artifactPath);

        String updateKey = getUpdateKey(session, artifactPath, check.getRepository());
        String dataKey = getDataKey(check.getAuthoritativeRepository());
        String transferKey = getTransferKey(session, check.getRepository());

        setUpdated(session, updateKey);
        Map<String, String> staleSiblingNotFounds = Collections.emptyMap();
        if (check.getException() == null) {
            staleSiblingNotFounds = getStaleSiblingNotFounds(
                    session, read(touchPath), touchPath, dataKey, check.getItem(), check.getRepository());
        } else if (check.getException() instanceof ArtifactNotFoundException) {
            setNotFound(session, getNotFoundKey(touchPath, dataKey));
        }
        Properties props = write(touchPath, dataKey, transferKey, check.getException(), staleSiblingNotFounds);

        if (Files.exists(artifactPath) && !hasErrors(props)) {
            trackingFileManager.delete(touchPath);
        }
    }

    /**
     * Collects, for removal, cached not-found markers left by other repositories for an artifact that has just
     * been successfully downloaded. A cached not-found silently suppresses any remote contact with the repository
     * that issued it, so a single spoofed or transient "not found" answer would otherwise durably reroute
     * resolution of the artifact to whatever lower-prioritized repository serves it. Expiring the marker forces a
     * confirming re-check of the suppressed repository (subject to the update policy) the next time it is
     * consulted, and the reroute is surfaced at WARN level instead of happening silently. A marker written during
     * the current session is the ordinary fall-through between repositories and is logged at DEBUG instead.
     */
    private Map<String, String> getStaleSiblingNotFounds(
            RepositorySystemSession session,
            Properties props,
            Path touchPath,
            String dataKey,
            Artifact artifact,
            RemoteRepository repository) {
        Map<String, String> removals = null;
        for (Object k : props.keySet()) {
            String key = k.toString();
            if (key.endsWith(ERROR_KEY_SUFFIX)) {
                String otherDataKey = key.substring(0, key.length() - ERROR_KEY_SUFFIX.length());
                if (!otherDataKey.equals(dataKey) && NOT_FOUND.equals(props.getProperty(key))) {
                    if (isNotFoundInSession(session, getNotFoundKey(touchPath, otherDataKey))) {
                        LOGGER.debug(
                                "{} was downloaded from {} after {} answered not-found earlier in this session;"
                                        + " not caching that not-found",
                                artifact,
                                repository.getUrl(),
                                otherDataKey);
                    } else {
                        LOGGER.warn(
                                "{} was downloaded from {} while a not-found cached by a previous session suppresses"
                                        + " re-checking {}; expiring the cached not-found so that repository is"
                                        + " checked again on the next resolution",
                                artifact,
                                repository.getUrl(),
                                otherDataKey);
                    }
                    if (removals == null) {
                        removals = new HashMap<>();
                    }
                    removals.put(key, null);
                    removals.put(otherDataKey + UPDATED_KEY_SUFFIX, null);
                }
            }
        }
        return removals != null ? removals : Collections.emptyMap();
    }

    private boolean hasErrors(Properties props) {
        for (Object key : props.keySet()) {
            if (key.toString().endsWith(ERROR_KEY_SUFFIX)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void touchMetadata(RepositorySystemSession session, UpdateCheck<Metadata, MetadataTransferException> check) {
        requireNonNull(session, "session cannot be null");
        requireNonNull(check, "check cannot be null");
        Path metadataPath = check.getPath();
        Path touchPath = getMetadataTouchFile(metadataPath);

        String updateKey = getUpdateKey(session, metadataPath, check.getRepository());
        String dataKey = getDataKey(metadataPath);
        String transferKey = getTransferKey(session, metadataPath, check.getRepository());

        setUpdated(session, updateKey);
        write(touchPath, dataKey, transferKey, check.getException(), Collections.emptyMap());
    }

    private Properties write(
            Path touchPath, String dataKey, String transferKey, Exception error, Map<String, String> extraUpdates) {
        Map<String, String> updates = new HashMap<>(extraUpdates);

        String timestamp = Long.toString(System.currentTimeMillis());

        if (error == null) {
            updates.put(dataKey + ERROR_KEY_SUFFIX, null);
            updates.put(dataKey + UPDATED_KEY_SUFFIX, timestamp);
            updates.put(transferKey + UPDATED_KEY_SUFFIX, null);
        } else if (error instanceof ArtifactNotFoundException || error instanceof MetadataNotFoundException) {
            updates.put(dataKey + ERROR_KEY_SUFFIX, NOT_FOUND);
            updates.put(dataKey + UPDATED_KEY_SUFFIX, timestamp);
            updates.put(transferKey + UPDATED_KEY_SUFFIX, null);
        } else {
            String msg = error.getMessage();
            if (msg == null || msg.isEmpty()) {
                msg = error.getClass().getSimpleName();
            }
            // transfer error messages may embed remote-derived bytes: neutralize terminal control characters
            // before persisting them, as they are re-read and logged on subsequent update checks
            updates.put(dataKey + ERROR_KEY_SUFFIX, LogSanitizer.sanitize(msg));
            updates.put(dataKey + UPDATED_KEY_SUFFIX, null);
            updates.put(transferKey + UPDATED_KEY_SUFFIX, timestamp);
        }

        return trackingFileManager.update(touchPath, updates);
    }
}