package pw.binom.llmproxy

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.datetime.Clock
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive

/**
 * SHA-256, чистая реализация на commonMain (без внешних зависимостей —
 * KMP-зеркало их не отдаёт). Нужен для стабильного хэша префиксов истории.
 */
internal object Sha256 {
    private val K = intArrayOf(
        0x428a2f98, 0x71374491, 0xb5c0fbcf.toInt(), 0xe9b5dba5.toInt(), 0x3956c25b, 0x59f111f1, 0x923f82a4.toInt(), 0xab1c5ed5.toInt(),
        0xd807aa98.toInt(), 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe.toInt(), 0x9bdc06a7.toInt(), 0xc19bf174.toInt(),
        0xe49b69c1.toInt(), 0xefbe4786.toInt(), 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
        0x983e5152.toInt(), 0xa831c66d.toInt(), 0xb00327c8.toInt(), 0xbf597fc7.toInt(), 0xc6e00bf3.toInt(), 0xd5a79147.toInt(), 0x06ca6351, 0x14292967,
        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e.toInt(), 0x92722c85.toInt(),
        0xa2bfe8a1.toInt(), 0xa81a664b.toInt(), 0xc24b8b70.toInt(), 0xc76c51a3.toInt(), 0xd192e819.toInt(), 0xd6990624.toInt(), 0xf40e3585.toInt(), 0x106aa070,
        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
        0x748f82ee, 0x78a5636f, 0x84c87814.toInt(), 0x8cc70208.toInt(), 0x90befffa.toInt(), 0xa4506ceb.toInt(), 0xbef9a3f7.toInt(), 0xc67178f2.toInt(),
    )

    private fun rotr(x: Int, n: Int): Int = (x ushr n) or (x shl (32 - n))

    private fun pad(input: ByteArray): ByteArray {
        val total = ((input.size + 9 + 63) / 64) * 64
        val out = ByteArray(total)
        input.copyInto(out)
        out[input.size] = 0x80.toByte()
        val bits = input.size.toLong() * 8
        for (k in 0 until 8) {
            out[total - 1 - k] = (bits ushr (8 * k)).toByte()
        }
        return out
    }

    fun hash(input: ByteArray): ByteArray {
        val msg = pad(input)
        val h = intArrayOf(
            0x6a09e667, 0xbb67ae85.toInt(), 0x3c6ef372, 0xa54ff53a.toInt(),
            0x510e527f, 0x9b05688c.toInt(), 0x1f83d9ab, 0x5be0cd19,
        )
        val w = IntArray(64)
        var i = 0
        while (i < msg.size) {
            for (j in 0 until 16) {
                w[j] = ((msg[i + j * 4].toInt() and 0xff) shl 24) or
                    ((msg[i + j * 4 + 1].toInt() and 0xff) shl 16) or
                    ((msg[i + j * 4 + 2].toInt() and 0xff) shl 8) or
                    (msg[i + j * 4 + 3].toInt() and 0xff)
            }
            for (j in 16 until 64) {
                val s0 = rotr(w[j - 15], 7) xor rotr(w[j - 15], 18) xor (w[j - 15] ushr 3)
                val s1 = rotr(w[j - 2], 17) xor rotr(w[j - 2], 19) xor (w[j - 2] ushr 10)
                w[j] = w[j - 16] + s0 + w[j - 7] + s1
            }
            var a = h[0]; var b = h[1]; var c = h[2]; var d = h[3]
            var e = h[4]; var f = h[5]; var g = h[6]; var hh = h[7]
            for (j in 0 until 64) {
                val s1 = rotr(e, 6) xor rotr(e, 11) xor rotr(e, 25)
                val ch = (e and f) xor (e.inv() and g)
                val t1 = hh + s1 + ch + K[j] + w[j]
                val s0 = rotr(a, 2) xor rotr(a, 13) xor rotr(a, 22)
                val maj = (a and b) xor (a and c) xor (b and c)
                val t2 = s0 + maj
                hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2
            }
            h[0] += a; h[1] += b; h[2] += c; h[3] += d
            h[4] += e; h[5] += f; h[6] += g; h[7] += hh
            i += 64
        }
        val out = ByteArray(32)
        for (j in 0 until 8) {
            out[j * 4] = (h[j] ushr 24).toByte()
            out[j * 4 + 1] = (h[j] ushr 16).toByte()
            out[j * 4 + 2] = (h[j] ushr 8).toByte()
            out[j * 4 + 3] = h[j].toByte()
        }
        return out
    }
}

