/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

def libLicense = properties.libLicense
def libLicenseUrl = properties.libLicenseUrl
def libRepositoryName = properties.libRepositoryName
def libProjectName = properties.libProjectName
def libUrl = properties.libUrl
def libVcsUrl = properties.libVcsUrl

static def getLocalPublicationTimestamp() {
    def date = new Date()
    return date.format('yyyyMMddHHmmss')
}

// `jnaForTestConfiguration` is a hacky way to say yes, I'm using JNA and want
// to pack the JNA dispatch libraries and my Rust libraries into a single JAR
// for use in unit tests that run on a development host (and not an Android
// target device).  We extract the JNA libraries and our local Rust libraries
// and stick them into a JAR that consumers augment their test configuration
// with.
//
// It's only used for megazords, for which it's required. Passing it in for a
// non-megazord is allowed, but will trigger a warning.
ext.configurePublish = { jnaForTestConfiguration = null ->
    def theGroupId = rootProject.ext.library.groupId
    def theArtifactId = project.ext.artifactId
    def theDescription = project.ext.description

    // This is a little cludgey, but it seems unlikely to cause a problem, and
    // we are already doing it inside taskcluster.
    def isMegazord = theArtifactId.endsWith("-megazord")

    // Do some sanity checks. The following properties should either all be
    // true, or none of them should be true:
    // - We're a megazord
    // - jnaForTestConfiguration was provided
    // - we should have 2 publish artifacts, [project, project-forUnitTests]
    if (isMegazord != (jnaForTestConfiguration != null)) {
        throw new GradleException("ext.configurePublish needs a `jnaForTestConfiguration` iff the project is a megazord")
    }

    if (isMegazord) {
        task extractJnaResources(type: Sync) {
            dependsOn jnaForTestConfiguration

            from {
                // Defer the resolution of the configuration.  This helps to
                // avoid a nasty issue with the Android-Gradle plugin 3.2.1,
                // like `Cannot change attributes of configuration
                // ':PROJECT:kapt' after it has been resolved`.
                zipTree(jnaForTestConfiguration.singleFile)
            }

            into "${buildDir}/jnaResources/"

            eachFile { FileCopyDetails fcp ->
                // The intention is to just keep the various `*jnidispatch.*` files.
                if (fcp.relativePath.pathString.startsWith("META-INFO") || fcp.relativePath.pathString.endsWith(".class")) {
                    fcp.exclude()
                }
            }

            includeEmptyDirs false
        }

        def forUnitTestsJarTask = task forUnitTestsJar(type: Jar) {
            from extractJnaResources
            from "$buildDir/rustJniLibs/desktop"
        }

        project.afterEvaluate {
            forUnitTestsJarTask.dependsOn(tasks["cargoBuild"])
        }
    }

    task sourcesJar(type: Jar) {
        from android.sourceSets.main.java.srcDirs
        classifier = 'sources'
    }

    task javadoc(type: Javadoc) {
        source = android.sourceSets.main.java.srcDirs
        classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        classifier = 'javadoc'
        from javadoc.destinationDir
    }

    publishing {
        publications {
            aar(MavenPublication) {
                project.afterEvaluate {
                    from components.findByName("androidRelease")
                }
                artifact sourcesJar
                // Can't publish Javadoc yet: fxaclient isn't well behaved.
                // artifact javadocJar

                if (isMegazord) {
                    artifact file("${projectDir}/../DEPENDENCIES.md"), {
                        extension "LICENSES.md"
                    }
                }

                // If this goes haywire with
                // 'Cannot configure the 'publishing' extension after it has been accessed.',
                // see https://github.com/researchgate/gradle-release/issues/125 and
                // https://stackoverflow.com/q/28020520.
                pom {
                    groupId = theGroupId
                    artifactId = theArtifactId
                    description = theDescription
                    // For mavenLocal publishing workflow, increment the version number every publish.
                    // We only do this to the .pom file and not in $MEGAZORD_VERSION, because otherwise we
                    // would need to rebuild the megazord .so on every publish, even if nothing else had changed.
                    version = rootProject.ext.library.version + (rootProject.hasProperty('local') ? '-' + getLocalPublicationTimestamp() : '')
                    packaging = "aar"

                    license {
                        name = libLicense
                        url = libLicenseUrl
                    }

                    // Megazords include compiled code from third-party rust dependencies.
                    // We add the license info of those dependencies to the .pom to make it
                    // easy for consumers to incorporate into their license info page.
                    if (isMegazord) {
                        def depLicenses = new XmlSlurper().parse(new File("${projectDir}/dependency-licenses.xml"))
                        depLicenses.license.each { node ->
                            license {
                                name = node.name.text()
                                url = node.url.text()
                            }
                        }
                    }

                    developers {
                        developer {
                            name = 'Mozilla Application Services'
                            email = 'application-services@mozilla.com'
                        }
                    }

                    scm {
                        connection = libVcsUrl
                        developerConnection = libVcsUrl
                        url = libUrl
                    }
                }
            }

            if (isMegazord) {
                forUnitTestsJar(MavenPublication) {
                    artifact tasks['forUnitTestsJar']
                    artifact file("${projectDir}/../DEPENDENCIES.md"), {
                        extension "LICENSES.md"
                    }
                    pom {
                        groupId = theGroupId
                        artifactId = "${theArtifactId}-forUnitTests"
                        description = theDescription
                        // For mavenLocal publishing workflow, increment the version number every publish.
                        version = rootProject.ext.library.version + (rootProject.hasProperty('local') ? '-' + getLocalPublicationTimestamp() : '')
                        packaging = "jar"

                        licenses {
                            license {
                                name = libLicense
                                url = libLicenseUrl
                            }
                        }

                        developers {
                            developer {
                                name = 'Mozilla Application Services'
                                email = 'application-services@mozilla.com'
                            }
                        }

                        scm {
                            connection = libVcsUrl
                            developerConnection = libVcsUrl
                            url = libUrl
                        }
                    }

                    // This is never the publication we want to use when publishing a
                    // parent project with us as a child `project()` dependency.
                    alias = true
                }
            }
        }
    }

    task checkMavenArtifacts

    publishing.publications.withType(MavenPublication).each {publication ->
        def checkFileSizeTask = task "checkLibSizeForMavenArtifact-${publication.artifactId}"(type: Exec) {
            commandLine "${rootProject.projectDir}/automation/check_artifact_size.sh", project.buildDir, publication.artifactId
        }
        checkMavenArtifacts.dependsOn(checkFileSizeTask)
    }
}