"""Parser for MAME C source files.

Extracts BIOS root sets and ROM definitions from MAME driver sources.
Handles GAME/SYST/COMP/CONS macros with MACHINE_IS_BIOS_ROOT flag,
ROM_START/ROM_END blocks, ROM_LOAD variants, ROM_REGION, ROM_SYSTEM_BIOS,
NO_DUMP filtering, and BAD_DUMP flagging.
"""

from __future__ import annotations

import os
import re
from pathlib import Path

# Macros that declare a machine entry
_MACHINE_MACROS = re.compile(
    r"\b(GAME|SYST|COMP|CONS)\s*\(",
    re.MULTILINE,
)

# ROM block boundaries
_ROM_START = re.compile(r"ROM_START\s*\(\s*(\w+)\s*\)")
_ROM_END = re.compile(r"ROM_END")

# ROM_REGION variants: ROM_REGION, ROM_REGION16_BE, ROM_REGION16_LE, ROM_REGION32_LE, etc.
_ROM_REGION = re.compile(
    r"ROM_REGION\w*\s*\("
    r"\s*(0x[\da-fA-F]+|\d+)\s*,"  # size
    r'\s*"([^"]+)"\s*,',  # tag
)

# ROM_SYSTEM_BIOS( index, label, description )
_ROM_SYSTEM_BIOS = re.compile(
    r"ROM_SYSTEM_BIOS\s*\("
    r"\s*(\d+)\s*,"  # index
    r'\s*"([^"]+)"\s*,'  # label
    r'\s*"([^"]+)"\s*\)',  # description
)

# All ROM_LOAD variants including custom BIOS macros.
# Standard: ROM_LOAD("name", offset, size, hash)
# BIOS variant: ROM_LOAD_BIOS(biosidx, "name", offset, size, hash)
# ROM_LOAD16_WORD_SWAP_BIOS(biosidx, "name", offset, size, hash)
# The key pattern: any macro containing "ROM_LOAD" or "ROMX_LOAD" in its name,
# with the first quoted string being the ROM filename.
_ROM_LOAD = re.compile(
    r"\b\w*ROMX?_LOAD\w*\s*\("
    r'[^"]*'  # skip any args before the filename (e.g., bios index)
    r'"([^"]+)"\s*,'  # name (first quoted string)
    r"\s*(0x[\da-fA-F]+|\d+)\s*,"  # offset
    r"\s*(0x[\da-fA-F]+|\d+)\s*,",  # size
)

# CRC32 and SHA1 within a ROM_LOAD line
_CRC_SHA = re.compile(
    r"CRC\s*\(\s*([0-9a-fA-F]+)\s*\)"
    r"\s+"
    r"SHA1\s*\(\s*([0-9a-fA-F]+)\s*\)",
)

_NO_DUMP = re.compile(r"\bNO_DUMP\b")
_BAD_DUMP = re.compile(r"\bBAD_DUMP\b")
_ROM_BIOS = re.compile(r"ROM_BIOS\s*\(\s*(\d+)\s*\)")


def find_bios_root_sets(source: str, filename: str) -> dict[str, dict]:
    """Find machine entries flagged as BIOS root sets.

    Scans for GAME/SYST/COMP/CONS macros where the args include
    MACHINE_IS_BIOS_ROOT, returns set names with source location.
    """
    results: dict[str, dict] = {}

    for match in _MACHINE_MACROS.finditer(source):
        start = match.end() - 1  # position of opening paren
        block_end = _find_closing_paren(source, start)
        if block_end == -1:
            continue

        block = source[start : block_end + 1]
        if "MACHINE_IS_BIOS_ROOT" not in block:
            continue

        # Extract set name: first arg after the opening paren
        inner = block[1:]  # skip opening paren
        args = _split_macro_args(inner)
        if not args:
            continue

        # The set name position varies by macro type
        # GAME(year, setname, parent, machine, input, init, monitor, company, fullname, flags)
        # CONS(year, setname, parent, compat, machine, input, init, company, fullname, flags)
        # COMP(year, setname, parent, compat, machine, input, init, company, fullname, flags)
        # SYST(year, setname, parent, compat, machine, input, init, company, fullname, flags)
        # In all cases, setname is the second arg (index 1)
        if len(args) < 2:
            continue

        set_name = args[1].strip()
        line_no = source[: match.start()].count("\n") + 1

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

    return results


