"""Trial engine: copy a pristine fixture, inject one fault, judge invariants.

Invariants (each True / False / None=unmeasured, ADR-0002):

- ``op_no_hang``            the faulted operation ended (killed or exited) within its timeout

- ``repo_opens``            independent open: SQLite integrity_check (Oak) / git fsck (Git)

- ``acked_local_reachable`` every commit a local ref named before the op is still reachable

                            from a local ref (branch head / HEAD / tag), per the independent reader

- ``server_intact``         remote store opens, its pre-op heads stay reachable, and the branch

                            head is either the pre-op head or the operation's intended head

- ``worktree_consistent``   the worktree equals the pre- or post-op state, or a committed tree,

                            or the subject's status reports it dirty/in-progress (never "clean"

                            while differing from HEAD)

- ``next_op_ok_or_actionable`` rerunning the operation succeeds, or fails with a typed/actionable

                            message (not a hang, panic, or signal)

- ``no_false_success``      a reported success (exit 0) leaves exactly the calibrated outcome

- ``acked_after_next``      pre-op local commits are still reachable after the next operation

"""

from __future__ import annotations

import json

import re

import shutil

import time

from dataclasses import dataclass, field

from pathlib import Path

from typing import Any, Callable, Optional

from . import HARNESS_ERROR, HELD, VIOLATED

from .adapters import GitAdapter, OakAdapter, Server

from .fixtures import Fixture

from .procs import Result, copy_tree

from .readers import OakGraph

ACTIONABLE_RE = re.compile(

    r"\b(oak|git)\s+[a-z][\w-]*|manually|--continue|--abort|try again|retry|\bpull\b|re-?run|remove this|rejected|move or remove", re.I)

def actionable(res: Result) -> bool:

    text = res.text()

    if res.returncode is None or res.returncode < 0:

        return False

    if "panicked at" in text or "RUST_BACKTRACE" in text:

        return False

    try:

        data = json.loads(res.stdout)

        if isinstance(data, dict) and isinstance(data.get("error"), dict) and data["error"].get("code"):

            return True

    except (ValueError, TypeError):

        pass

    return bool(text.strip()) and bool(ACTIONABLE_RE.search(text))

@dataclass

class Calibration:

    elapsed_ms: float

    post_tree: Optional[dict]

    post_worktree: Optional[dict]

    post_head: Optional[str]

    post_server_head: Optional[str]

    boundaries: int = 0

    boundary_kinds: list = field(default_factory=list)

    requests: list = field(default_factory=list)

    ok: bool = True

    detail: str = ""

class Trial:

    """One copied fixture + (for Oak) its loopback server, ready for one faulted op."""

    def __init__(self, fixture: Fixture, adapter_bin: str, work: Path, name: str):

        self.fixture = fixture

        self.dir = work / name

        copy_tree(fixture.pristine, self.dir)

        self.home = self.dir / "home"

        self.kind = fixture.kind

        if self.kind == "oak":

            self.adapter = OakAdapter(adapter_bin, self.home)

            self.server: Optional[Server] = Server(adapter_bin, self.dir / "srv", fixture.port or 0,

                                                   self.dir / "serve.log")

        else:

            self.adapter = GitAdapter(adapter_bin, self.home)

            self.server = None

        self.client = self.dir / "client"

    # op plumbing ---------------------------------------------------------------

    def op_cwd(self) -> Path:

        return self.dir if self.fixture.op == "clone" else self.client

    def op_argv(self, bin_override: Optional[str] = None, dest: str = "cloned", url: Optional[str] = None) -> list[str]:

        kw: dict[str, Any] = {"bin": bin_override}

        if self.fixture.op == "clone":

            kw.update(dest=dest, branch=self.fixture.branch, url=url or self.fixture.meta["url"])

        if self.fixture.op == "switch":

            kw["target"] = self.fixture.meta["target"]

        return self.adapter.argv(self.fixture.op, **kw)

    def pre(self) -> None:

        for argv in self.adapter.pre_argv(self.fixture.op):

            self.adapter.must(argv, self.client)

    def start_server(self, port: Optional[int] = None) -> None:

        if self.server is not None:

            self.server.start(port)

    def stop_server(self) -> None:

        if self.server is not None:

            self.server.stop()

    def settle(self) -> None:

        """Let orphaned server-side children (Git local receive-pack) finish."""

        if self.kind == "git":

            remote = self.dir / "srv" / "remote.git"

            deadline = time.monotonic() + 10

            while time.monotonic() < deadline and any(remote.rglob("*.lock")):

                time.sleep(0.05)

            time.sleep(0.1)

    def target_repo(self, dest: str = "cloned") -> Path:

        return self.dir / dest if self.fixture.op == "clone" else self.client

    def cleanup(self) -> None:

        self.stop_server()

        shutil.rmtree(self.dir, ignore_errors=True)

    # independent observations ---------------------------------------------------

    def server_head(self) -> Optional[str]:

        if self.kind == "oak":

            db = self.server.db() if self.server else None

            if not db or not db.exists():

                return None

            with OakGraph(db) as g:

                return g.branch_heads().get(self.fixture.branch)

        refs = self.adapter.oracle.refs(self.dir / "srv" / "remote.git")

        return refs.get(f"refs/heads/{self.fixture.branch}")

    def server_tree(self, commit: str) -> tuple[Optional[dict], str]:

        if self.kind == "oak":

            from .readers import oak_commit_tree

            return oak_commit_tree(self.server.db(), commit)

        return self.adapter.oracle.commit_tree(self.dir / "srv" / "remote.git", commit)

    def repo_opens(self, repo: Path) -> Optional[bool]:

        if self.kind == "oak":

            db = repo / ".oak" / "oak.db"

            if not db.exists():

                return False

            try:

                with OakGraph(db) as g:

                    return g.integrity() == "ok" and g.metadata("current_branch") is not None

            except Exception:  # noqa: BLE001 - any failure to open is the finding

                return False

        if not (repo / ".git").exists():

            return False

        return self.adapter.oracle.fsck(repo) == "ok"

    def acked_reachable(self, repo: Path, heads: list[str]) -> tuple[Optional[bool], list[str]]:

        if not heads:

            return None, []

        try:

            if self.kind == "oak":

                with OakGraph(repo / ".oak" / "oak.db") as g:

                    reach = g.reachable()

                lost = [h for h in heads if h not in reach]

            else:

                lost = [h for h in heads if not self.adapter.oracle.reachable_from_refs(repo, h)]

        except Exception as exc:  # noqa: BLE001

            return False, [f"reader error: {exc}"]

        return not lost, lost

    def server_intact(self, intended: Optional[str]) -> tuple[Optional[bool], dict]:

        pre = self.fixture.meta.get("pre_server_heads", {})

        detail: dict = {}

        try:

            if self.kind == "oak":

                with OakGraph(self.server.db()) as g:

                    detail["integrity"] = g.integrity()

                    heads = g.branch_heads()

                    reach = g.ancestors(heads.values())

                    missing = g.missing_parents([h for h in heads.values()])

            else:

                remote = self.dir / "srv" / "remote.git"

                detail["integrity"] = self.adapter.oracle.fsck(remote)

                refs = self.adapter.oracle.refs(remote)

                heads = {k.removeprefix("refs/heads/"): v for k, v in refs.items() if k.startswith("refs/heads/")}

                reach = set()

                for v in pre.values():

                    if any(self.adapter.oracle.is_ancestor(remote, v, h) for h in heads.values()):

                        reach.add(v)

                missing = []

        except Exception as exc:  # noqa: BLE001

            return False, {"error": str(exc)}

        head = heads.get(self.fixture.branch)

        detail.update(server_head=head, lost_pre_heads=[v for v in pre.values() if v not in reach],

                      torn_graph=missing[:5])

        allowed = {pre.get(self.fixture.branch), intended}

        detail["head_in_allowed"] = head in allowed

        ok = detail["integrity"] == "ok" and not detail["lost_pre_heads"] and not missing and head in allowed

        return ok, detail

