#!/usr/bin/env python3
"""Fake `docker` for tests: serves canned `ps`/`inspect` data and records `stop`s.

FAKE_DOCKER_CONTAINERS is a JSON list of inspect records in the shape tt reads:
Id/Name/Config.Image/Config.Labels/Mounts/State/HostConfig.PortBindings/
NetworkSettings.Ports/Labels/Ports — the last a raw `docker ps --format {{.Ports}}`
string, e.g. "0.0.0.0:20000->20000/tcp". `ps` lists running records only — one with
no State at all counts as running — unless --all/-a is passed, like the real thing;
--filter label=k[=v] narrows by top-level Labels, `--format {{.Label "k"}}` prints
that label, `--format {{.Ports}}` prints the Ports string, everything else prints
one 12-char id per line (what tt asks for).
FAKE_DOCKER_STOP_LOG collects stopped ids. `logs` records its full argv as one JSON
line in FAKE_DOCKER_ARGV_LOG and prints a marker line plus a fake HF token, so tests
can assert exactly which flags tt forwarded and that tt redacts what comes back.
FAKE_DOCKER_LOGS, a JSON object {"<12-char id>": {"stdout": "...", "stderr": "..."}},
adds a container's own output after the marker.
"""

import json
import os
import re
import sys


def _containers() -> list:
    return json.loads(os.environ.get("FAKE_DOCKER_CONTAINERS") or "[]")


def _label_filter(args: list) -> str | None:
    for a in args:
        if a.startswith("label="):
            return a[len("label="):]
    return None


def _label_format(args: list) -> str | None:
    """`--format {{.Label "k"}}` → k."""
    for a in args:
        m = re.fullmatch(r'\{\{\.Label "([^"]+)"\}\}', a)
        if m:
            return m.group(1)
    return None


def main() -> int:
    args = sys.argv[1:]
    if args[:1] == ["ps"]:
        label = _label_filter(args)
        show_all = bool({"--all", "-a"} & set(args[1:]))
        entries = _containers()
        if label is not None:
            key, _, value = label.partition("=")
            entries = [
                e for e in entries
                if key in (e.get("Labels") or {})
                and (not value or (e.get("Labels") or {}).get(key) == value)
            ]
        if not show_all:
            entries = [
                e for e in entries
                if e.get("State") is None or e["State"].get("Running")
            ]
        wanted_label = _label_format(args)
        if wanted_label is not None:
            for entry in entries:
                print((entry.get("Labels") or {}).get(wanted_label, ""))
            return 0
        if "{{.Ports}}" in args:
            for entry in entries:
                print(entry.get("Ports", ""))
            return 0
        for entry in entries:
            print(str(entry.get("Id", ""))[:12])
        return 0
    if args[:1] == ["inspect"]:
        # `--format {{json .}}` is an option value, so only bare ids are targets
        wanted = [a for a in args[1:] if not a.startswith("-") and not a.startswith("{{")]
        found = [e for e in _containers() if str(e.get("Id", ""))[:12] in wanted]
        for entry in found:
            print(json.dumps(entry))
        # Like docker: an unknown target is an error.
        return 0 if len(found) == len(wanted) else 1
    if args[:1] == ["stop"]:
        log = os.environ.get("FAKE_DOCKER_STOP_LOG")
        if log:
            with open(log, "a") as fh:
                for target in args[1:]:
                    fh.write(target + "\n")
        return 0
    if args[:1] == ["logs"]:
        log = os.environ.get("FAKE_DOCKER_ARGV_LOG")
        if log:
            with open(log, "a") as fh:
                fh.write(json.dumps({"argv": args}) + "\n")
        print(f"fake docker logs {args[-1]}")
        print("HF_TOKEN=hf_" + "x" * 30)
        extra = json.loads(os.environ.get("FAKE_DOCKER_LOGS") or "{}").get(args[-1], {})
        sys.stdout.write(extra.get("stdout", ""))
        sys.stderr.write(extra.get("stderr", ""))
        return 0
    return 0


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