def parse_rom_block(source: str, set_name: str) -> list[dict]:
    """Parse ROM definitions for a given set name.

    Finds the ROM_START(set_name)...ROM_END block, expands local
    #define macros that contain ROM_LOAD/ROM_REGION calls, then
    extracts all ROM entries. Skips NO_DUMP, flags BAD_DUMP.
    """
    pattern = re.compile(
        r"ROM_START\s*\(\s*" + re.escape(set_name) + r"\s*\)",
    )
    start_match = pattern.search(source)
    if not start_match:
        return []

    end_match = _ROM_END.search(source, start_match.end())
    if not end_match:
        return []

    block = source[start_match.end() : end_match.start()]

    # Pre-expand macros: find #define macros in the file that contain
    # ROM_LOAD/ROM_REGION/ROM_SYSTEM_BIOS calls, then expand their
    # invocations within the ROM block.
    macros = _collect_rom_macros(source)
    block = _expand_macros(block, macros, depth=5)

    return _parse_rom_entries(block)


def parse_mame_source_tree(base_path: str) -> dict[str, dict]:
    """Walk MAME source tree and extract all BIOS root sets with ROMs.

    Scans src/mame/ and src/devices/ for C/C++ source files.
    """
    results: dict[str, dict] = {}
    root = Path(base_path)

    search_dirs = [root / "src" / "mame", root / "src" / "devices"]

    for search_dir in search_dirs:
        if not search_dir.is_dir():
            continue
        for dirpath, _dirnames, filenames in os.walk(search_dir):
            for fname in filenames:
                if not fname.endswith((".cpp", ".c", ".h", ".hxx")):
                    continue
                filepath = Path(dirpath) / fname
                rel_path = str(filepath.relative_to(root))
                content = filepath.read_text(encoding="utf-8", errors="replace")

                bios_sets = find_bios_root_sets(content, rel_path)
                for set_name, info in bios_sets.items():
                    roms = parse_rom_block(content, set_name)
                    results[set_name] = {
                        "source_file": info["source_file"],
                        "source_line": info["source_line"],
                        "roms": roms,
                    }

    return results


# Regex for #define macros that span multiple lines (backslash continuation)
_DEFINE_RE = re.compile(
    r"^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s*((?:.*\\\n)*.*)",
    re.MULTILINE,
)

# ROM-related tokens that indicate a macro is relevant for expansion
_ROM_TOKENS = {
    "ROM_LOAD",
    "ROMX_LOAD",
    "ROM_REGION",
    "ROM_SYSTEM_BIOS",
    "ROM_FILL",
    "ROM_COPY",
    "ROM_RELOAD",
}


def _collect_rom_macros(source: str) -> dict[str, str]:
    """Collect #define macros that contain ROM-related calls.

    Returns {macro_name: expanded_body} with backslash continuations joined.
    Only collects macros that contain actual ROM data (quoted filenames),
    not wrapper macros like ROM_LOAD16_WORD_SWAP_BIOS that just redirect
    to ROMX_LOAD with formal parameters.
    """
    macros: dict[str, str] = {}
    for m in _DEFINE_RE.finditer(source):
        name = m.group(1)
        body = m.group(2)
        # Join backslash-continued lines
        body = body.replace("\\\n", " ")
        # Only keep macros that contain ROM-related tokens
        if not any(tok in body for tok in _ROM_TOKENS):
            continue
        # Skip wrapper macros: if the body contains ROMX_LOAD/ROM_LOAD
        # with unquoted args (formal parameters), it's a wrapper.
        # These are already recognized by the _ROM_LOAD regex directly.
        if re.search(r"ROMX?_LOAD\s*\(\s*\w+\s*,\s*\w+\s*,", body):
            continue
        macros[name] = body
    return macros


def _expand_macros(block: str, macros: dict[str, str], depth: int = 5) -> str:
    """Expand macro invocations in a ROM block.

    Handles both simple macros (NEOGEO_BIOS) and parameterized ones
    (NEOGEO_UNIBIOS_2_2_AND_NEWER(16)). Recurses up to `depth` levels
    for nested macros.
    """
    if depth <= 0 or not macros:
        return block

    changed = True
    iterations = 0
    while changed and iterations < depth:
        changed = False
        iterations += 1
        for name, body in macros.items():
            # Match macro invocation: NAME or NAME(args)
            pattern = re.compile(r"\b" + re.escape(name) + r"(?:\s*\([^)]*\))?")
            if pattern.search(block):
                block = pattern.sub(body, block)
                changed = True

    return block