def worktree_verdict(trial: Trial, repo: Path, allowed: list[Optional[dict]]) -> tuple[Optional[bool], dict]:

    from .readers import worktree_manifest

    wt = worktree_manifest(repo)

    if wt is None:

        return None, {"worktree": "unreadable"}

    if any(a is not None and wt == a for a in allowed):

        return True, {"worktree": "pre_or_post"}

    head_tree, status = trial.adapter.tree(repo)

    if head_tree is not None and wt == head_tree:

        return True, {"worktree": "matches_head_tree"}

    dirty, res = trial.adapter.status_dirty(repo)

    if dirty is None:

        # status refused with an error: acceptable only if it is actionable

        ok = actionable(res)

        return ok, {"worktree": "differs; status errored", "status_actionable": ok, "status": res.brief(300),

                    "head_tree_reader": status}

    if dirty:

        return True, {"worktree": "differs; reported dirty", "head_tree_reader": status}

    if head_tree is None:

        return None, {"worktree": "differs; status clean; head tree unreadable", "head_tree_reader": status}

    return False, {"worktree": "SILENT_TORN: differs from HEAD tree while status reports clean"}

def classify(invariants: dict[str, Optional[bool]], harness_error: Optional[str] = None) -> str:

    if harness_error:

        return HARNESS_ERROR

    if any(v is False for v in invariants.values()):

        return VIOLATED

    return HELD

def converge_check(trial: Trial, calib: Calibration, repo: Path) -> tuple[Optional[bool], dict]:

    """After a successful next op, is the state exactly the calibrated outcome?"""

    from .readers import worktree_manifest

    op = trial.fixture.op

    detail: dict = {}

    if op == "push":

        local = trial.adapter.head(repo)

        remote = trial.server_head()

        detail.update(local_head=local, server_head=remote)

        if remote is None or local is None or remote != local:

            return False, detail

        tree, status = trial.server_tree(remote)

        detail["server_tree_reader"] = status

        if tree is None:

            return None, detail

        return tree == calib.post_tree, detail

    if op == "switch":

        branch = trial.adapter.current_branch(repo)

        detail["branch"] = branch

        return branch == trial.fixture.meta["target"] and worktree_manifest(repo) == calib.post_worktree, detail

    tree, status = trial.adapter.tree(repo)

    detail["head_tree_reader"] = status

    if tree is None:

        return (False if status.startswith("corrupt") else None), detail

    same_tree = tree == calib.post_tree

    same_wt = worktree_manifest(repo) == calib.post_worktree

    detail.update(head_tree_matches=same_tree, worktree_matches=same_wt)

    if op == "clone":

        detail["head"] = trial.adapter.head(repo)

    return same_tree and same_wt, detail