/*
 *    Copyright 2019 Ugljesa Jovanovic
 *
 *    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.
 *
 */

@file:Suppress("UnstableApiUsage")
import org.jetbrains.kotlin.gradle.targets.native.tasks.KotlinNativeTest
import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest

plugins {
    kotlin(PluginsDeps.multiplatform)
    id(PluginsDeps.mavenPublish)
    id(PluginsDeps.signing)
    id(PluginsDeps.node) version Versions.nodePlugin
    id(PluginsDeps.dokka) version Versions.dokkaPlugin
}

val sonatypeStaging = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
val sonatypeSnapshots = "https://oss.sonatype.org/content/repositories/snapshots/"

val sonatypePassword: String? by project

val sonatypeUsername: String? by project

val sonatypePasswordEnv: String? = System.getenv()["SONATYPE_PASSWORD"]
val sonatypeUsernameEnv: String? = System.getenv()["SONATYPE_USERNAME"]

repositories {
    mavenCentral()
    jcenter()

}
group = ReleaseInfo.group
version = ReleaseInfo.version

val ideaActive = System.getProperty("idea.active") == "true"

kotlin {
    val hostOsName = getHostOsName()
    runningOnLinuxx86_64 {
        jvm()
        js {
            //Until I figure out how to run headless chrome on travis
//        browser {
//
//            testTask {
//                useKarma {
//                    useChrome()
//                }
//            }
//        }
            nodejs {
                testTask {
                    useMocha() {
                        timeout = "10s"
                    }
                }
            }

        }
        linuxX64("linux") {
            binaries {
                staticLib {
                    optimized = true
                }
            }
        }



    }

    runningOnLinuxArm32 {
        //        Not supported in coroutines at the moment
        linuxArm32Hfp() {
            binaries {
                staticLib {
                }
            }
        }
    }

    runningOnLinuxArm64 {
        //        Not supported in coroutines at the moment
        linuxArm64() {
            binaries {
                staticLib {
                }
            }
        }
    }

    runningOnMacos {
        iosX64("ios") {
            binaries {
                framework {
                    optimized = true
                }
            }
        }
        iosArm64("ios64Arm") {
            binaries {
                framework {
                    optimized = true
                }
            }
        }

        iosArm32("ios32Arm") {
            binaries {
                framework {
                    optimized = true
                }
            }
        }
        macosX64() {
            binaries {
                framework {
                    optimized = true
                }
            }
        }
    }
    runningOnWindows {

        mingwX64() {
            binaries {
                staticLib {
                    optimized = true
                }
            }
        }
    }
// No coroutines support for mingwX86
//    mingwX86() {
//        binaries {
//            staticLib {
//
//            }
//        }
//    }


    println(targets.names)

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(kotlin(Deps.Common.stdLib))
                implementation(kotlin(Deps.Common.test))
                implementation(Deps.Common.coroutines)
                implementation(Deps.Common.kotlinBigNum)
                implementation(project(Deps.Common.apiProject))
            }
        }
        val commonTest by getting {
            dependencies {
                implementation(kotlin(Deps.Common.test))
                implementation(kotlin(Deps.Common.testAnnotation))
            }
        }


        val nativeMain by creating {
            dependsOn(commonMain)
            dependencies {
                implementation(Deps.Native.coroutines)
            }
        }


        val nativeTest by creating {
            dependsOn(commonTest)
            dependencies {
                implementation(Deps.Native.coroutines)
            }
        }

        targets.withType<org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget> {
            compilations.getByName("main") {
                println("Setting native sourceset dependancy for $name")
                if ((this@withType.name.contains("ios") ||
                            this@withType.name.contains("mingw")).not()
                ) {
                    println("Setting native sourceset dependancy for $this@withType.name")
                    defaultSourceSet.dependsOn(nativeMain)
                }
            }
            compilations.getByName("test") {
                println("Setting native sourceset dependancy for $name")
                if ((this@withType.name.contains("ios") ||
                            this@withType.name.contains("mingw")).not()
                ) {
                    println("Setting native sourceset dependancy for $this@withType.name")
                    defaultSourceSet.dependsOn(nativeTest)
                }
            }
        }



        runningOnLinuxx86_64 {
            val jvmMain by getting {
                dependencies {
                    implementation(kotlin(Deps.Jvm.stdLib))
                    implementation(kotlin(Deps.Jvm.test))
                    implementation(kotlin(Deps.Jvm.testJUnit))
                    implementation(Deps.Jvm.coroutinesCore)
                }
            }
            val jvmTest by getting {
                dependencies {
                    implementation(kotlin(Deps.Jvm.test))
                    implementation(kotlin(Deps.Jvm.testJUnit))
                    implementation(Deps.Jvm.coroutinesTest)
                    implementation(kotlin(Deps.Jvm.reflection))
                }
            }
            val jsMain by getting {
                dependencies {
                    implementation(kotlin(Deps.Js.stdLib))
                    implementation(Deps.Js.coroutines)
                }
            }
            val jsTest by getting {
                dependencies {
                    implementation(Deps.Js.coroutines)
                    implementation(kotlin(Deps.Js.test))
                }
            }
            val linuxMain by getting {
                dependsOn(nativeMain)
                //Force idea to consider native sourceset
                if (ideaActive) {
                    kotlin.srcDir("src/nativeMain/kotlin")
                }
            }
            val linuxTest by getting {
                dependsOn(nativeTest)
                //Force idea to consider native sourceset
                if (ideaActive) {
                    kotlin.srcDir("src/nativeTest/kotlin")
                }
            }

        }

        runningOnLinuxArm64 {
            //Not supported in OFFICIAL coroutines at the moment, we're running a custom build
            val linuxArm64Main by getting {
                dependsOn(nativeMain)
            }

            val linuxArm64Test by getting {
                dependsOn(nativeTest)
            }

        }

        runningOnLinuxArm32 {
            val linuxArm32HfpMain by getting {
                dependsOn(nativeMain)
            }

            val linuxArm32HfpTest by getting {
                dependsOn(nativeTest)
            }
        }

        runningOnMacos{

            val iosMain by getting {
                dependsOn(nativeMain)
            }
            val iosTest by getting {
                dependsOn(nativeTest)
            }

            val ios64ArmMain by getting {
                dependsOn(nativeMain)
            }
            val ios64ArmTest by getting {
                dependsOn(nativeTest)
            }

            val ios32ArmMain by getting {
                dependsOn(nativeMain)
            }
            val ios32ArmTest by getting {
                dependsOn(nativeTest)
            }

            val macosX64Main by getting {
                dependsOn(commonMain)
                if (ideaActive) {
                    kotlin.srcDir("src/nativeMain/kotlin")
                }
            }
            val macosX64Test by getting {
                dependsOn(commonTest)
                if (ideaActive) {
                    kotlin.srcDir("src/nativeTest/kotlin")
                }
            }
        }

