import java.util.Properties

plugins {
    alias(libs.plugins.android.application)
    // AGP 9 has built-in Kotlin (org.jetbrains.kotlin.android is gone); only the
    // compiler sub-plugins are applied separately, pinned to AGP's bundled KGP version.
    alias(libs.plugins.kotlin.compose)
    alias(libs.plugins.kotlin.serialization)
    alias(libs.plugins.ksp)
}

ksp {
    // Commit exported schemas: migration baseline for a DB that is a medical record.
    arg("room.schemaLocation", "$projectDir/schemas")
}

// Release signing from gitignored keystore.properties (keystore lives in
// ~/.keystores). Absent file → unsigned release, so CI/fresh clones still build.
val keystoreProps = Properties().apply {
    val f = rootProject.file("keystore.properties")
    if (f.exists()) f.inputStream().use(::load)
}

android {
    namespace = "no.naiv.meddetsamme"
    // compileSdk 37: required by current AndroidX (core 1.19 / compose BOM 2026.05).
    // targetSdk stays 35 (brief) — compile-against vs runtime-behavior are separate knobs.
    compileSdk = 37

    defaultConfig {
        applicationId = "no.naiv.meddetsamme"
        minSdk = 26
        targetSdk = 35
        // Bump both for every release installed on the phone — versionName for
        // humans, versionCode so dumpsys/install history can tell builds apart.
        versionCode = 3
        versionName = "0.3.0"
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    signingConfigs {
        if (keystoreProps.isNotEmpty()) {
            create("release") {
                storeFile = file(keystoreProps.getProperty("storeFile"))
                storePassword = keystoreProps.getProperty("storePassword")
                keyAlias = keystoreProps.getProperty("keyAlias")
                keyPassword = keystoreProps.getProperty("keyPassword")
            }
        }
    }

    buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
            if (keystoreProps.isNotEmpty()) {
                signingConfig = signingConfigs.getByName("release")
            }
        }
    }

    compileOptions {
        // Built-in Kotlin derives jvmTarget from targetCompatibility — one knob, not two.
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

    buildFeatures {
        compose = true
    }

    lint {
        // Deliberate decisions, not oversights — see CLAUDE.md:
        // BatteryLife: decision #4, sideloaded app (Play policy n/a).
        // OldTargetApi: targetSdk 35 is pinned by the brief.
        // NewerVersionAvailable: Kotlin 2.4 is blocked until KSP supports it.
        disable += listOf("BatteryLife", "OldTargetApi", "NewerVersionAvailable")
    }

    // MigrationTestHelper reads the exported schema JSONs as androidTest assets.
    sourceSets.getByName("androidTest").assets.srcDir("$projectDir/schemas")
}

// Guardrail (added after a real incident): an unscoped connected test run fans
// out to EVERY adb device. On 2026-06-10 that meant the personal phone, where
// the debug test APK's signature mismatch got "resolved" by uninstalling the
// release app — destroying its data. Connected tests now refuse to run unless
// ANDROID_SERIAL pins them to a specific (emulator) device.
tasks.matching { it.name.startsWith("connected") }.configureEach {
    doFirst {
        val serial = System.getenv("ANDROID_SERIAL")
        check(!serial.isNullOrBlank()) {
            "Refusing to run connected tests without ANDROID_SERIAL — an unscoped run " +
                "targets every adb device, including the phone. " +
                "Use: ANDROID_SERIAL=emulator-5554 ./gradlew ${this@configureEach.name}"
        }
        check(serial.startsWith("emulator-")) {
            "ANDROID_SERIAL=$serial is not an emulator — connected tests must never " +
                "target a physical device."
        }
    }
}

// Release builds refresh the bundled FEST dataset when it's >30 days old.
// The script fast-exits when fresh and keeps the old file on download failure,
// so offline/CI release builds never break on this.
val refreshFestData by tasks.registering(Exec::class) {
    group = "fest"
    description = "Regenerate app/src/main/assets/fest/slim.json from DMP's M30 extract if stale"
    workingDir = rootProject.projectDir
    commandLine(
        "python3", "tools/fest_flatten.py",
        "--out", "app/src/main/assets/fest/slim.json",
        "--max-age-days", "30",
    )
}

tasks.matching { it.name == "preReleaseBuild" }.configureEach {
    dependsOn(refreshFestData)
}

dependencies {
    implementation(libs.kotlinx.coroutines.android)
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.activity.compose)
    implementation(libs.androidx.lifecycle.runtime.ktx)

    implementation(platform(libs.compose.bom))
    implementation(libs.compose.ui)
    implementation(libs.compose.material3)
    implementation(libs.compose.ui.tooling.preview)
    debugImplementation(libs.compose.ui.tooling)

    implementation(libs.room.runtime)
    ksp(libs.room.compiler)

    implementation(libs.work.runtime)
    implementation(libs.okhttp)
    implementation(libs.kotlinx.serialization.json)
    implementation(libs.kage)

    testImplementation(libs.junit)
    androidTestImplementation(libs.androidx.test.junit)
    androidTestImplementation(libs.androidx.test.runner)
    androidTestImplementation(libs.room.testing)
}