private const val HEX = "0123456789abcdef"

/** SHA-256 строки (UTF-8) в нижнем hex. */
internal fun sha256Hex(text: String): String {
    val bytes = Sha256.hash(text.encodeToByteArray())
    val sb = StringBuilder(bytes.size * 2)
    for (b in bytes) {
        val v = b.toInt() and 0xff
        sb.append(HEX[v ushr 4]).append(HEX[v and 0xf])
    }
    return sb.toString()
}

/**
 * Инкрементальные префикс-хэши истории: H_i = sha256(H_{i-1} + "\u0000" + msg_i).
 *
 * Цепочка начинается с первого `user`-сообщения: system-промпт обычно
 * идентичен у всех сессий одного клиента и как признак сессии бесполезен
 * (иначе LCP склеивает все сессии на общем префиксе `[system]`).
 * Если `messages` нет/пусто — fallback на хэш всего тела.
 */
internal fun sessionPrefixHashes(body: JsonObject): List<String> {
    val messages = body["messages"] as? JsonArray
    if (messages == null || messages.isEmpty()) {
        return listOf(sha256Hex(body.toString()))
    }

    fun roleAt(i: Int): String? =
        ((messages[i] as? JsonObject)?.get("role") as? JsonPrimitive)?.content

    var start = messages.indices.firstOrNull { roleAt(it) == "user" }
        ?: messages.indices.firstOrNull { roleAt(it) != "system" }
        ?: 0

    val res = ArrayList<String>(messages.size - start)
    var prev = ""
    for (i in start until messages.size) {
        prev = sha256Hex(prev + "\u0000" + messages[i].toString())
        res.add(prev)
    }
    return res
}

/**
 * Реестр сессий: id сессии определяется наибольшим общим префиксом (LCP)
 * присланной истории. Для префиксов, которые уже встречались, возвращается
 * id исходной сессии; иначе создаётся новая (id = хэш всей истории).
 *
 * Таблица ограничена по размеру (LRU) и времени жизни (TTL). Доступ под
 * Mutex: параллельные запросы одной сессии не должны гонять состояние.
 */
class SessionRegistry(
    private val maxSessions: Int = 1000,
    private val ttlMillis: Long = 6 * 60 * 60 * 1000L,
) {
    private class Entry(val prefixes: MutableSet<String>) {
        var lastAccess: Long = 0
    }

    private val mutex = Mutex()
    private val prefixToSession = mutableMapOf<String, String>()

    /** В порядке доступа: голова — самая давняя, хвост — свежая. */
    private val sessions = LinkedHashMap<String, Entry>()

    suspend fun resolve(prefixHashes: List<String>): String? =
        mutex.withLock { resolveLocked(prefixHashes, Clock.System.now().toEpochMilliseconds()) }

    /** Синхронная (без блокировки) версия — для тестов и вызовов под mutex. */
    internal fun resolveLocked(prefixHashes: List<String>, now: Long): String? {
        if (prefixHashes.isEmpty()) return null
        evictExpired(now)

        var found: String? = null
        for (i in prefixHashes.indices.reversed()) {
            val s = prefixToSession[prefixHashes[i]]
            if (s != null) {
                found = s
                break
            }
        }
        val id = found ?: prefixHashes.last()

        val entry = sessions.remove(id) ?: Entry(mutableSetOf())
        for (h in prefixHashes) {
            val prev = prefixToSession.put(h, id)
            if (prev != null && prev != id) {
                sessions[prev]?.prefixes?.remove(h)
            }
            entry.prefixes.add(h)
        }
        entry.lastAccess = now
        sessions[id] = entry
        evictOverflow()
        return id
    }

    private fun drop(sessionId: String, entry: Entry) {
        entry.prefixes.forEach { h -> if (prefixToSession[h] == sessionId) prefixToSession.remove(h) }
    }

    private fun evictExpired(now: Long) {
        val it = sessions.entries.iterator()
        while (it.hasNext()) {
            val e = it.next()
            if (now - e.value.lastAccess <= ttlMillis) break
            drop(e.key, e.value)
            it.remove()
        }
    }

    private fun evictOverflow() {
        val it = sessions.entries.iterator()
        while (sessions.size > maxSessions && it.hasNext()) {
            val e = it.next()
            drop(e.key, e.value)
            it.remove()
        }
    }
}