/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed 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 android.databinding

import groovy.io.FileType
import org.apache.maven.repository.internal.MavenRepositorySystemUtils
import org.eclipse.aether.DefaultRepositorySystemSession
import org.eclipse.aether.RepositorySystem
import org.eclipse.aether.RepositorySystemSession
import org.eclipse.aether.artifact.Artifact
import org.eclipse.aether.artifact.DefaultArtifact
import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory
import org.eclipse.aether.graph.Dependency
import org.eclipse.aether.impl.DefaultServiceLocator
import org.eclipse.aether.repository.LocalRepository
import org.eclipse.aether.repository.RemoteRepository
import org.eclipse.aether.resolution.ArtifactDescriptorRequest
import org.eclipse.aether.resolution.ArtifactDescriptorResult
import org.eclipse.aether.resolution.ArtifactRequest
import org.eclipse.aether.spi.connector.RepositoryConnectorFactory
import org.eclipse.aether.spi.connector.transport.TransporterFactory
import org.eclipse.aether.transport.file.FileTransporterFactory
import org.eclipse.aether.transport.http.HttpTransporterFactory
import org.gradle.api.DefaultTask
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.ModuleVersionIdentifier
import org.gradle.api.tasks.TaskAction

class LocalizeDependenciesTask extends DefaultTask {

    private Set<String> ids = new HashSet<>();

    private Set<String> fetchTestDependencies = new HashSet<>();

    List<Artifact> artifactsToResolve = new LinkedList<>();

    Set<String> resolvedArtifacts = new HashSet<>();

    Set<String> failed = new HashSet<>();

    HashMap<String, Object> licenses = new HashMap<>();

    Set<String> missingLicenses = new HashSet<>();

    File localRepoDir;

    @TaskAction
    doIt() {
        println(ids)
        LocalizePluginExtension extension = project.extensions.
                getByName(MavenDependencyCollectorPlugin.EXTENSION_NAME)
        if (extension.localRepoDir == null || extension.otherRepoDirs == null) {
            throw new IllegalArgumentException("you must configure " +
                    "${MavenDependencyCollectorPlugin.EXTENSION_NAME} with localRepoDir and" +
                    " otherRepoDirs")
        }
        localRepoDir = extension.localRepoDir
        downloadAll(extension.localRepoDir, extension.otherRepoDirs)

        if (!missingLicenses.isEmpty()) {
            throw new RuntimeException("Missing licenses for $missingLicenses")
        }
        println("List of new licenses:")
        println(ExportLicensesTask.buildNotice(licenses))
    }

    public void add(MavenDependencyCollectorTask task, ModuleVersionIdentifier id, Configuration conf) {
        def key = toStringIdentifier(id)
        ids.add(key)
        println("adding $key in $conf by $task")
    }

    public static String toStringIdentifier(ModuleVersionIdentifier id) {
        return id.group + ":" + id.name + ":" + id.version;
    }

    private static String artifactKey(Artifact artifact) {
        return artifact.groupId + ":" + artifact.artifactId + ":" + artifact.version;
    }

    public downloadAll(File localRepoDir, List<String> otherRepoDirs) {
        println("downloading all dependencies to $localRepoDir")
        def mavenCentral = new RemoteRepository.Builder("central", "default",
                "http://central.maven.org/maven2/").build();
        def system = newRepositorySystem()
        localRepoDir = localRepoDir.canonicalFile
        List<File> otherRepos = new ArrayList<>()
        otherRepoDirs.each {
            def repo = new File(it).getCanonicalFile()
            if (repo.exists() && !repo.equals(localRepoDir)) {
                otherRepos.add(repo)
            }
        }
        def session = newRepositorySystemSession(system, localRepoDir)
        ids.each {
            def artifact = new DefaultArtifact(it)
            artifactsToResolve.add(artifact)
        }

        while (!artifactsToResolve.isEmpty()) {
            println("remaining artifacts to resolve ${artifactsToResolve.size()}")
            Artifact artifact = artifactsToResolve.remove(0)
            println("    handling artifact ${artifact.getArtifactId()}")
            if (shouldSkip(artifact, otherRepos)) {
                println("skipping $artifact")
                continue
            }
            resolveArtifactWithDependencies(system, session, Arrays.asList(mavenCentral), artifact);
        }
    }

