package com.k2fsa.sherpa.onnx

import android.content.res.AssetManager
import android.util.Log
import org.json.JSONObject

// ============================================================================
// SummarizePipeline — §5 摘要流水线(分块 → 滚动笔记 → 成稿)
//
// 提示词唯一事实源是 assets/summarize/prompts.md(用户可直接编辑/复制到 PC
// llama.cpp 调试)。解析失败时退回本文件内置的同源副本 —— 两份不一致以 md
// 为准,改提示词请同步改 md。
//
// 只在摘要专用后台线程上 new 出来跑完就丢,绝不触碰录音/主线程对象。
// ============================================================================

class SummarizeCancelledException : Exception("summarize cancelled")

/** 空笔记防线(用户要求 2026-09-11):笔记/成稿为空 → 提示并自动取消,不落盘。 */
class SummarizeEmptyException(msg: String) : Exception(msg)

data class Prompts(
    val p1System: String, val p1UserTpl: String,
    val p2System: String, val p2UserTpl: String,
)

data class MeetingSummary(
    val markdown: String,
    val language: String,        // ja / zh / en
    val notesJson: String,
    val totalChunks: Int,
    val failedChunks: Int,
)

interface SummarizeListener {
    /** stage 人话描述("正在加载模型…"、"第 3/12 块…")。在摘要线程回调。 */
    fun onProgress(stage: String, done: Int, total: Int)
    fun isCancelled(): Boolean
}

// ---- prompts.md 解析 --------------------------------------------------------

object PromptsLoader {
    private const val TAG = "sherpa-onnx"
    private const val ASSET = "summarize/prompts.md"

    fun load(assets: AssetManager): Prompts {
        val md = try {
            assets.open(ASSET).bufferedReader().use { it.readText() }
        } catch (t: Throwable) {
            Log.w(TAG, "prompts.md missing/unreadable, using builtin: $t")
            return BUILTIN
        }
        return try {
            parse(md)
        } catch (t: Throwable) {
            Log.e(TAG, "prompts.md parse failed, using builtin", t)
            BUILTIN
        }
    }

    // "## P1 …" 小节里前两个代码围栏块依次是 SYSTEM、USER;"## P2" 同理。
    internal fun parse(md: String): Prompts {
        fun section(marker: String): Pair<String, String> {
            val start = md.indexOf(marker)
            require(start >= 0) { "section $marker not found" }
            val end = md.indexOf("\n## ", start + marker.length).let {
                if (it < 0) md.length else it
            }
            val body = md.substring(start, end)
            val fences = ArrayList<String>()
            var i = 0
            while (true) {
                val open = body.indexOf("```", i)
                if (open < 0) break
                val close = body.indexOf("```", open + 3)
                if (close < 0) break
                fences.add(body.substring(open + 3, close).trim('\n').trim())
                i = close + 3
            }
            require(fences.size >= 2) { "$marker: need 2 fenced blocks, got ${fences.size}" }
            return fences[0] to fences[1]
        }
        val (p1s, p1u) = section("## P1")
        val (p2s, p2u) = section("## P2")
        require(p1s.isNotBlank() && p2s.isNotBlank())
        return Prompts(p1s, p1u, p2s, p2u)
    }

