"""flat_kv.py -- readers for the flat 'KEY value' tuning tables and the
whitespace-positional tables under Data/, Weapons/, Badges/, Avatars/, GUI/.

Two shapes exist:

  parse_kv(text)    KEY value            -> {KEY: value}
                    one constant per line; value is a bareword or a
                    "quoted string"; '//' comments; colors are quoted
                    "r g b" (use color()).  Files: Data/globals.txt,
                    Data/species.txt, Data/Strategy/StrategyVars.txt,
                    Data/Combat/*.txt (most), Data/encounters.txt, ...

  parse_rows(text)  tok tok tok ...      -> [[tok, ...], ...]
                    one record per line, whitespace separated, quoted
                    tokens may contain spaces; '//' comments.  Files:
                    Weapons/_turrets.txt, Weapons/_defaultweapons.txt,
                    Data/Combat/damfx*.txt, Data/Strategy/playercolors.txt,
                    Badges/BadgeTable.txt, Avatars/AvatarTable.txt,
                    GUI/WeaponIconPlacements.txt

Quirks handled: '//' inside a quoted value is not a comment; a quoted
value may be empty (""); keys repeat in a few files (kept as list);
duplicate-key detection is exposed via parse_kv(..., on_dup=).

Stdlib only.
"""
from __future__ import annotations

import re
from typing import Any

from mars_data import coerce

__all__ = ["parse_kv", "parse_rows", "duplicates", "color", "strip_comment",
           "split_tokens", "parse_kv_file", "parse_rows_file"]

_TOK_RE = re.compile(r'"([^"]*)"|(\S+)')


def strip_comment(line: str) -> str:
    """Remove a trailing // comment, ignoring // inside double quotes."""
    in_q = False
    i = 0
    n = len(line)
    while i < n:
        c = line[i]
        if c == '"':
            in_q = not in_q
        elif c == "/" and not in_q and line.startswith("//", i):
            return line[:i]
        i += 1
    return line


def split_tokens(line: str) -> list[tuple[str, bool]]:
    """Split a line into (token, was_quoted) pairs."""
    out = []
    for m in _TOK_RE.finditer(line):
        if m.group(1) is not None:
            out.append((m.group(1), True))
        else:
            out.append((m.group(2), False))
    return out


def parse_rows(text: str, *, typed: bool = True) -> list[list[Any]]:
    rows = []
    for raw in text.splitlines():
        line = strip_comment(raw).strip()
        if not line:
            continue
        toks = split_tokens(line)
        rows.append([coerce(t) if (typed and not q) else t for t, q in toks])
    return rows


def _pairs(text: str, typed: bool):
    for lineno, raw in enumerate(text.splitlines(), 1):
        line = strip_comment(raw).strip()
        if not line:
            continue
        toks = split_tokens(line)
        key = toks[0][0]
        vals = [coerce(t) if (typed and not q) else t for t, q in toks[1:]]
        val: Any = None if not vals else (vals[0] if len(vals) == 1 else vals)
        yield lineno, key, val


def parse_kv(text: str, *, typed: bool = True, on_dup: str = "last") -> dict:
    """KEY value per line -> dict.  A value made of several unquoted tokens
    is kept as a list.  on_dup: 'last' (later line wins), 'first', 'error'.
    Use duplicates() to find repeated keys."""
    d: dict = {}
    for lineno, key, val in _pairs(text, typed):
        if key in d:
            if on_dup == "error":
                raise ValueError(f"line {lineno}: duplicate key {key}")
            if on_dup == "first":
                continue
        d[key] = val
    return d


def duplicates(text: str) -> dict[str, list[int]]:
    """key -> line numbers, for keys that appear more than once."""
    seen: dict[str, list[int]] = {}
    for lineno, key, _ in _pairs(text, False):
        seen.setdefault(key, []).append(lineno)
    return {k: v for k, v in seen.items() if len(v) > 1}


def color(value: str) -> tuple:
    """'r g b' or 'r g b a' -> tuple of numbers."""
    return tuple(coerce(t) for t in value.split())


def _read(path) -> str:
    with open(path, "rb") as f:
        return f.read().decode("cp1252")


def parse_kv_file(path, **kw) -> dict:
    return parse_kv(_read(path), **kw)


def parse_rows_file(path, **kw) -> list:
    return parse_rows(_read(path), **kw)