/*
 *  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.
 */

boolean isUsingArtifactory = rootProject.hasProperty('artifactoryUser') && rootProject.artifactoryUser &&
        rootProject.hasProperty('artifactoryPassword') && rootProject.artifactoryPassword

if (isUsingArtifactory) {
    logger.lifecycle 'Deployment environment set to Artifactory'
}

def embedded = ['asm', 'asm-util', 'asm-analysis', 'asm-tree', 'asm-commons', 'antlr', 'commons-cli', 'openbeans']
def removeJarjaredDependencies = { p ->
    p.dependencies.removeAll(p.dependencies.findAll {
        it.groupId == 'org.codehaus.groovy' || embedded.contains(it.artifactId)
    })
}

allprojects {
    if (project == rootProject || modules().contains(project)) {
        apply plugin: 'maven'
        apply from: "${rootProject.projectDir}/gradle/pomconfigurer.gradle"
        install.dependsOn checkCompatibility
    }
}

apply from: 'gradle/backports.gradle'

ext.basename = { String s -> s.take(s.lastIndexOf('.')) }
ext.deriveFile = { File archive, String suffix -> new File(archive.parent, basename(archive.name) + "-${suffix}.jar") }

allprojects {
    if (project == rootProject || modules().contains(project)) {
        ext.signWithClassifier = { String c, File f ->
            if (rootProject.isReleaseVersion) {
                signing.sign(c, f)
                def ascFile = new File(f.parent, f.name + '.asc')
                if (ascFile.exists()) {
                    project.artifacts.add('archives', ascFile) {
                        classifier = c
                        type = 'asc'
                        extension = 'jar.asc'
                    }
                }
            }
        }

        ext.signArchiveTask = { archiveTask ->
            if (rootProject.isReleaseVersion) {
                signing.sign(archiveTask.classifier, archiveTask.archivePath)
                def ascFile = new File(archiveTask.destinationDir, archiveTask.archiveName + '.asc')
                if (ascFile.exists()) {
                    project.artifacts.add('archives', ascFile) {
                        name = archiveTask.baseName
                        classifier = archiveTask.classifier
                        type = 'asc'
                        extension = archiveTask.extension + '.asc'
                    }
                }
            }
        }

        uploadArchives {
            repositories {
                mavenDeployer {
                    pom pomConfigureClosure
                    beforeDeployment { MavenDeployment deployment -> if (rootProject.isReleaseVersion) signing.signPom(deployment) }
                }
            }
        }

        install {
            repositories {
                mavenInstaller {
                    pom pomConfigureClosure
                    beforeDeployment { MavenDeployment deployment -> if (rootProject.isReleaseVersion) signing.signPom(deployment) }
                }
            }
        }

        artifacts {
            archives jar
            archives sourceJar
            archives javadocJar
            archives groovydocJar
        }

        [uploadArchives, install]*.with {
            // dependency on jarAllAll should in theory be replaced with jar, jarWithIndy but
            // in practice, it is faster
            dependsOn([jarAllAll, sourceJar, javadocJar, groovydocJar])
            doFirst {
                if (rootProject.useIndy()) {
                    new GradleException('You cannot use uploadArchives or install task with the flag [indy] turned'
                            + ' on because the build handles indy artifacts by itself in that case.')
                }
                def indyJar = rootProject.ext.deriveFile(jar.archivePath, 'indy')
                if (indyJar.exists()) {
                    project.artifacts.add('archives', indyJar)
                }
                def grooidJar = rootProject.ext.deriveFile(jar.archivePath, 'grooid')
                if (grooidJar.exists()) {
                    project.artifacts.add('archives', grooidJar)
                }
            }
        }

        install {
            doFirst {
                // gradle doesn't expect us to mutate configurations like we do here
                // so signing the configuration won't work and we do it manually here
                signArchiveTask(jar)
                signArchiveTask(sourceJar)
                signArchiveTask(javadocJar)
                signArchiveTask(groovydocJar)
                def indyJar = rootProject.ext.deriveFile(jar.archivePath, 'indy')
                if (indyJar.exists()) {
                    signWithClassifier('indy', indyJar)
                }
                def grooidJar = rootProject.ext.deriveFile(jar.archivePath, 'grooid')
                if (grooidJar.exists()) {
                    signWithClassifier('grooid', grooidJar)
                }
            }
        }
    }
}