    // 与 prompts.md 同源的内置副本(md 丢失/被改坏时的兜底;2026-09-14 起中文)。
    val BUILTIN = Prompts(
        p1System = "你是处理会议转写记录的笔记员。请把【新的断片】的内容合并进给定的【当前笔记】,只以JSON输出更新后的笔记。\n\n" +
            "严格要求:\n" +
            "- 只输出符合指定schema的JSON对象;禁止说明文字、代码围栏、开场语。\n" +
            "- schema的键名必须原样输出,不得翻译、转写或改写(程序按这些键校验)。\n" +
            "- 笔记内容用中文书写;人名、组织名、产品名等专有名词保留原文写法。\n" +
            "- 不得把输入笔记原样照抄:必须从【新的断片】中提取至少一条笔记尚未覆盖的信息并合并;断片确实没有新信息时,保留原笔记并只更新「前回末尾」。\n" +
            "- 数字、金额、日期时间、期限、次数、单位按原文准确转记,不许模糊概括。\n" +
            "- 不得删除否定、保留、反对的意图;「暂缓」「再议」「反对意见」本身就是重要信息。\n" +
            "- 每个条目在「出典」字段给出依据发言的时间段(格式:\"mm:ss-mm:ss\",多个用\";\"分隔)。\n" +
            "- 总计超过500字时,合并删除低价值的旧条目压缩;「行動項目」和「已定事項」最后才允许删。\n" +
            "- 「前回末尾」用一句话写最近的议题,供下一个断片衔接上下文。\n" +
            "- JSON字符串值内需要双引号时转义为\\\";换行用\\n。\n\n" +
            "schema(键名禁止改动):\n" +
            "{\"已定事項\":[{\"内容\":\"\",\"出典\":\"\"}],\"討論中\":[{\"内容\":\"\",\"出典\":\"\"}],\"行動項目\":[{\"内容\":\"\",\"担当者\":\"\",\"期限\":\"\",\"出典\":\"\"}],\"人物\":[{\"名前\":\"\",\"立場\":\"\"}],\"前回末尾\":\"\"}",
        p1UserTpl = "【当前笔记】\n{notes_json}\n\n" +
            "【新的断片】(时间戳为会议开始的 分:秒,[]内是说话人标签)\n{chunk_text}\n\n" +
            "请输出更新后的笔记JSON。",
        p2System = "你是会议的官方纪要撰写者。收到会议笔记(JSON)与术语表后,用指定成稿语言输出完整的Markdown会议纪要。\n\n" +
            "严格要求:\n" +
            "- 输出语言严格遵守指定的「成稿语言」,用该语言的书面体撰写。\n" +
            "- 正文只用成稿语言的文字书写:中文稿不得出现日文假名;英文稿不得出现汉字与假名;日文稿除产品名外不得残留英文句子。\n" +
            "- 人物、公司、品牌等专有名词可保留笔记/术语表中的原文写法(上述文字限制的例外)。\n" +
            "- 章节标题必须依序为「议题与经过」「决定事项」「行动项」「未决与待议」;成稿语言非中文时翻译成该语言的等价标题;没有条目的章节明确写\"(无)\"。\n" +
            "- 行动项用表格输出,列为 负责人 / 内容 / 期限 / 出处;负责人不明时写\"待定\"。\n" +
            "- 每个条目末尾给出处,格式 `出处: mm:ss-mm:ss`;出处只允许使用笔记JSON中「出典」字段的值,不得编造。\n" +
            "- 不得添加笔记中没有的事实、推测或补充说明。\n" +
            "- 人名、产品名以术语表的正式写法统一(术语表没有的沿用笔记写法)。\n" +
            "- 开头放置元信息:会议时间(如有)、发言人数、使用语言、转写总时长。\n" +
            "- 只输出Markdown正文,不要用代码围栏包裹全文。",
        p2UserTpl = "【成稿语言】{language_name}\n\n" +
            "【会议信息】开始: {meeting_start} / 发言人数: {n_speakers} / 总时长: {total_duration}\n\n" +
            "【术语表(正式写法列表;人名、产品名的错误写法以此统一)】\n{glossary_lines}\n\n" +
            "【会议笔记JSON】\n{notes_json}\n\n" +
            "请根据以上内容输出会议纪要Markdown。",
    )
}

// ---- 流水线主体 --------------------------------------------------------------

