//import org.gradle.kotlin.dsl.implementation
import org.jetbrains.compose.desktop.application.dsl.TargetFormat
import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpackConfig

plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.composeMultiplatform)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.serialization)
    alias(libs.plugins.buildconfig)
}

version = PhoebenchVersion(1, 1, 2)

if((version as PhoebenchVersion) < (rootProject.version as PhoebenchVersion))
    throw GradleException("UI Clients version must be at least as high as protocol/common version")
val versionDirectory = layout.buildDirectory.dir("generated/sources/version")

val generateVersion = tasks.register<Task>("clientVersion") {
    doFirst {
        val outFile = versionDirectory.get().file("com/jaytux/phoebench/client/Version.kt").asFile
        outFile.parentFile.mkdirs()
        outFile.writeText("""
            package com.jaytux.phoebench.client
            
            object ClientVersion {
                const val VERSION="$version"
            }
        """.trimIndent())
    }
}

kotlin {
    compilerOptions {
        freeCompilerArgs.add("-Xcontext-parameters")
        optIn.add("kotlin.uuid.ExperimentalUuidApi")
    }

    jvm("desktop")

    @OptIn(ExperimentalWasmDsl::class)
    wasmJs {
        browser {
            val rootDirPath = project.rootDir.path
            val projectDirPath = project.projectDir.path
            commonWebpackConfig {
                outputFileName = "composeApp.js"
                devServer = (devServer ?: KotlinWebpackConfig.DevServer()).apply {
                    static(rootDirPath)
                    static(projectDirPath)
                }
            }
        }
        binaries.executable()
    }

    applyDefaultHierarchyTemplate()

    sourceSets {
        val desktopMain by getting

        val nonWeb by creating {
            dependsOn(commonMain.get())

            dependencies {
            }
        }

        desktopMain.dependsOn(nonWeb)

        commonMain.dependencies {
            implementation(libs.compose.runtime)
            implementation(libs.compose.foundation)
            implementation(libs.compose.ui)
            implementation(libs.compose.components.resources)
            implementation(libs.compose.material3)
            implementation(libs.androidx.lifecycle.viewmodel)
            implementation(libs.androidx.lifecycle.viewmodel.compose)
            implementation(libs.androidx.lifecycle.runtime.compose)
            implementation(libs.ktor.client.core)
            implementation(libs.ktor.client.logging)
            implementation(libs.ktor.client.auth)
            implementation(libs.ktor.client.content.negotiation)
            implementation(libs.kotlinx.datetime)
            implementation(libs.kotlinx.serialization)
            implementation(libs.ktor.serialization.kotlinx.json)
            implementation(libs.ktor.client.auth)
            implementation(libs.ktor.client.logging)
            implementation(project(":common"))
            implementation(kotlin("reflect"))
            implementation(libs.compose.backhandler)
            implementation(libs.kotlinx.atomic)
            implementation(libs.lucide)
            implementation(libs.koala)
            implementation(libs.kolor)
        }
        desktopMain.dependencies {
            implementation(compose.desktop.currentOs)
            implementation(libs.kotlinx.coroutines.swing)
            implementation(libs.ktor.client.okhttp)
            implementation(libs.slf4j.simple)
            implementation(libs.java.keystore)
        }
        wasmJsMain.dependencies {
            implementation(libs.ktor.client.js)
        }

        commonMain {
            kotlin {
                srcDir(versionDirectory)
            }
        }
    }

    targets.all {
        compilations.all {
            compileTaskProvider.configure {
                dependsOn(generateVersion)
            }
        }
    }
}

compose.desktop {
    application {
        mainClass = "com.jaytux.phoebench.clients.MainKt"

        nativeDistributions {
            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
            packageName = "com.jaytux.phoebench.clients"
            packageVersion = (version as PhoebenchVersion).safeString()

            jvmArgs += listOf("--enable-native-access=ALL-UNNAMED")
            includeAllModules = true
            buildTypes.release.proguard {
                configurationFiles.from(file("proguard-rules.pro"))
            }
        }
    }
}

fun envValue(key: String): String? {
    val fromEnv = providers.environmentVariable(key).orNull
    if(fromEnv != null) return fromEnv

    val envFile = rootProject.file(".env")
    if(!envFile.exists()) return null

    return envFile.useLines { lines ->
        lines.map { it.trim() }.filter { it.isNotBlank() && !it.startsWith('#') && '=' in it }
            .map { line ->
                val (k, v) = line.split('=', limit = 2)
                k.trim() to v.trim().removeSurrounding("\"").removeSurrounding("'")
            }
            .firstOrNull { it.first == key }?.second
    }
}

buildConfig {
    generateAtSync = false
    useKotlinOutput { internalVisibility = false }

    println("Source sets: ${kotlin.sourceSets.toList().map { it.name }}")

    sourceSets.named("desktopMain") {
        println("Generating 'desktopMain'")
        className("PersistenceConstants")
        packageName("com.jaytux.phoebench.clients")

        envValue("PHOEBENCH_BUILD_RELEASE")?.let {
            println("Using release desktop service")
            buildConfigField("SERVICE", "com.jaytux.phoebench")
        } ?: run {
            println("Using debug desktop service")
            buildConfigField("SERVICE", "com.jaytux.phoebench.debug")
        }
    }
}