import org.gradle.kotlin.dsl.support.serviceOf
import org.jetbrains.compose.desktop.application.dsl.TargetFormat
import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import java.util.*

plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.androidApplication)
    alias(libs.plugins.composeMultiplatform)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.composeHotReload)

    alias(libs.plugins.kotlinSerialization)
}

kotlin {
    // androidTarget { compilerOptions { jvmTarget.set(JvmTarget.JVM_11) } }
    androidTarget()

    jvm()

    js {
        browser()
        binaries.executable()
    }

    @OptIn(ExperimentalWasmDsl::class)
    wasmJs {
        browser()
        binaries.executable()
    }

    sourceSets {
        androidMain.dependencies {
            implementation(libs.compose.uiToolingPreview)
            implementation(libs.androidx.activity.compose)
            implementation(libs.ktor.client.okhttp)
            implementation(libs.markdown.renderer.android)
        }
        commonMain.dependencies {
            implementation(libs.compose.runtime)
            implementation(libs.compose.foundation)
            implementation(libs.compose.material3)
            implementation(libs.compose.ui)
            implementation(libs.compose.components.resources)
            implementation(libs.compose.uiToolingPreview)
            implementation(libs.androidx.lifecycle.viewmodelCompose)
            implementation(libs.androidx.lifecycle.runtimeCompose)
            implementation(projects.shared)

            implementation(libs.bundles.ktor)
            implementation(libs.multiplatform.settings)
            implementation(libs.material.icons.core)
            implementation(libs.material.icons.extended)
            implementation(libs.compose.navigation)
            implementation(libs.markdown.renderer)
            implementation(libs.markdown.renderer.m3)
        }
        commonTest.dependencies { implementation(libs.kotlin.test) }
        jsMain.dependencies { implementation(libs.ktor.client.js) }
        wasmJsMain.dependencies { implementation(libs.ktor.client.js) }
        jvmMain.dependencies {
            implementation(compose.desktop.currentOs)
            implementation(libs.kotlinx.coroutinesSwing)
            implementation(libs.ktor.client.cio)
            implementation(libs.markdown.renderer.jvm)
        }
    }
}

android {
    namespace = "win.tap_tap.papertrader"
    compileSdk = libs.versions.android.compileSdk.get().toInt()

    signingConfigs {
        create("release") {
            val localProperties = Properties()
            val localPropertiesFile = rootProject.projectDir.resolve("secrets.properties")
            localProperties.load(localPropertiesFile.inputStream())
            storeFile = project.file("upload-key.keystore")
            storePassword = localProperties.getProperty("KEYSTORE_PASSWORD")
            keyAlias = localProperties.getProperty("KEY_ALIAS")
            keyPassword = localProperties.getProperty("KEY_PASSWORD")
        }
    }

    defaultConfig {
        applicationId = "win.tap_tap.papertrader"
        minSdk = libs.versions.android.minSdk.get().toInt()
        targetSdk = libs.versions.android.targetSdk.get().toInt()
        versionCode = 21
        versionName = "1.1.2"
    }
    packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
    buildTypes {
        getByName("release") {
            isMinifyEnabled = true
            isShrinkResources = true
            signingConfig = signingConfigs.getByName("release")
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
}

dependencies { debugImplementation(libs.compose.uiTooling) }

compose.desktop {
    application {
        mainClass = "win.tap_tap.papertrader.MainKt"

        nativeDistributions {
            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
            packageName = "win.tap_tap.papertrader"
            packageVersion = "1.0.0"
        }
    }
}

allprojects { version = "1.1.2" }

tasks.register<Exec>("wasmJsDockerBuild") {
    group = "deployment"
    dependsOn("wasmJsBrowserDistribution")
    workingDir = projectDir
    commandLine("docker", "build", "-t", "papertrader-browser", "-f", "src/webMain/Dockerfile", ".")
}

tasks.register("wasmJsDockerPush") {
    group = "deployment"
    val version = project.version
    val execOps = project.serviceOf<ExecOperations>()
    doLast {
        fun execute(args: List<String>) {
            execOps.exec { commandLine(args) }
        }
        execute(
            listOf(
                "docker",
                "tag",
                "papertrader-browser",
                "taptap1/papertrader-browser:$version"
            )
        )
        execute(
            listOf("docker", "tag", "papertrader-browser", "taptap1/papertrader-browser:latest")
        )
        execute(listOf("docker", "push", "taptap1/papertrader-browser:$version"))
        execute(listOf("docker", "push", "taptap1/papertrader-browser:latest"))
        println("Pushed: papertrader-browser:$version and papertrader-browser:latest")
    }
}

tasks.register("wasmJsDockerDeploy") {
    group = "deployment"
    dependsOn("wasmJsDockerBuild")
    dependsOn("wasmJsDockerPush")
}

tasks.named("wasmJsDockerPush") { mustRunAfter("wasmJsDockerBuild") }

tasks.register<Exec>("androidDeploy") {
    group = "deployment"
    dependsOn("bundleRelease")
    commandLine(
        "cp",
        "-f",
        "build/outputs/bundle/release/composeApp-release.aab",
        "./../android.aab"
    )
}