class SummarizePipeline(
    private val engine: LlmEngine,
    private val prompts: Prompts,
) {
    companion object {
        private const val TAG = "sherpa-onnx"
        private const val CHUNK_TARGET = 2500     // §5:2500±500 字/块
        private const val CHUNK_MIN = 2000
        private const val CHUNK_MAX = 3000
        // P1 输入(笔记+块+固定文案)字符预算:超了就对半拆块,
        // 保证 ≤8192 ctx 永远够用(日语 1 字 ≈ 1 token 多一点)
        private const val P1_MAX_PROMPT_CHARS = 6500
        private const val NOTES_RESERVE = 1200    // 笔记+模板文案预留
        val EMPTY_NOTES =
            "{\"已定事項\":[],\"討論中\":[],\"行動項目\":[],\"人物\":[],\"前回末尾\":\"\"}"

        // 脚本占比判语种:假名出现即日语信号(日语里汉字占比也高,不能只看汉字);
        // 无假名时看汉字 vs 拉丁;全兜底 en。
        fun detectLanguage(text: String): String {
            var kana = 0
            var han = 0
            var latin = 0
            for (ch in text) {
                val cp = ch.code
                when {
                    cp in 0x3040..0x30FF || cp in 0x31F0..0x31FF || cp in 0xFF66..0xFF9F -> kana++
                    cp in 0x3400..0x4DBF || cp in 0x4E00..0x9FFF || cp in 0xF900..0xFAFF -> han++
                    cp in 0x41..0x5A || cp in 0x61..0x7A -> latin++
                }
            }
            return when {
                kana > 0 && kana * 20 >= kana + han -> "ja"     // 假名/汉字 ≥ 5%
                han >= latin && han > 0 -> "zh"
                else -> "en"
            }
        }

        fun languageName(lang: String) = when (lang) {
            "ja" -> "日本語"
            "zh" -> "中文(简体书面语)"
            else -> "English (formal written English)"
        }

        /** 笔记是否无任何实质条目(四类条目全空;"前回末尾"不算)。解析失败按空处理。 */
        internal fun notesEntriesEmpty(notes: String): Boolean = runCatching {
            val o = JSONObject(notes)
            listOf("已定事項", "討論中", "行動項目", "人物").all { k ->
                o.optJSONArray(k)?.length() == 0
            }
        }.getOrDefault(true)

        fun mmss(ms: Long): String {
            val t = ms / 1000
            return "%02d:%02d".format(t / 60, t % 60)
        }

        fun formatDate(wallMs: Long): String =
            java.text.SimpleDateFormat("yyyy-MM-dd HH:mm", java.util.Locale.US)
                .format(java.util.Date(wallMs))

        /** P2 成稿 user 提示词构造(滚动成稿与里程碑 1 共用,保证两路输出同构)。 */
        fun buildDraftUserPrompt(
            prompts: Prompts, lang: String, meetingStartWallMs: Long,
            nSpeakers: Int, totalDurMs: Long, glossary: String, notes: String,
        ): String = prompts.p2UserTpl
            .replace("{language_name}", languageName(lang))
            .replace("{meeting_start}", formatDate(meetingStartWallMs))
            .replace("{n_speakers}", nSpeakers.toString())
            .replace("{total_duration}", mmss(totalDurMs))
            .replace("{glossary_lines}", glossary.ifBlank { "(なし)" })
            .replace("{notes_json}", notes)

        // §5 分块铁律:句子边界聚合到 2500±500 字;块间重叠 1 句;
        // 同一说话人连续段(轮次)不拆开:切点落在同人连续段中间则延到段尾。
        // 另:超 P1 预算的块按行二分一次,保证 prompt ≤ ctx。

        /**
         * schema 键名别名表:中文系小模型常把日语/繁体键写成简体
         * (已定事项/行动项目…),不规范化则 extractJson 永远判失败——
         * 这正是"中文会议也解析不了"的头号嫌疑。
         */
        private val KEY_ALIASES = mapOf(
            "已定事项" to "已定事項", "讨论中" to "討論中",
            "行动项目" to "行動項目", "决定事项" to "已定事項",
            "待办事项" to "行動項目", "上次末尾" to "前回末尾",
        )

        internal fun normalizeKeys(o: JSONObject): JSONObject {
            for ((from, to) in KEY_ALIASES) {
                if (o.has(from) && !o.has(to)) o.put(to, o.remove(from))
            }
            return o
        }

        internal fun chunk(lines: List<String>): List<String> {
            val blocks = ArrayList<String>()
            var i = 0
            var overlap: String? = null
            while (i < lines.size) {
                var j = i
                var len = 0
                while (j < lines.size) {
                    val l = lines[j]
                    if (len > 0 && len + l.length > CHUNK_MAX) break
                    if (len >= CHUNK_TARGET) {
                        // 与上一句同一说话人 → 轮次未完,继续收
                        if (j == i || speakerOf(l) != speakerOf(lines[j - 1])) {
                            if (len >= CHUNK_MIN) break
                        }
                    }
                    len += l.length + 1
                    j++
                }
                if (j == i) j++     // 单句超长的极端情况:至少吞一句
                blocks.add(
                    StringBuilder().apply {
                        overlap?.let { append(it).append('\n') }
                        for (k in i until j) append(lines[k]).append('\n')
                    }.toString().trimEnd()
                )
                overlap = if (j < lines.size) lines[j - 1] else null
                i = j
            }

            val fine = ArrayList<String>()
            for (c in blocks) {
                if (c.length + NOTES_RESERVE <= P1_MAX_PROMPT_CHARS) {
                    fine.add(c)
                } else {
                    val ls = c.split('\n').filter { it.isNotBlank() }
                    val half = (ls.size / 2).coerceAtLeast(1)
                    val a = ls.subList(0, half).joinToString("\n")
                    val b = ls.subList(half, ls.size).joinToString("\n")
                    if (a.isNotBlank()) fine.add(a)
                    if (b.isNotBlank()) fine.add(b)
                }
            }
            return fine
        }

        private fun speakerOf(line: String): String {
            val a = line.indexOf('[')
            val b = line.indexOf(']', a + 1)
            return if (a >= 0 && b > a) line.substring(a, b) else line
        }

        // 笔记输出健壮性:取首个平衡 {...}(前后的客套话/代码围栏自然被忽略)、
        // 必需键检查
        internal fun extractJson(raw: String): String? {
            val start = raw.indexOf('{')
            if (start < 0) return null
            var depth = 0
            var inStr = false
            var esc = false
            for (i in start until raw.length) {
                val c = raw[i]
                if (esc) { esc = false; continue }
                when {
                    c == '\\' && inStr -> esc = true
                    c == '"' -> inStr = !inStr
                    !inStr && c == '{' -> depth++
                    !inStr && c == '}' -> {
                        depth--
                        if (depth == 0) {
                            val cand = raw.substring(start, i + 1)
                            return try {
                                // 键名先规范化(简体别名→schema),再校验必需键
                                val o = normalizeKeys(JSONObject(cand))
                                if (o.has("已定事項") && o.has("行動項目"))
                                    o.toString()
                                else null
                            } catch (t: Throwable) {
                                null
                            }
                        }
                    }
                }
            }
            return null
        }

        internal fun cleanDraft(md: String): String {
            var s = md.trim()
            if (s.startsWith("```")) {
                s = s.substringAfter('\n').substringBeforeLast("```")
            }
            s = s.replace(
                Regex("<\\|channel>thought.*?<channel\\|>", RegexOption.DOT_MATCHES_ALL), ""
            )
            // MiniCPM5 兜底:万一 think 块未被预填空掉仍然冒出来,一并剥除
            s = s.replace(Regex("<think>.*?</think>", RegexOption.DOT_MATCHES_ALL), "")
            s = s.replace(Regex("\n{3,}"), "\n\n")
            return s.trim()
        }

        /**
         * 输出语种纯度统计(2026-09-11 起只用于对账日志,不再触发整篇重写):
         *  zh  → 假名 > 8 个判违规;en → 汉字+假名 > 6 个判违规;ja → 不检查。
         * 返回违规样本描述,null = 通过。
         */
        internal fun scriptViolation(lang: String, text: String): String? {
            var kana = 0
            var han = 0
            var firstBad = -1
            for (i in text.indices) {
                val cp = text[i].code
                when {
                    cp in 0x3040..0x30FF || cp in 0xFF66..0xFF9F -> { kana++; if (firstBad < 0) firstBad = i }
                    cp in 0x3400..0x4DBF || cp in 0x4E00..0x9FFF || cp in 0xF900..0xFAFF -> {
                        han++
                        if (firstBad < 0) firstBad = i
                    }
                }
            }
            fun sample(): String = text.substring(
                firstBad, (firstBad + 16).coerceAtMost(text.length)
            ).replace("\n", " ")
            return when (lang) {
                "zh" -> if (kana > 8) "假名 $kana 个(如「${sample()}」)" else null
                "en" -> if (kana + han > 6) "中日文字 $han+$kana 个(around \"${sample()}\")" else null
                else -> null
            }
        }
    }

    /**
     * @param labelOf 内部说话人键(S{n}/真名)→ 显示名(已识别人N/真名/未识别)
     * @param entries SessionTranscript 快照(定格顺序,不可为空)
     * @param resumeNotes/resumeFromIndex M2:会中滚动笔记已覆盖前 resumeFromIndex 句,
     *        仅补跑尾部(进度、成稿复用同一份笔记)
     */
    fun run(
        labelOf: (String?) -> String,
        entries: List<TranscriptEntry>,
        meetingStartWallMs: Long,
        glossary: String,
        listener: SummarizeListener,
        resumeNotes: String? = null,
        resumeFromIndex: Int = 0,
    ): MeetingSummary {
        if (entries.isEmpty()) throw IllegalArgumentException("会议转写为空")
        val lang = detectLanguage(entries.joinToString("") { it.text })

        // ---- 分块(从断点句开始;断点前借 1 句做上下文衔接,同块间重叠规则)----
        val startIdx = resumeFromIndex.coerceIn(0, entries.size)
        fun renderLine(e: TranscriptEntry) = "(%s-%s)[%s] %s".format(
            mmss(e.startMs), mmss(e.endMs), labelOf(e.speaker), e.text.trim()
        )
        val lines = ArrayList<String>()
        if (startIdx > 0 && startIdx < entries.size) lines.add(renderLine(entries[startIdx - 1]))
        for (e in entries.drop(startIdx)) lines.add(renderLine(e))
        val chunks = chunk(lines)
        val total = chunks.size
        // 用户要求(2026-09-11):没有新句可消化(再点生成纪要,断点已覆盖全部
        // 转写)时不再空跑"成稿 0/0",直接提示并自动取消
        if (total == 0) {
            throw SummarizeEmptyException(if (resumeNotes != null)
                "本场会议没有新增转写,纪要已是最新"
            else "没有可分析的转写内容")
        }
        Log.i(TAG, "SUMMARIZE: ${entries.size} utterances -> $total chunks, " +
                "lang=$lang, resumeIdx=$startIdx")

        // ---- 滚动笔记(§5.2)----
        var notes = resumeNotes ?: EMPTY_NOTES
        var failed = 0
        val tP1Start = System.currentTimeMillis()
        chunks.forEachIndexed { idx, chunkText ->
            if (listener.isCancelled()) throw SummarizeCancelledException()
            val user = prompts.p1UserTpl
                .replace("{notes_json}", notes)
                .replace("{chunk_text}", chunkText)
            listener.onProgress("滚动笔记", idx + 1, total)
            val t0 = System.currentTimeMillis()
            var out = engine.generate(
                systemPrompt = prompts.p1System, userPrompt = user,
                maxNewTokens = 900, temperature = 0f,
            )
            var parsed = extractJson(out)
            // 空笔记视同失败:小模型吃不透指令时会把输入的空模板原样复读
            // (EMPTY 进 EMPTY 出)。首轮空结果带一次强约束重试再判。
            val emptyEcho = parsed != null && idx == 0 &&
                    resumeNotes == null && notesEntriesEmpty(parsed)
            if (parsed == null || emptyEcho) {
                // 一次修复重试:把畸形/空洞输出递回去(仍失败保留旧笔记,计 failed)
                if (listener.isCancelled()) throw SummarizeCancelledException()
                val why = if (emptyEcho)
                    "上一次输出是没有任何条目的空笔记。"
                else
                    "上一次输出不是合法JSON: " +
                        out.take(200).replace("\n", " ") + "。"
                val fix = user + "\n\n(" + why +
                    "请从【新的断片】中至少提取一条并合并,只输出修正后的笔记JSON," +
                    "禁止照抄输入笔记。)"
                out = engine.generate(
                    systemPrompt = prompts.p1System, userPrompt = fix,
                    maxNewTokens = 900, temperature = 0f,
                )
                val p2 = extractJson(out)
                if (p2 != null && !notesEntriesEmpty(p2)) parsed = p2
            }
            if (parsed != null) notes = parsed
            else {
                failed++
                // 诊断转储:解析失败时把模型原文头尾写进日志,归因不靠猜
                Log.w(TAG, "P1 chunk=${idx + 1} UNPARSABLE raw(${out.length}) " +
                        "head=[" + out.take(160).replace("\n", "\\n") + "] " +
                        "tail=[" + out.takeLast(60).replace("\n", "\\n") + "]")
                // 及时止损:第一块都解析不出来,笔记链条已断,后面块只会白烧 token
                if (idx == 0) {
                    throw SummarizeEmptyException("开头转写片段无法生成有效笔记(内容过少或输出不可解析)")
                }
            }
            // 测量点(baseline,不改行为):raw≫json 说明解码浪费在废话/思考上;
            // ms 是单块真实耗时,决定 diff 化/大块合并的参数
            Log.i(TAG, "P1 chunk=${idx + 1}/$total prompt_len=${user.length} " +
                    "raw=${out.length} json=${parsed?.length ?: 0} " +
                    "retry=${if (parsed == null || out.length < 1) 1 else 0} " +
                    "ms=${System.currentTimeMillis() - t0}")
        }
        Log.i(TAG, "P1 phase total_ms=${System.currentTimeMillis() - tP1Start} " +
                "chunks=$total failed=$failed")
        // 空笔记终检:全部块失败,或笔记仍是空壳(total==0 已在入口取消)
        if (failed == total || notesEntriesEmpty(notes)) {
            throw SummarizeEmptyException("整场转写未能形成任何笔记条目" +
                "(failed=$failed/$total, notes=" +
                notes.replace("\n", " ").take(120) + ")")
        }

        // ---- 成稿(§5.3)----
        if (listener.isCancelled()) throw SummarizeCancelledException()
        listener.onProgress("成稿", total, total)
        val nSpeakers = entries.map { it.speaker ?: "?" }.distinct().size
        val user2 = buildDraftUserPrompt(
            prompts, lang, meetingStartWallMs, nSpeakers,
            entries.last().endMs, glossary, notes
        )
        val tP2 = System.currentTimeMillis()
        val md = cleanDraft(engine.generate(
            systemPrompt = prompts.p2System, userPrompt = user2,
            maxNewTokens = 2500, temperature = 0.5f, topK = 64, topP = 0.95f,
        ))
        Log.i(TAG, "P2 draft prompt_len=${user2.length} draft_len=${md.length} " +
                "ms=${System.currentTimeMillis() - tP2}")
        // 语种"校正"(整篇重写)已按用户要求移除:识别是什么语言,纪要就存
        // 什么语言,不再为混语倾向多花一次 2500 token 生成。这里只留一行
        // 纯统计日志(零成本),纪要中的混语留给人工处理。
        val viol = scriptViolation(lang, md)
        if (viol != null) Log.i(TAG, "SUMMARIZE langcheck NOTE($lang): $viol (no rewrite)")
        if (md.isBlank()) throw SummarizeEmptyException("成稿输出为空")
        Log.i(TAG, "SUMMARIZE wall clock total_ms=${System.currentTimeMillis() - tP1Start}")
        return MeetingSummary(md, lang, notes, total, failed)
    }
}