//      Coroutines don't support mingwx86 yet
//        val mingwX86Main by getting {
//            dependsOn(commonMain)
//            dependencies {
//                implementation(Deps.Native.coroutines)
//            }
//        }

//        val mingwX86Test by getting {
//            dependsOn(commonTest)
//        }
//
        runningOnWindows {
            val mingwX64Main by getting {
                dependsOn(commonMain)
                dependencies {
                    implementation(Deps.Native.coroutines)
                }
            }

            val mingwX64Test by getting {
                dependsOn(commonTest)
            }
        }


        all {
            languageSettings.enableLanguageFeature("InlineClasses")
            languageSettings.useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
            languageSettings.useExperimentalAnnotation("kotlin.ExperimentalStdlibApi")
        }
    }


}



task<Copy>("copyPackageJson") {
    dependsOn("compileKotlinJs")
    println("Copying package.json from $projectDir/core/src/jsMain/npm")
    from("$projectDir/src/jsMain/npm")
    println("Node modules dir ${node.nodeModulesDir}")
    into("${node.nodeModulesDir}")
}

tasks {


    create<Jar>("javadocJar") {
        dependsOn(dokka)
        archiveClassifier.set("javadoc")
        from(dokka.get().outputDirectory)
    }

    dokka {
        println("Dokka !")
        impliedPlatforms = mutableListOf("Common")
        kotlinTasks {
            listOf()
        }
        sourceRoot {
            println("Common !")
            path =
                "/home/ionspin/Projects/Future/kotlin-multiplatform-crypto/crypto/src/commonMain" //TODO remove static path!
            platforms = listOf("Common")
        }
    }
    if (getHostOsName() == "linux" && getHostArchitecture() == "x86-64") {

        val jvmTest by getting(Test::class) {
            testLogging {
                events("PASSED", "FAILED", "SKIPPED")
            }
        }

        val linuxTest by getting(KotlinNativeTest::class) {

            testLogging {
                events("PASSED", "FAILED", "SKIPPED")
// showStandardStreams = true
            }
        }

        val jsNodeTest by getting(KotlinJsTest::class) {
            testLogging {
                events("PASSED", "FAILED", "SKIPPED")
                showStandardStreams = true
            }
        }

//        val legacyjsNodeTest by getting(KotlinJsTest::class) {
//
//            testLogging {
//                events("PASSED", "FAILED", "SKIPPED")
//                showStandardStreams = true
//            }
//        }

//        val jsIrBrowserTest by getting(KotlinJsTest::class) {
//            testLogging {
//                events("PASSED", "FAILED", "SKIPPED")
//                 showStandardStreams = true
//            }
//        }
    }

    if (getHostOsName() == "windows") {
        val mingwX64Test by getting(KotlinNativeTest::class) {

            testLogging {
                events("PASSED", "FAILED", "SKIPPED")
                showStandardStreams = true
            }
        }
    }

}



signing {
    isRequired = false
    sign(publishing.publications)
}

publishing {
    publications.withType(MavenPublication::class) {
        artifact(tasks["javadocJar"])
        pom {
            name.set("Kotlin Multiplatform Crypto")
            description.set("Kotlin Multiplatform Crypto library")
            url.set("https://github.com/ionspin/kotlin-multiplatform-crypto")
            licenses {
                license {
                    name.set("The Apache License, Version 2.0")
                    url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
                }
            }
            developers {
                developer {
                    id.set("ionspin")
                    name.set("Ugljesa Jovanovic")
                    email.set("opensource@ionspin.com")
                }
            }
            scm {
                url.set("https://github.com/ionspin/kotlin-multiplatform-crypto")
                connection.set("scm:git:git://git@github.com:ionspin/kotlin-multiplatform-crypto.git")
                developerConnection.set("scm:git:ssh://git@github.com:ionspin/kotlin-multiplatform-crypto.git")

            }

        }
    }
    repositories {
        maven {

            url = uri(sonatypeStaging)
            credentials {
                username = sonatypeUsername ?: sonatypeUsernameEnv ?: ""
                password = sonatypePassword ?: sonatypePasswordEnv ?: ""
            }
        }

        maven {
            name = "snapshot"
            url = uri(sonatypeSnapshots)
            credentials {
                username = sonatypeUsername ?: sonatypeUsernameEnv ?: ""
                password = sonatypePassword ?: sonatypePasswordEnv ?: ""
            }
        }
    }
}


