"""Parser for FBNeo source files to extract BIOS sets and ROM definitions.

Parses BurnRomInfo structs (static ROM arrays) and BurnDriver structs
(driver registration) from FBNeo C source files. BIOS sets are identified
by the BDF_BOARDROM flag in BurnDriver definitions.
"""

from __future__ import annotations

import os
import re
from pathlib import Path

_ROM_ENTRY_RE = re.compile(
    r'\{\s*"([^"]+)"\s*,\s*(0x[\da-fA-F]+)\s*,\s*(0x[\da-fA-F]+)\s*,\s*([^}]+)\}',
)

_BURN_DRIVER_RE = re.compile(
    r"struct\s+BurnDriver\s+BurnDrv(\w+)\s*=\s*\{(.*?)\};",
    re.DOTALL,
)

_ROM_DESC_RE = re.compile(
    r"static\s+struct\s+BurnRomInfo\s+(\w+)RomDesc\s*\[\s*\]\s*=\s*\{(.*?)\};",
    re.DOTALL,
)


def find_bios_sets(source: str, filename: str) -> dict[str, dict]:
    """Find BDF_BOARDROM drivers in source code.

    Returns a dict mapping set name to metadata:
        {set_name: {"source_file": str, "source_line": int}}
    """
    results: dict[str, dict] = {}

    for match in _BURN_DRIVER_RE.finditer(source):
        body = match.group(2)
        if "BDF_BOARDROM" not in body:
            continue

        # Set name is the first quoted string in the struct body
        name_match = re.search(r'"([^"]+)"', body)
        if not name_match:
            continue

        set_name = name_match.group(1)
        line_num = source[: match.start()].count("\n") + 1

        results[set_name] = {
            "source_file": filename,
            "source_line": line_num,
        }

    return results


def parse_rom_info(source: str, set_name: str) -> list[dict]:
    """Parse a BurnRomInfo array for the given set name.

    Returns a list of dicts with keys: name, size, crc32.
    Sentinel entries (empty name) are skipped.
    """
    pattern = re.compile(
        r"static\s+struct\s+BurnRomInfo\s+"
        + re.escape(set_name)
        + r"RomDesc\s*\[\s*\]\s*=\s*\{(.*?)\};",
        re.DOTALL,
    )
    match = pattern.search(source)
    if not match:
        return []

    body = match.group(1)
    roms: list[dict] = []

    for entry in _ROM_ENTRY_RE.finditer(body):
        name = entry.group(1)
        if not name:
            continue
        size = int(entry.group(2), 16)
        crc32 = format(int(entry.group(3), 16), "08x")

        roms.append(
            {
                "name": name,
                "size": size,
                "crc32": crc32,
            }
        )

    return roms


def parse_fbneo_source_tree(base_path: str) -> dict[str, dict]:
    """Walk the FBNeo driver source tree and extract all BIOS sets.

    Scans .cpp files under src/burn/drv/ for BDF_BOARDROM drivers,
    then parses their associated BurnRomInfo arrays.

    Returns a dict mapping set name to:
        {source_file, source_line, roms: [{name, size, crc32}, ...]}
    """
    drv_path = Path(base_path) / "src" / "burn" / "drv"
    if not drv_path.is_dir():
        return {}

    results: dict[str, dict] = {}

    for root, _dirs, files in os.walk(drv_path):
        for fname in files:
            if not fname.endswith(".cpp"):
                continue

            filepath = Path(root) / fname
            source = filepath.read_text(encoding="utf-8", errors="replace")
            rel_path = str(filepath.relative_to(base_path))

            bios_sets = find_bios_sets(source, rel_path)
            for set_name, meta in bios_sets.items():
                roms = parse_rom_info(source, set_name)
                results[set_name] = {
                    "source_file": meta["source_file"],
                    "source_line": meta["source_line"],
                    "roms": roms,
                }

    return results