#!/usr/bin/env python3
"""Generate Kotlin tables from csdk C headers (palette256, t2e)."""
import re, sys, io

CSDK = r"C:\Project\MAG160C\csdk\src"
OUT  = r"C:\Project\MAG160C\android\app\src\main\kotlin\com\mag160c\thermal\core\OfficialTables.kt"

def read(fn):
    with open(fn, encoding="utf-8") as f:
        return f.read()

def parse_matrix(text, rows=256):
    vals = []
    for m in re.finditer(r"\{\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\}", text):
        vals.append((int(m.group(3)), int(m.group(2)), int(m.group(1))))  # R,G,B from (B,G,R,0)
        if len(vals) == rows:
            break
    return vals

def parse_int32(text):
    body = text[text.index("{"):]
    return [int(x) for x in re.findall(r"-?\d+", body)]

pal_txt = read(rf"{CSDK}\mag160c_official_palette256.h")
t2e_txt = read(rf"{CSDK}\mag160c_official_t2e.h")
tables_txt = read(rf"{CSDK}\mag160c_tables.h")

pal = parse_matrix(pal_txt)
assert len(pal) == 256, f"palette entries: {len(pal)}"
t2e = parse_int32(t2e_txt)
assert len(t2e) == 646, f"t2e entries: {len(t2e)}"

# mag160c_t2e (274 entries, hex) + mag160c_e2t_acc_q10 (274 entries)
def parse_hex_array(text, name):
    m = re.search(rf"static const uint32_t {name}\[MAG160C_TEMP_CURVE_ENTRIES\] = \{{(.*?)\}};", text, re.S)
    assert m, name
    return [int(x, 16) for x in re.findall(r"0x[0-9a-fA-F]+", m.group(1))]

t2e274 = parse_hex_array(tables_txt, "mag160c_t2e")
assert len(t2e274) == 274, f"t2e274: {len(t2e274)}"
e2t = parse_hex_array(tables_txt, "mag160c_e2t_acc_q10")
assert len(e2t) == 274, f"e2t: {len(e2t)}"

# palette ARGB int per gray index
lines = []
lines.append("package com.mag160c.thermal.core")
lines.append("")
lines.append("/** Generated from csdk C headers by analysis/gen_kotlin_tables.py. DO NOT EDIT. */")
lines.append("object OfficialTables {")
lines.append("    /** Official default palette (256 gray levels -> ARGB int), source: CoreSDKLib dev+0xb18. */")
lines.append("    val PALETTE256_ARGB = intArrayBuilder {")
for i, (r, g, b) in enumerate(pal):
    argb = (0xFF << 24) | (r << 16) | (g << 8) | b
    lines.append(f"        add({argb}) // {i}")
lines.append("    }")
lines.append("")
lines.append("    /** Official T2E table (646 int32), temp = slope*diff>>12 + (i<<12) - 0x249f0. */")
lines.append("    val T2E = intArrayBuilder {")
for i in range(0, len(t2e), 8):
    chunk = t2e[i:i+8]
    lines.append("        add(" + ", ".join(str(v) for v in chunk) + (")" if i + 8 >= len(t2e) else ""))
lines.append("    }")
lines.append("}")
kt = "\n".join(lines) + "\n"

# intArrayBuilder trick is overkill; use direct arrays with chunked lines instead.
argb_lines = []
def signed(v):
    return v if v < 2**31 else v - 2**32
for i in range(0, len(pal), 6):
    row = ", ".join(str(signed((0xFF << 24) | (r << 16) | (g << 8) | b)) for (r, g, b) in pal[i:i+6])
    argb_lines.append("        " + row + ",")
t2e_lines = []
for i in range(0, len(t2e), 8):
    row = ", ".join(str(v) for v in t2e[i:i+8])
    t2e_lines.append("        " + row + ("," if i + 8 < len(t2e) else ""))

t2e274_lines = []
for i in range(0, len(t2e274), 8):
    row = ", ".join(f"0x{v:08x}" for v in t2e274[i:i+8])
    t2e274_lines.append("        " + row + ("," if i + 8 < len(t2e274) else ""))

e2t_lines = []
for i in range(0, len(e2t), 8):
    row = ", ".join(f"0x{v:08x}" for v in e2t[i:i+8])
    e2t_lines.append("        " + row + ("," if i + 8 < len(e2t) else ""))

kt = f"""package com.mag160c.thermal.core

/** Generated from csdk C headers by analysis/gen_kotlin_tables.py. DO NOT EDIT. */
object OfficialTables {{
    /** Official default palette: 256 gray levels -> ARGB int (from CoreSDKLib dev+0xb18, B,G,R order swapped). */
    val PALETTE256_ARGB = intArrayOf(
{chr(10).join(argb_lines)}
    )

    /** Official T2E table (646 int32): temp = slope*diff>>12 + (i<<12) - 0x249f0. */
    val T2E = intArrayOf(
{chr(10).join(t2e_lines)}
    )

    /** Vendor T2E curve from libcoresdk.so ARM64 @0x402010 (274 uint32 entries). */
    val T2E274 = intArrayOf(
{chr(10).join(t2e274_lines)}
    )

    /** Vendor E2TAccQ10 curve from libcoresdk.so ARM64 @0x40245c (274 uint32 entries). */
    val E2T_ACC_Q10 = intArrayOf(
{chr(10).join(e2t_lines)}
    )
}}
"""
with open(OUT, "w", encoding="utf-8", newline="\n") as f:
    f.write(kt)
print(f"written {OUT}: palette {len(pal)} entries, t2e {len(t2e)} entries")