#!/usr/bin/env python3
"""Check the emulator's default palette against the one in VERA's bitstream.

VERA's palette RAM is initialised at configuration time from a Lattice memory
file, fpga/source/palette_ram.mem, baked into the FPGA bitstream. That makes
the default palette a property of the hardware rather than a convention the
ROM establishes, so src/video.c's default_palette[] is checkable against it
entry for entry.

    python tests/check_vera_palette.py

Skips when the RTL has not been fetched. Nothing in the suite requires the
reference to be present -- run tests/fetch_vera_rtl.py to get it. CI does
fetch it, and sets X16_VERA_RTL_REQUIRED so that a broken fetch is a failure
rather than a silent skip, the same way X16_KLAUS_REQUIRED works.

WHY THIS IS A SCRIPT AND NOT A C TEST
-------------------------------------
The palette the renderer uses lives in a static array with no accessor, and
the only path to it is rendered pixels, which need the framebuffer. Comparing
the two declarations needs neither. It also catches an entry being edited by
hand, which is the way a 256-entry table actually goes wrong.

WHAT THIS DOES NOT CHECK
------------------------
How a 4-bit channel becomes an 8-bit one. video.c:792-794 replicates the
nibble, so 0xF becomes 0xFF. The RTL cannot settle that: video_vga.v declares
vga_r, vga_g and vga_b as [3:0] and assigns palette_rgb_data[11:8] etc.
straight to them, so the hardware terminates at four bits per channel and the
expansion is the emulator's own presentation choice. Asserting it against the
Verilog would be inventing an oracle.
"""

import os
import re
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
VIDEO_C = ROOT / "src" / "video.c"
MEM = ROOT / "tests" / "vera-rtl" / "palette_ram.mem"

ENTRIES = 256


def required():
    v = os.environ.get("X16_VERA_RTL_REQUIRED")
    return v is not None and v not in ("", "0")


def emulator_palette():
    src = VIDEO_C.read_text(encoding="utf-8", errors="replace")
    m = re.search(r"default_palette\[\]\s*=\s*\{(.*?)\}\s*;", src, re.S)
    if not m:
        print(f"FAIL: default_palette[] not found in {VIDEO_C}")
        return None
    return [int(v, 16) for v in re.findall(r"0x([0-9a-fA-F]+)", m.group(1))]


def rtl_palette():
    out = []
    for lineno, line in enumerate(MEM.read_text(encoding="utf-8").splitlines(), 1):
        line = line.strip()
        if not line:
            continue
        try:
            out.append(int(line, 16))
        except ValueError:
            print(f"FAIL: {MEM.name}:{lineno} is not a hex word: {line!r}")
            return None
    return out


def main():
    if not MEM.exists():
        if required():
            print(f"FAIL: {MEM.name} not present and X16_VERA_RTL_REQUIRED is set")
            print("      Run tests/fetch_vera_rtl.py. A skip here would leave the")
            print("      default palette unchecked on a green run.")
            return 1
        print(f"skip: {MEM.name} not present (run tests/fetch_vera_rtl.py)")
        return 0

    emu = emulator_palette()
    rtl = rtl_palette()
    if emu is None or rtl is None:
        return 1

    ok = True

    # Counted separately from the comparison. Two tables of different lengths
    # would otherwise compare equal over the shorter one and say nothing about
    # the rest.
    for name, got in (("video.c", len(emu)), (MEM.name, len(rtl))):
        if got != ENTRIES:
            print(f"FAIL: {name} holds {got} entries, expected {ENTRIES}")
            ok = False
    if not ok:
        return 1

    mismatches = 0
    for i, (a, b) in enumerate(zip(emu, rtl)):
        if a != b:
            mismatches += 1
            if mismatches <= 8:
                print(f"FAIL: entry {i} ($1FA{i * 2:02X}): video.c 0x{a:03x}, RTL 0x{b:03x}")
    if mismatches > 8:
        print(f"      and {mismatches - 8} more")

    if mismatches:
        print(f"FAIL: {mismatches} of {ENTRIES} palette entries differ")
        return 1

    print(f"ok  : all {ENTRIES} default palette entries match palette_ram.mem")
    return 0


if __name__ == "__main__":
    sys.exit(main())