def _find_closing_paren(source: str, start: int) -> int:
    """Find the matching closing paren for source[start] which must be '('."""
    depth = 0
    i = start
    while i < len(source):
        ch = source[i]
        if ch == "(":
            depth += 1
        elif ch == ")":
            depth -= 1
            if depth == 0:
                return i
        elif ch == '"':
            i += 1
            while i < len(source) and source[i] != '"':
                i += 1
        i += 1
    return -1


def _split_macro_args(inner: str) -> list[str]:
    """Split macro arguments respecting nested parens and strings."""
    args: list[str] = []
    depth = 0
    current: list[str] = []

    i = 0
    while i < len(inner):
        ch = inner[i]
        if ch == '"':
            current.append(ch)
            i += 1
            while i < len(inner) and inner[i] != '"':
                current.append(inner[i])
                i += 1
            if i < len(inner):
                current.append(inner[i])
        elif ch == "(":
            depth += 1
            current.append(ch)
        elif ch == ")":
            if depth == 0:
                args.append("".join(current))
                break
            depth -= 1
            current.append(ch)
        elif ch == "," and depth == 0:
            args.append("".join(current))
            current = []
        else:
            current.append(ch)
        i += 1

    if current:
        remaining = "".join(current).strip()
        if remaining:
            args.append(remaining)

    return args


def _parse_rom_entries(block: str) -> list[dict]:
    """Parse ROM entries from a ROM block (content between ROM_START and ROM_END).

    Uses regex scanning over the entire block (not line-by-line) to handle
    macro-expanded content where multiple statements may be on one line.
    Processes matches in order of appearance to track region and BIOS context.
    """
    roms: list[dict] = []
    current_region = ""
    bios_labels: dict[int, tuple[str, str]] = {}

    # Build a combined pattern that matches all interesting tokens
    # and process them in order of occurrence
    token_patterns = [
        ("region", _ROM_REGION),
        ("bios_label", _ROM_SYSTEM_BIOS),
        ("rom_load", _ROM_LOAD),
    ]

    # Collect all matches with their positions
    events: list[tuple[int, str, re.Match]] = []
    for tag, pat in token_patterns:
        for m in pat.finditer(block):
            events.append((m.start(), tag, m))

    # Sort by position in block
    events.sort(key=lambda e: e[0])

    for _pos, tag, m in events:
        if tag == "region":
            current_region = m.group(2)
        elif tag == "bios_label":
            idx = int(m.group(1))
            bios_labels[idx] = (m.group(2), m.group(3))
        elif tag == "rom_load":
            # Get the full macro call as context (find closing paren)
            context_start = m.start()
            # Find the opening paren of the ROM_LOAD macro
            paren_pos = block.find("(", context_start)
            if paren_pos != -1:
                close_pos = _find_closing_paren(block, paren_pos)
                context_end = close_pos + 1 if close_pos != -1 else m.end() + 200
            else:
                context_end = m.end() + 200
            context = block[context_start : min(context_end, len(block))]

            if _NO_DUMP.search(context):
                continue

            rom_name = m.group(1)
            rom_size = _parse_int(m.group(3))

            crc_sha_match = _CRC_SHA.search(context)
            crc32 = ""
            sha1 = ""
            if crc_sha_match:
                crc32 = crc_sha_match.group(1).lower()
                sha1 = crc_sha_match.group(2).lower()

            bad_dump = bool(_BAD_DUMP.search(context))

            bios_index = None
            bios_label = ""
            bios_description = ""
            bios_ref = _ROM_BIOS.search(context)
            if bios_ref:
                bios_index = int(bios_ref.group(1))
                if bios_index in bios_labels:
                    bios_label, bios_description = bios_labels[bios_index]

            entry: dict = {
                "name": rom_name,
                "size": rom_size,
                "crc32": crc32,
                "sha1": sha1,
                "region": current_region,
                "bad_dump": bad_dump,
            }

            if bios_index is not None:
                entry["bios_index"] = bios_index
                entry["bios_label"] = bios_label
                entry["bios_description"] = bios_description

            roms.append(entry)

    return roms


def _parse_int(value: str) -> int:
    """Parse an integer that may be hex (0x...) or decimal."""
    value = value.strip()
    if value.startswith("0x") or value.startswith("0X"):
        return int(value, 16)
    return int(value)