package afield.runtime.completion

import afield.app.diagnostics.named
import afield.app.protocol.put
import afield.app.server.sessions
import afield.data.table.div
import afield.data.table.get
import afield.data.table.minus
import afield.data.table.plus
import afield.data.table.rem
import afield.document.graph.Box
import afield.document.graph.box
import afield.document.graph.offline
import afield.runtime.execution.plus
import afield.runtime.lifecycle.plus
import afield.runtime.lifecycle.rem
import afield.ui.notation.string
import afield.ui.notation.with
import afield.ui.output.histogram
import afield.ui.output.templates.templates
import afield.ui.visualization.table

import afield.app.server.documents
import afield.audio.synth.*
import afield.data.table.times
import afield.document.graph.introImports
import afield.document.graph.notes
import afield.document.graph.preamble
import afield.document.workspace.metadata
import afield.graphics.vulkan.*
import afield.media.stream.*
import afield.media.video.*
import afield.runtime.kotlin.CompletionResult
import afield.runtime.kotlin.KotlinEngineConfig
import afield.runtime.lifecycle.end
import afield.runtime.lifecycle.map
import afield.tools.docs.format
import afield.ui.output.templates.filter
import afield.ui.visualization.h
import afield.ui.visualization.typed

import java.io.File
import kotlin.random.Random

    @JvmStatic
    fun main(args: Array<String>) {
        // Gate by default, so the catalog entry asserts; `--report` keeps the exploration mode the
        // measurement was built as (print every verdict, exit 0) for a run whose point is the residual.
        val gate = !args.contains("--report") && System.getenv("AFIELD_LOWERING_GATE")?.trim() != "0"
        val url = (System.getProperty("afield.completion.sidecarUrl")?.trim()?.ifBlank { null }
            ?: System.getenv("AFIELD_CODE_USE_SEMANTIC_SIDECAR_URL")?.trim()?.ifBlank { null }
            ?: File("build/completion-corpus/sidecar-url.txt").takeIf { it.exists() }?.readText()?.trim()
                ?.ifBlank { null })
        if (url == null) {
            println("NO SIDECAR: no sidecar URL (set -Dafield.completion.sidecarUrl or write build/completion-corpus/sidecar-url.txt); the lowering was not checked")
            kotlin.system.exitProcess(3)
        }
        System.setProperty("afield.completion.sidecarUrl", url)
        KotlinEngineConfig.activeCompletionBackend = KotlinEngineConfig.CompletionBackend.AA

        fun env(k: String, d: String) = System.getenv(k)?.trim()?.ifBlank { null } ?: d
        val corpusDirs = env("AFIELD_LOWERING_CORPUS", "public/docs/assets/agent_transcripts,templates")
            .split(',').map { it.trim() }.filter { it.isNotEmpty() }.map(::File).filter { it.isDirectory }
        val maxDocs = env("AFIELD_LOWERING_DOCS", "200").toInt()
        val caretsPerBox = env("AFIELD_LOWERING_CARETS", "4").toInt()
        // No cap by default (0). A cap that BINDS turns the report into a sample, and makes the numbers
        // depend on how many questions the corpus happens to yield. The old fixed cap of 8000 did exactly
        // that once the corpus tripled: the round-robin queue cut each box's later questions, so `dot/2`
        // fell under its sample-size floor while `dot/0` looked fine. It stays a knob so an exploration
        // run can be quick, but a cap that cuts the sweep short fails the gate.
        val maxRequests = env("AFIELD_LOWERING_MAX_REQUESTS", "0").toInt()
        val seed = env("AFIELD_LOWERING_SEED", "42").toLong()
        val jsonOut = File(env("AFIELD_LOWERING_JSON", "build/completion-lowering/report.json"))
        val skipRecall = env("AFIELD_LOWERING_SKIP_RECALL", "0") == "1"
        val maxExamples = env("AFIELD_LOWERING_EXAMPLES", "14").toInt()
        val receivers = listOf("afield.document.graph.Box")

        println("sidecar   $url")
        println("corpus    ${corpusDirs.joinToString(", ") { it.path }}")

        // The corpus comes from the checked-in harvest ([CompletionCorpus]) whenever it is present: those
        // fixtures carry each box's preamble AS EXPANDED, which is the context a real editing session has
        // and which no static read of a document can reconstruct. Falling back to the raw documents keeps
        // the probe usable against a directory that has never been harvested (e.g. a personal workspace),
        // with the caveat that every macro-declared name will read as unresolved.
        val dirNames = corpusDirs.map { it.path }
        val (fixtures, drift) = CompletionCorpus.readFixtures(dirs = dirNames)
        drift.take(5).forEach { println("  ! fixture drift: ${it.label}: ${it.what}") }
        val cases: List<CompletionCorpus.Case>
        val docCount: Int
        if (fixtures.isNotEmpty() && drift.isEmpty()) {
            cases = fixtures.take(maxDocs * 64)
            docCount = cases.map { it.doc }.distinct().size
            println("corpus    from harvested fixtures (${CompletionCorpus.FIXTURE_DIR})")
        } else {
            println("corpus    from documents on disk — NOT harvested, so macro-declared names will be unresolved")
            val docs = CompletionCorpus.documents(dirNames).take(maxDocs)
            docCount = docs.size
            cases = docs.flatMap { doc ->
                CompletionCorpus.kotlinBoxes(doc).map { rec ->
                    CompletionCorpus.Case(doc.name, rec.id, rec.props["code"]!!, rec.props["preamble"].orEmpty())
                }
            }
        }
        val withPreamble = cases.count { it.preamble.isNotBlank() }
        println("documents $docCount   kotlin boxes ${cases.size}   with a preamble $withPreamble   " +
            "lines ${cases.sumOf { it.code.lines().size }}")

        // ── 1. the lowering invariant ───────────────────────────────────────────────────────────────
        println()
        println("══ 1. LOWERING INVARIANT — does the file completion analyses type-check? ══")
        val byRegion = Counter<String>()
        val byRegionFactory = Counter<String>()
        val unresolvedNames = Counter<String>()
        val worstBoxes = mutableListOf<Triple<String, Int, String>>()   // label, injected-region errors, sample
        var lowered = 0
        var preambleDropped = 0
        var loweringFailed = 0
        val injectedRegions = setOf("preamble", "declarations", "stubs", "wrapper")
        for (c in cases) {
            val r = AaCompletionClient.lower(c.code, c.code.length, c.preamble, receivers, replImports = introImports)
            if (r == null || !r.success) { loweringFailed++; continue }
            lowered++
            if (c.preamble.isNotBlank() && !r.preambleInjected) {
                preambleDropped++
                println("  ! preamble NOT injected (unparseable) ${c.label}")
            }
            var injected = 0
            for (e in r.errors) {
                byRegion.add(e.region)
                byRegionFactory.add("${e.region}:${e.factory}")
                if (e.region in injectedRegions) injected++
                if (e.factory.contains("UNRESOLVED")) unresolvedNames.add(e.excerpt.take(40))
            }
            if (injected > 0) {
                val sample = r.errors.first { it.region in injectedRegions }
                worstBoxes += Triple("${c.label}", injected, "${sample.region}:${sample.factory} ${sample.excerpt}")
            }
        }
        println("  lowered ${lowered}/${cases.size} boxes (failed $loweringFailed), preambles dropped as unparseable: $preambleDropped")
        println("  errors by region: " + byRegion.counts.entries.joinToString(", ") { "${it.key}=${it.value}" }
            .ifBlank { "none" })
        val injectedErrors = byRegion.counts.filterKeys { it in injectedRegions }.values.sum()
        println("  INVARIANT (injected regions must be clean): " +
            "${worstBoxes.size} boxes with injected-region errors, $injectedErrors errors")
        worstBoxes.sortedByDescending { it.second }.take(12).forEach { (label, n, sample) ->
            println("    $label  $n  e.g. $sample")
        }
        println("  top error kinds:")
        byRegionFactory.top(12).forEach { println("    ${it.value.toString().padStart(5)}  ${it.key}") }
        println("  most-unresolved names in box code (what a headless session cannot see):")
        unresolvedNames.top(20).forEach { println("    ${it.value.toString().padStart(5)}  ${it.key}") }

        // ── 2. caret recall against the source ─────────────────────────────────────────────────────
        val recall = Counter<String>()
        val attempts = Counter<String>()
        val missNotes = Counter<String>()
        val notesByBucket = LinkedHashMap<String, Counter<String>>()
        val missedNames = Counter<String>()
        val missExamples = mutableListOf<String>()
        var requests = 0
        var available = 0   // questions the corpus yields
        var asked = 0       // of those, how many the cap let through
        val times = mutableListOf<Long>()
        if (!skipRecall) {
            println()
            println("══ 2. CARET RECALL — is what the author wrote actually offered? ══")
            val rng = Random(seed)
            // Every question the sweep could ask, built before any of it is asked so the request cap
            // truncates EVENLY across the corpus. Asked box-by-box (as this was), a 400-request cap only
            // ever reached the first ~30 of 182 boxes — every reported miss came from `alife_*`, `dot` got
            // 15 samples, and a floor set on 15 samples measures the sample, not the engine. Round-robin
            // by caret index instead: request N of the run is caret N/182 of box N%182.
            val perCase = cases.map { c ->
                val all = targetsIn(c.code)
                // Sampled PER KIND, not `take(n)` over the lot. Real box code is mostly name positions, so
                // a flat sample follows that distribution: `dot` came out at 61 carets against `name`'s 531,
                // and a floor cut 5 points under a 61-caret observation is three carets from a false red —
                // which is how a gate gets deleted instead of repaired. Each bucket is measured on its own
                // denominator anyway, so evening out the denominators costs nothing but requests.
                val picked = all.shuffled(rng).distinctBy { it.offset }
                    .groupBy { it.kind }.values.flatMap { it.take(caretsPerBox) }
                picked.flatMap { site ->
                    // A bare `.` and two characters typed are different questions of the same caret; a
                    // name position with nothing typed is not asked at all (the AA path withholds
                    // star-import scopes there on purpose, so it would measure a decision, not a defect).
                    val typedVariants = if (site.kind == "dot" || site.kind == "pkg") listOf(0, 2) else listOf(2)
                    // A NAMED ARGUMENT that is already written is not a fair `keep`-mode target: with
                    // `cellSide = 280` still on the line, completion is right to leave `cellSide` out —
                    // you don't offer a keyword argument that has been supplied. In `blank` mode the rest
                    // of the line is gone, so the same site is a legitimate test. Counting these as misses
                    // was inflating the typing-vs-editing gap with an artifact of the sweep.
                    val suppliedNamedArg = site.kind == "name" &&
                        Regex("""^\s*=[^=]""").containsMatchIn(c.code.drop(site.offset + site.truth.length))
                    typedVariants.flatMap { t -> listOf("blank", "keep").map { t to it } }
                        .filter { (typed, mode) ->
                            typed <= site.truth.length && !(mode == "keep" && suppliedNamedArg)
                        }
                        .map { (typed, mode) -> Ask(c, Site(site.offset + typed, site.truth, site.kind), typed, mode) }
                }
            }
            val queue = ArrayList<Ask>()
            var round = 0
            while (maxRequests <= 0 || queue.size < maxRequests) {
                val added = perCase.count { round < it.size }
                if (added == 0) break
                perCase.forEach { if (round < it.size) queue += it[round] }
                round++
            }
            available = perCase.sumOf { it.size }
            val sweep = if (maxRequests > 0) queue.take(maxRequests) else queue
            asked = sweep.size
            for (ask in sweep) {
                val (c, t, typed, mode) = ask
                val (snippet, cursor) = snippetFor(c.code, t.offset, mode)
                if (cursor > snippet.length) continue
                val key = "${t.kind}/$typed/$mode"
                attempts.add(key)
                requests++
                val t0 = System.nanoTime()
                val outcome = AaCompletionClient.complete(
                    snippet, cursor, c.preamble, receivers, replImports = introImports,
                )
                times += (System.nanoTime() - t0) / 1_000_000
                val cands = (outcome.result as? CompletionResult.Success)?.metadata.orEmpty()
                val hit = cands.any {
                    it.text.trimEnd('(', ' ', '=') == t.truth || it.displayText.startsWith(t.truth)
                }
                if (hit) recall.add(key)
                else {
                    // A histogram says WHAT is missed; it can't be reproduced. Keep a handful of
                    // misses verbatim — the line the caret was on, and the note — so each bucket
                    // in the summary leads to something that can be pasted into a box.
                    if (missExamples.size < maxExamples) {
                        val line = c.code.take(t.offset).substringAfterLast('\n') +
                            "‸" + c.code.drop(t.offset).substringBefore('\n')
                        missExamples += "${c.label} $key .${t.truth}\n" +
                            "        line: ${line.trim().take(110)}\n" +
                            "        note: ${outcome.detail.take(110)}"
                    }
                    missedNames.add(t.truth)
                    val note = outcome.detail.substringBefore(':').take(60).let {
                        if (outcome.detail.startsWith("empty")) "empty: " + outcome.detail
                            .substringAfter("empty: ").substringBefore(':').take(40) else it
                    }
                    missNotes.add(note)
                    // Kept per bucket as well as overall, because that is what a ratchet failure has to
                    // say: "bare-dot recall fell to 71%, and the sidecar's own note on those misses is X"
                    // is a diagnosis; "recall fell" is a number to argue about.
                    notesByBucket.getOrPut(key) { Counter() }.add(note)
                }
            }
            println("  requests $requests   latency p50=${times.sorted().getOrNull(times.size / 2)}ms")
            println("  RECALL (kind/typed-chars/mode):")
            attempts.counts.keys.sorted().forEach { k ->
                val n = attempts.counts[k] ?: 0
                val h = recall.counts[k] ?: 0
                println("    ${k.padEnd(16)} ${h.toString().padStart(4)}/${n.toString().padEnd(4)} " +
                    "${if (n > 0) "%.0f%%".format(100.0 * h / n) else "-"}")
            }
            val totalA = attempts.counts.values.sum(); val totalH = recall.counts.values.sum()
            println("    ${"TOTAL".padEnd(16)} ${totalH}/${totalA} ${if (totalA > 0) "%.0f%%".format(100.0 * totalH / totalA) else "-"}")
            println("  miss reasons (sidecar's own note):")
            missNotes.top(12).forEach { println("    ${it.value.toString().padStart(5)}  ${it.key}") }
            println("  most-missed identifiers:")
            missedNames.top(20).forEach { println("    ${it.value.toString().padStart(5)}  ${it.key}") }
            println("  example misses (paste-able):")
            missExamples.forEach { println("    $it") }
        }

        // ── 3. the ratchet ──────────────────────────────────────────────────────────────────────────
        println()
        println("══ 3. RATCHET — the floors this gate holds ══")
        val broken = mutableListOf<String>()
        val held = mutableListOf<String>()
        fun hard(desc: String, ok: Boolean, detail: String) {
            if (ok) { held += desc; println("  ✓ $desc — $detail") }
            else { broken += desc; println("  ✗ RATCHET FAIL $desc — $detail") }
        }
        hard("every box lowers", lowered == cases.size, "$lowered/${cases.size} lowered, $loweringFailed failed")
        hard("no preamble dropped as unparseable", preambleDropped == 0, "$preambleDropped dropped")
        hard(
            "injected regions type-check", injectedErrors == 0,
            "$injectedErrors errors in ${worstBoxes.size} boxes" +
                worstBoxes.sortedByDescending { it.second }.firstOrNull()?.let { " (worst: ${it.first} — ${it.third})" }.orEmpty(),
        )
        if (!skipRecall) {
            hard("the sweep actually ran", requests >= MIN_REQUESTS, "$requests requests (floor $MIN_REQUESTS)")
            hard(
                "the sweep covered the whole corpus", asked == available,
                "$asked of $available questions asked" +
                    if (asked < available) " — AFIELD_LOWERING_MAX_REQUESTS=$maxRequests made this a sample" else "",
            )
            for (f in FLOORS) {
                val n = if (f.bucket == "TOTAL") attempts.counts.values.sum() else attempts.counts[f.bucket] ?: 0
                val h = if (f.bucket == "TOTAL") recall.counts.values.sum() else recall.counts[f.bucket] ?: 0
                val pct = if (n > 0) 100.0 * h / n else 0.0
                // A recall percentage over a bucket nobody sampled is 0/0 — vacuously fine, or vacuously
                // broken, and either way not a measurement. So the sample size is a floor too: a change
                // that stops PRODUCING `dot` targets must fail here rather than quietly stop asking.
                if (n < f.minAttempts) {
                    broken += f.bucket
                    println("  ✗ RATCHET FAIL ${f.bucket} sampled only $n carets (floor ${f.minAttempts}, " +
                        "${f.observed} when this floor was cut) — the sweep stopped asking, so its recall means nothing")
                    continue
                }
                if (pct + 1e-9 < f.minPercent) {
                    broken += f.bucket
                    val notes = (if (f.bucket == "TOTAL") missNotes else notesByBucket[f.bucket])
                        ?.top(3)?.joinToString("; ") { "${it.value}× \"${it.key}\"" } ?: "no notes recorded"
                    // `%%` everywhere, including in the interpolated numbers: a bare `%` followed by a space
                    // is an invalid format conversion, so the FAILURE MESSAGE threw instead of printing.
                    // The gate still exited nonzero — by exception — which is exactly the shape of bug that
                    // only deliberately breaking a guarded fix can find, since the happy path never runs it.
                    println("  ✗ RATCHET FAIL ${f.bucket} recall fell from ${f.observed}%% to %.0f%%".format(pct) +
                        " (floor ${f.minPercent}%, $h/$n); the sidecar's own note on those misses: $notes")
                } else {
                    held += f.bucket
                    println("  ✓ ${f.bucket.padEnd(16)} %3.0f%% ≥ ${f.minPercent}%%  n=$n  (cut from ${f.observed}%%)".format(pct))
                }
            }
        } else println("  (recall floors skipped: AFIELD_LOWERING_SKIP_RECALL=1)")

        runCatching {
            jsonOut.parentFile?.mkdirs()
            val sb = StringBuilder("{\n")
            sb.append("""  "documents": $docCount, "boxes": ${cases.size}, "withPreamble": $withPreamble,""").append('\n')
            sb.append("""  "lowered": $lowered, "loweringFailed": $loweringFailed,""").append('\n')
            sb.append("""  "preambleDropped": $preambleDropped,""").append('\n')
            sb.append("""  "errorsByRegion": {""")
                .append(byRegion.counts.entries.joinToString(", ") { """"${it.key}": ${it.value}""" }).append("},\n")
            sb.append("""  "errorKinds": {""")
                .append(byRegionFactory.top(40).joinToString(", ") { """"${jsonEscape(it.key)}": ${it.value}""" }).append("},\n")
            sb.append("""  "unresolvedInSnippet": {""")
                .append(unresolvedNames.top(60).joinToString(", ") { """"${jsonEscape(it.key)}": ${it.value}""" }).append("},\n")
            sb.append("""  "recall": {""")
                .append(attempts.counts.keys.sorted().joinToString(", ") {
                    """"$it": [${recall.counts[it] ?: 0}, ${attempts.counts[it]}]"""
                }).append("},\n")
            sb.append("""  "missNotes": {""")
                .append(missNotes.top(40).joinToString(", ") { """"${jsonEscape(it.key)}": ${it.value}""" }).append("},\n")
            sb.append("""  "missedNames": {""")
                .append(missedNames.top(60).joinToString(", ") { """"${jsonEscape(it.key)}": ${it.value}""" }).append("}\n")
            sb.append("}\n")
            jsonOut.writeText(sb.toString())
            println()
            println("report → ${jsonOut.path}")
        }

        println()
        if (broken.isEmpty()) {
            println("RATCHET PASS: ${held.size} floors held")
        } else if (gate) {
            println("RATCHET FAIL: ${broken.size} of ${broken.size + held.size} floors broken — ${broken.joinToString(", ")}")
            println("  (each ✗ above names what it fell from and the sidecar's own note on the misses;")
            println("   a floor is raised when a fix moves its number, never lowered to make a run green)")
            println("LOWERING PROBE DONE")
            System.out.flush()
            kotlin.system.exitProcess(1)
        } else {
            println("RATCHET (report-only): ${broken.size} of ${broken.size + held.size} floors broken — " +
                broken.joinToString(", ") + "  [--report given, so exiting 0]")
        }

        println("LOWERING PROBE DONE")
    }
}