    public static boolean shouldSkip(Artifact artifact, List<File> otherRepos) {
        if (artifact.groupId.startsWith('com.android.databinding') ||
                artifact.groupId.startsWith('com.android.support') ||
                artifact.groupId.equals("jdk")){
            return true
        }
        String targetPath = artifact.groupId.replaceAll("\\.", "/") + "/" + artifact.artifactId +
                "/" + artifact.version
        for (File repo : otherRepos) {
            File f = new File(repo, targetPath)
            if (f.exists()) {
                println("skipping ${artifact} because it exists in $repo")
                return true
            }
        }
        return false
    }

    def boolean isInGit(File file) {
        if (!file.getCanonicalPath().startsWith(localRepoDir.getCanonicalPath())) {
            println("$file is in another git repo, ignore for license")
            return false
        }
        def gitSt = ["git", "status", "--porcelain", file.getCanonicalPath()].
                execute([], localRepoDir)
        gitSt.waitFor()
        if (gitSt.exitValue() != 0) {
            throw new RuntimeException("unable to get git status for $file. ${gitSt.err.text}")
        }
        return gitSt.text.trim().isEmpty()
    }

    public void resolveArtifactWithDependencies(RepositorySystem system,
            RepositorySystemSession session, List<RemoteRepository> remoteRepositories,
            Artifact artifact) {
        def key = artifactKey(artifact)
        if (resolvedArtifacts.contains(key) || failed.contains(key)) {
            return
        }
        resolvedArtifacts.add(key)
        ArtifactRequest artifactRequest = new ArtifactRequest();
        artifactRequest.setArtifact(artifact);
        artifactRequest.setRepositories(remoteRepositories);
        def resolved;
        try {
            resolved = system.resolveArtifact(session, artifactRequest);
        } catch (Throwable ignored) {
            println("cannot find $key, skipping")
            failed.add(key)
            return
        }
        def alreadyInGit = isInGit(resolved.artifact.file)
        println("         |-> resolved ${resolved.artifact.file}. Already in git? $alreadyInGit")


        if (!alreadyInGit) {
            def license = ExportLicensesTask.findLicenseFor(resolved.artifact.artifactId)
            if (license == null) {
                missingLicenses.add(artifactKey(artifact))
            } else {
                licenses.put(resolved.artifact.artifactId, license)
            }
        }

        ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
        descriptorRequest.setArtifact(artifact);
        descriptorRequest.setRepositories(remoteRepositories);

        ArtifactDescriptorResult descriptorResult = system.
                readArtifactDescriptor(session, descriptorRequest);
        for (Dependency dependency : descriptorResult.getDependencies()) {
            println("dependency $dependency for $artifact . scope: ${dependency.scope}")
            if ("provided".equals(dependency.scope)) {
                println("skipping $dependency because provided")
                continue
            }
            if ("optional".equals(dependency.scope)) {
                println("skipping $dependency because optional")
                continue
            }
            if ("test".equals(dependency.scope)) {
                if (fetchTestDependencies.contains(key)) {
                    println("${dependency} is test scope but including because $key is in direct dependencies")
                } else {
                    println("skipping $dependency because test and not first level dependency")
                    continue
                }
            }


            def dependencyKey = artifactKey(dependency.artifact)
            if (resolvedArtifacts.contains(dependencyKey)) {
                println("skipping $dependency because is already resolved as ${dependencyKey}")
                continue
            }
            println("adding to the list ${dependency.artifact}")
            artifactsToResolve.add(dependency.artifact)
        }
        File unwanted = new File(resolved.artifact.file.getParentFile(), "_remote.repositories")
        if (unwanted.exists()) {
            unwanted.delete()
        }
    }

    public static DefaultRepositorySystemSession newRepositorySystemSession(RepositorySystem system,
            File localRepoDir) {
        DefaultRepositorySystemSession session = MavenRepositorySystemUtils.newSession();
        LocalRepository localRepo = new LocalRepository(localRepoDir);
        session.setLocalRepositoryManager(system.newLocalRepositoryManager(session, localRepo));
        return session;
    }

    public static RepositorySystem newRepositorySystem() {
        DefaultServiceLocator locator = MavenRepositorySystemUtils.newServiceLocator();
        locator.addService(RepositoryConnectorFactory.class, BasicRepositoryConnectorFactory.class);
        locator.addService(TransporterFactory.class, FileTransporterFactory.class);
        locator.addService(TransporterFactory.class, HttpTransporterFactory.class);

        return locator.getService(RepositorySystem.class);
    }
}