#!/usr/bin/env python3

"""Fetch SingleStepTests suites and convert them for test_processor_tests.

Not committed: roughly a gigabyte of JSON per 65C02 variant and three for the

65C816, one file per opcode. Takes a fixed prefix of each instead.

Prefix, not a random sample: the baseline records exact per-opcode counts, so

every machine must convert the same cases.

    python tests/fetch_pt.py                    # 100 cases/opcode, wdc65c02

    python tests/fetch_pt.py --cases 10000      # everything

    python tests/fetch_pt.py --variant 816-emu  # 65816, emulation mode

"""

import argparse

import json

import pathlib

import sys

import time

import urllib.error

import urllib.request

import pt_convert

RAW = "https://raw.githubusercontent.com/SingleStepTests/{repo}/main/{sub}/{name}.json"

VARIANTS = {

    # wdc65c02 is the superset: the 32 Rockwell bit instructions we implement

    # plus WAI and STP. The rockwell and synertek suites are subsets of it.

    "wdc65c02": {

        "repo": "65x02", "sub": "wdc65c02/v1", "suffix": "",

        "cpu": pt_convert.CPU_65C02,

    },

    # The 65C816 ships two files per opcode. Emulation mode is all E=1 with 8-bit

    # registers; native mixes the four M/X width combinations within one file.

    "816-emu": {

        "repo": "65816", "sub": "v1", "suffix": ".e",

        "cpu": pt_convert.CPU_65816,

    },

    "816-native": {

        "repo": "65816", "sub": "v1", "suffix": ".n",

        "cpu": pt_convert.CPU_65816,

    },

}

ATTEMPTS = 4

def fetch_opcode(variant: str, op: int, dest: pathlib.Path) -> bool:

    spec = VARIANTS[variant]

    name = f"{op:02x}{spec['suffix']}"

    out = dest / f"{name}.json"

    if out.exists() and out.stat().st_size > 0:

        return True

    url = RAW.format(repo=spec["repo"], sub=spec["sub"], name=name)

    # Hundreds of requests per run, so a transient failure is likely rather

    # than exceptional. Retry anything that is not a definite 404.

    last = None

    for attempt in range(ATTEMPTS):

        try:

            with urllib.request.urlopen(url, timeout=60) as r:

                data = r.read()

            out.write_bytes(data)

            return True

        except urllib.error.HTTPError as e:

            if e.code == 404:

                return False

            last = e

        except Exception as e:

            last = e

        if attempt < ATTEMPTS - 1:

            time.sleep(2 ** attempt)

    raise SystemExit(f"${op:02X}: giving up after {ATTEMPTS} attempts: {last}")

def load_cases(path: pathlib.Path):

    """Cases in one opcode's file, or [] if it holds none.

    $CB (WAI) and $DB (STP) are empty in the 65C02 suite: they stop the

    processor, so there is no state after one instruction.

    """

    if path.stat().st_size == 0:

        return []

    try:

        return json.loads(path.read_text(encoding="utf-8"))

    except json.JSONDecodeError:

        path.unlink()

        raise SystemExit(f"{path.name} is not valid JSON; deleted, run again")

def main() -> int:

    ap = argparse.ArgumentParser()

    ap.add_argument("--variant", default="wdc65c02", choices=sorted(VARIANTS))

    ap.add_argument(

        "--cases",

        type=int,

        default=100,

        help="cases per opcode, taken as a prefix (default 100)",

    )

    ap.add_argument(

        "--opcodes",

        default="",

        help="comma-separated hex opcodes; default is all 256",

    )

    ap.add_argument(

        "--force",

        action="store_true",

        help="re-fetch and re-convert even if the fixture already exists",

    )

    args = ap.parse_args()

    spec = VARIANTS[args.variant]

    here = pathlib.Path(__file__).resolve().parent

    out = here / "pt" / f"{args.variant}.bin"

    # The fixture is a megabyte or so and the JSON it came from is gigabytes,

    # so CI caches only the fixture. Nothing to do when the cache hit.

    if out.exists() and out.stat().st_size > 0 and not args.force:

        print(f"{out} already present ({out.stat().st_size / 1e6:.1f} MB); "

              f"pass --force to rebuild")

        return 0

    dest = here / "pt" / args.variant

    dest.mkdir(parents=True, exist_ok=True)

    if args.opcodes:

        wanted = [int(x, 16) for x in args.opcodes.split(",")]

    else:

        wanted = list(range(256))

    have = []

    for op in wanted:

        sys.stdout.write(f"\rfetching ${op:02X}...")

        sys.stdout.flush()

        if fetch_opcode(args.variant, op, dest):

            have.append(op)

    print(f"\r{len(have)} opcodes available          ")

    cases = []

    empty = []

    short = []

    for op in have:

        raw = load_cases(dest / f"{op:02x}{spec['suffix']}.json")

        if not raw:

            empty.append(op)

            continue

        if len(raw) < args.cases:

            short.append((op, len(raw)))

        cases.extend((op, spec["cpu"], c) for c in raw[: args.cases])

    if empty:

        print("no cases: " + " ".join(f"${o:02X}" for o in empty))

    for op, n in short:

        print(f"  ${op:02X}: only {n} cases, wanted {args.cases}")

    pt_convert.write_fixture(out, cases)

    print(f"wrote {out} -- {len(cases)} cases, {out.stat().st_size / 1e6:.1f} MB")

    return 0

if __name__ == "__main__":

    raise SystemExit(main())