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

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.Set;

import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.metadata.Metadata;
import org.eclipse.aether.repository.LocalArtifactRegistration;
import org.eclipse.aether.repository.LocalArtifactRequest;
import org.eclipse.aether.repository.LocalArtifactResult;
import org.eclipse.aether.repository.LocalMetadataRegistration;
import org.eclipse.aether.repository.LocalMetadataRequest;
import org.eclipse.aether.repository.LocalMetadataResult;
import org.eclipse.aether.repository.LocalRepository;
import org.eclipse.aether.repository.LocalRepositoryManager;
import org.eclipse.aether.repository.RemoteRepository;

import static java.util.Objects.requireNonNull;

/**
 * A simplistic local repository manager that uses a temporary base directory.
 */
public class TestLocalRepositoryManager implements LocalRepositoryManager {

    private LocalRepository localRepository;

    private final Set<Artifact> unavailableArtifacts = new HashSet<>();

    private final Set<Artifact> artifactRegistrations = new HashSet<>();

    private final Set<Metadata> metadataRegistrations = new HashSet<>();

    public TestLocalRepositoryManager() {
        try {
            Path tempDirectory = Files.createTempDirectory("test-local-repo");
            tempDirectory.toFile().deleteOnExit();
            localRepository = new LocalRepository(tempDirectory);
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

    public LocalRepository getRepository() {
        return localRepository;
    }

    public String getPathForLocalArtifact(Artifact artifact) {
        requireNonNull(artifact, "artifact cannot be null");

        String artifactId = artifact.getArtifactId();
        String groupId = artifact.getGroupId();
        String extension = artifact.getExtension();
        String version = artifact.getVersion();
        String classifier = artifact.getClassifier();

        return String.format(
                "%s/%s/%s/%s-%s-%s%s.%s",
                groupId, artifactId, version, groupId, artifactId, version, classifier, extension);
    }

    public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
        requireNonNull(artifact, "artifact cannot be null");
        requireNonNull(repository, "repository cannot be null");

        return getPathForLocalArtifact(artifact);
    }

    public String getPathForLocalMetadata(Metadata metadata) {
        requireNonNull(metadata, "metadata cannot be null");

        String artifactId = metadata.getArtifactId();
        String groupId = metadata.getGroupId();
        String version = metadata.getVersion();
        return String.format("%s/%s/%s/%s-%s-%s.xml", groupId, artifactId, version, groupId, artifactId, version);
    }

    public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
        requireNonNull(metadata, "metadata cannot be null");
        requireNonNull(repository, "repository cannot be null");

        return getPathForLocalMetadata(metadata);
    }

    public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
        requireNonNull(session, "session cannot be null");
        requireNonNull(request, "request cannot be null");

        Artifact artifact = request.getArtifact();

        LocalArtifactResult result = new LocalArtifactResult(request);
        File file = new File(localRepository.getBasedir(), getPathForLocalArtifact(artifact));
        result.setFile(file.isFile() ? file : null);
        result.setAvailable(file.isFile() && !unavailableArtifacts.contains(artifact));

        return result;
    }

    public void add(RepositorySystemSession session, LocalArtifactRegistration request) {
        requireNonNull(session, "session cannot be null");
        requireNonNull(request, "request cannot be null");

        artifactRegistrations.add(request.getArtifact());
    }

    public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
        requireNonNull(session, "session cannot be null");
        requireNonNull(request, "request cannot be null");

        Metadata metadata = request.getMetadata();

        LocalMetadataResult result = new LocalMetadataResult(request);
        File file = new File(localRepository.getBasedir(), getPathForLocalMetadata(metadata));
        result.setFile(file.isFile() ? file : null);

        return result;
    }

    public void add(RepositorySystemSession session, LocalMetadataRegistration request) {
        requireNonNull(session, "session cannot be null");
        requireNonNull(request, "request cannot be null");

        metadataRegistrations.add(request.getMetadata());
    }

    public Set<Artifact> getArtifactRegistration() {
        return artifactRegistrations;
    }

    public Set<Metadata> getMetadataRegistration() {
        return metadataRegistrations;
    }

    public void setArtifactAvailability(Artifact artifact, boolean available) {
        if (available) {
            unavailableArtifacts.remove(artifact);
        } else {
            unavailableArtifacts.add(artifact);
        }
    }
}