// the root project generates several alternate artifacts, e.g. 'groovy-all'
// we don't want them in the root project so add them as artifacts with a modified name
// we'll exclude the original artifacts during publication with an exclude pattern
[uploadArchives, install]*.with {
    dependsOn([sourceAllJar, javadocAllJar, groovydocAllJar, distBin, distDoc, dist, distBin])
    doFirst {
        project.artifacts.add('archives', jarAll) {
            name = 'groovy-all'
        }
        project.artifacts.add('archives', sourceAllJar) {
            name = 'groovy-all'
        }
        project.artifacts.add('archives', javadocAllJar) {
            name = 'groovy-all'
        }
        project.artifacts.add('archives', groovydocAllJar) {
            name = 'groovy-all'
        }
        project.artifacts.add('archives', distBin) {
            name = 'groovy-binary'
        }
        signArchiveTask(jarAll)
        signArchiveTask(sourceAllJar)
        signArchiveTask(javadocAllJar)
        signArchiveTask(groovydocAllJar)

        // TODO rework these?
        if (isReleaseVersion) {
            signing.sign(distBin.archivePath)
            def ascFile = new File(distBin.destinationDir, distBin.archiveName + '.asc')
            if (ascFile.exists()) {
                project.artifacts.add('archives', ascFile) {
                    name = 'groovy-binary'
                    type = 'asc'
                    extension = 'zip.asc'
                }
            }
            signing.sign(distSrc.archivePath)
            signing.sign(distDoc.archivePath)
            signing.sign(dist.archivePath)
        }

        tasks.withType(Jar).matching { it.name.startsWith('backport') }.each { t ->
            project.artifacts.add('archives', t.archivePath) {
                name = t.baseName
                type = 'jar'
                classifier = t.classifier
            }
            if (isReleaseVersion) {
                signing.sign(t.classifier, t.archivePath)
                def ascFile = new File(t.destinationDir, t.archiveName + '.asc')
                if (ascFile.exists()) {
                    project.artifacts.add('archives', ascFile) {
                        name = t.baseName
                        classifier = t.classifier
                        type = 'asc'
                        extension = t.extension + '.asc'
                    }
                }
            }
        }

        def indyJar = deriveFile(jarAll.archivePath, 'indy')
        if (indyJar.exists()) {
            project.artifacts.add('archives', indyJar)
            signWithClassifier('indy', indyJar)
        }
        def grooidJar = deriveFile(jarAll.archivePath, 'grooid')
        if (grooidJar.exists()) {
            project.artifacts.add('archives', grooidJar)
            signWithClassifier('grooid', grooidJar)
        }
    }
}

ext.pomAll = {
    addFilter('groovy') { artifact, file ->
        !(artifact.name.contains('groovy-all')) &&
                !(artifact.name.contains('groovy-binary')) &&
                !(artifact.name.contains('backport'))
    }
    addFilter('all') { artifact, file ->
        artifact.name.contains('groovy-all')
    }
    addFilter('binary') { artifact, file ->
        artifact.name.contains('groovy-binary')
    }
    project.backports.each { pkg, classes ->
        addFilter("backports-$pkg") { artifact, file ->
            artifact.name == "groovy-backports-$pkg"
        }
    }

    // regular pom
    def groovypom = pom('groovy', pomConfigureClosure)

    // pom for 'all'
    def allpom = pom('all', pomConfigureClosure)
    allpom.artifactId = 'groovy-all'

    // pom for binary zip
    def binarypom = pom('binary', pomConfigureClosureWithoutTweaks)
    binarypom.artifactId = 'groovy-binary'

    // poms for backports
    project.backports.each { pkg, classes ->
        String id = "backports-$pkg"
        def backportPom = pom(id, pomConfigureClosureWithoutTweaks)
        backportPom.artifactId = "groovy-$id"
        backportPom.whenConfigured { p ->
            p.dependencies.clear()
        }
    }

    modules().each { sp ->
        sp.install.repositories.mavenInstaller.pom.whenConfigured { subpom ->
            // add dependencies of other modules
            allpom.dependencies.addAll(subpom.dependencies)
        }
        sp.uploadArchives.repositories.mavenDeployer.pom.whenConfigured { subpom ->
            // add dependencies of other modules
            allpom.dependencies.addAll(subpom.dependencies)
        }
    }


    groovypom.whenConfigured(removeJarjaredDependencies)
    allpom.whenConfigured(removeJarjaredDependencies)

    binarypom.whenConfigured { p ->
        p.dependencies.clear()
    }

    beforeDeployment { MavenDeployment deployment -> if (isReleaseVersion) signing.signPom(deployment) }
}

install {
    // make sure dependencies poms are built *before* the all pom
    dependsOn(modules()*.install)
    repositories {
        mavenInstaller pomAll
    }
}

uploadArchives {
    // make sure dependencies poms are built *before* the all pom
    dependsOn(modules()*.uploadArchives)
    repositories {
        mavenDeployer pomAll
    }
}