/*
 1. add
    signing.keyId=xx
    signing.password=xx
    signing.secretKeyRingFile=/Users/xx/secring.gpg
    ossrhUsername=xx
    ossrhPassword=xx
    in root local.properties

 2. copy the file to the directory of gradle, and apply the file in the module
 ext {
    groupId = Config.modules.lib_utilcode.groupId
    artifactId = Config.modules.lib_utilcode.artifactId
    version = Config.modules.lib_utilcode.version
    website = "https://github.com/Blankj/AndroidUtilCode"
}
 apply from: "${rootDir.path}/config/publish.gradle"

 3. execute following command to publish
 ./gradlew :xxmodule:publish2Local  -> upload to mavenLocal
 ./gradlew :xxmodule:publish2Remote -> upload to mavenCentral
*/

apply plugin: 'maven-publish'
apply plugin: 'signing'

ext.multiPublishMode = true

File localPropertiesFile = project.rootProject.file("local.properties");
if (!localPropertiesFile.exists()) {
    return
}

Properties properties = new Properties()
properties.load(new FileInputStream(localPropertiesFile))
properties.each { name, value -> ext[name] = value }

afterEvaluate {
    def ext = project.ext
    publishing {
        publications {
            release(MavenPublication) {
                groupId ext.groupId
                artifactId ext.artifactId
                version ext.version

                if (isAndroidEnv(project)) {
                    if (project.ext.multiPublishMode) {
                        artifact("$buildDir/outputs/aar/${project.getName()}-release.aar")
                        artifact sourcesJar
                    } else {
                        from project.components.release
                    }
                } else {
                    from project.components.java
                }

                pom {
                    name = ext.artifactId
                    description = ext.artifactId
                    url = ext.website

                    licenses {
                        license {
                            name = 'The Apache Software License, Version 2.0'
                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }
                    developers {
                        developer {
                            id = ext.ossrhUsername
                            name = ext.ossrhUsername
                        }
                    }
                    scm {
                        url = ext.website
                        connection = ext.website
                        developerConnection = ext.website + ".git"
                    }

                    if (project.ext.multiPublishMode) {
                        withXml {
                            def dependenciesNode = asNode().getAt('dependencies')[0] ?:
                                    asNode().appendNode('dependencies')

                            configurations.api.getDependencies().each {
                                dep -> addDependency(project, dependenciesNode, dep, "compile")
                            }
                            configurations.implementation.getDependencies().each {
                                dep -> addDependency(project, dependenciesNode, dep, "runtime")
                            }
                        }
                    }
                }
            }
        }

        repositories {
            maven {
                // s01 is newest
                def releasesUrl = "https://s01.oss.sonatype.org/content/repositories/releases/"
                def snapshotUrl = "https://s01.oss.sonatype.org/content/repositories/snapshots/"
                url = version.toUpperCase().endsWith('SNAPSHOT') ? snapshotUrl : releasesUrl

                credentials {
                    username ossrhUsername
                    password ossrhPassword
                }
            }
        }
    }

    signing {
        sign publishing.publications
    }
}

private void addDependency(Project project, def dependenciesNode, Dependency dep, String scope) {
    if (dep.group == null || dep.version == null || dep.name == null || dep.name == "unspecified") {
        return
    }

    final dependencyNode = dependenciesNode.appendNode('dependency')
    dependencyNode.appendNode('scope', scope)

    if (dep.version == 'unspecified') {
        // 检测 module 中的 dependencies 是否有源码依赖
        // 如果是源码依赖，而且没有在 config 中配置 remotePath，
        // 那么发布到仓库，其他地方依赖该库时会找不到源码的那个库
        println "publish -> module(unspecified) <${dep.group}:${dep.name}:${dep.version}>"
        if (project.ext.groupId || project.ext.version) {
            throw new GradleException("The module of <" + dep.name + "> should set groupId & version.")
        }
        // 源码依赖，但配置了 remotePath，让 pom 中写入 remotePath
        println("publish -> module(wrapped) <${project.ext.groupId}:${name}:${project.ext.version}>")

        dependencyNode.appendNode('groupId', project.ext.pomGroupID)
        dependencyNode.appendNode('artifactId', dep.name)
        dependencyNode.appendNode('version', project.ext.pomVersion)
    } else {
        dependencyNode.appendNode('groupId', dep.group)
        dependencyNode.appendNode('artifactId', dep.name)
        dependencyNode.appendNode('version', dep.version)
        println("publish -> library <${dep.group}:${dep.name}:${dep.version}>")
    }

    if (!dep.transitive) {
        // In case of non transitive dependency,
        // all its dependencies should be force excluded from them POM file
        final exclusionNode = dependencyNode.appendNode('exclusions').appendNode('exclusion')
        exclusionNode.appendNode('groupId', '*')
        exclusionNode.appendNode('artifactId', '*')
    } else if (!dep.properties.excludeRules.empty) {
        // For transitive with exclusions, all exclude rules should be added to the POM file
        final exclusions = dependencyNode.appendNode('exclusions')
        dep.properties.excludeRules.each { ExcludeRule rule ->
            final exclusionNode = exclusions.appendNode('exclusion')
            exclusionNode.appendNode('groupId', rule.group ?: '*')
            exclusionNode.appendNode('artifactId', rule.module ?: '*')
        }
    }
}

if (isAndroidEnv(project)) {
    // This generates sources.jar
    task sourcesJar(type: Jar) {
        classifier = 'sources'
        from android.sourceSets.main.java.source
    }

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

    task javadocJar(type: Jar, dependsOn: javadoc) {
        classifier = 'javadoc'
        from javadoc.destinationDir
    }
} else {
    task sourcesJar(type: Jar, dependsOn: classes) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

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

if (project.hasProperty("kotlin")) {
    // Disable creating javadocs
    project.tasks.withType(Javadoc) {
        enabled = false
    }
}

javadoc {
    options {
        encoding "UTF-8"
        charSet 'UTF-8'
        author true
        version project.ext.version
        links "http://docs.oracle.com/javase/7/docs/api"
        title "${project.ext.artifactId} ${project.ext.version}"
    }
}

artifacts {
    archives javadocJar
    archives sourcesJar
}

static def isAndroidEnv(Project project) {
    return project.getPlugins().hasPlugin('com.android.application') || project.getPlugins().hasPlugin('com.android.library')
}

task publish2Local(type: GradleBuild) {
    tasks = ['assemble', 'publishReleasePublicationToMavenLocal']
}

task publish2Remote(type: GradleBuild) {
    tasks = ['assemble', 'publishReleasePublicationToMavenRepository']
}