import json
from typing import Any

import httpx
import pytest
from fastmcp import Client
from fastmcp.exceptions import ToolError

from t3code_mcp.config import Machine, ModelSpec, load_machines
from t3code_mcp.server import Registry, build_server
from t3code_mcp.t3 import T3Error


class FakeT3:
    def __init__(
        self, label: str, projects: list[dict[str, Any]], token: str = "tok"
    ) -> None:
        self.label = label
        self.token = token
        self.projects = projects
        self.threads: dict[str, dict[str, Any]] = {}
        self.commands: list[dict[str, Any]] = []
        self.polls_until_done = 2
        self.pending_input = False
        self.fail_with: str | None = None

    def handle(self, request: httpx.Request) -> httpx.Response:
        path = request.url.path
        if path == "/.well-known/t3/environment":
            return httpx.Response(
                200,
                json={
                    "label": self.label,
                    "serverVersion": "0.1.0",
                    "platform": {"os": "linux"},
                },
            )
        if request.headers.get("authorization") != f"Bearer {self.token}":
            return httpx.Response(
                401, json={"code": "auth_invalid", "reason": "missing_credential"}
            )
        if request.headers.get("x-t3-orchestration-protocol") != "2":
            return httpx.Response(400, json={"code": "invalid_request"})
        if path == "/api/orchestration/shell":
            return httpx.Response(200, json=self._shell())
        if path.startswith("/api/orchestration/threads/"):
            thread_id = path.rsplit("/", 1)[1]
            if thread_id not in self.threads:
                return httpx.Response(
                    404, json={"code": "not_found", "reason": "thread_not_found"}
                )
            self._tick(thread_id)
            return httpx.Response(
                200, json={"snapshotSequence": 1, "projection": self.threads[thread_id]}
            )
        return httpx.Response(404, json={"code": "not_found"})

    async def rpc(self, tag: str, payload: dict[str, Any]) -> Any:
        assert tag == "orchestration.dispatchCommand"
        self.commands.append(payload)
        return self._dispatch(payload)

    def _shell(self) -> dict[str, Any]:
        threads = []
        for projection in self.threads.values():
            thread = projection["thread"]
            runs = projection["runs"]
            pending = [
                r for r in projection["runtimeRequests"] if r["status"] == "pending"
            ]
            threads.append(
                {
                    "id": thread["id"],
                    "projectId": thread["projectId"],
                    "title": thread["title"],
                    "archivedAt": None,
                    "status": runs[-1]["status"] if runs else "idle",
                    "lastError": self.fail_with,
                    "pendingRuntimeRequest": (
                        {"id": pending[-1]["id"], "kind": pending[-1]["kind"]}
                        if pending
                        else None
                    ),
                    "hasActionableProposedPlan": False,
                }
            )
        return {"snapshotSequence": 1, "projects": self.projects, "threads": threads}

    def _tick(self, thread_id: str) -> None:
        projection = self.threads[thread_id]
        if self.pending_input and not projection["runtimeRequests"]:
            projection["runtimeRequests"].append(
                {"id": "req-0", "kind": "user_input", "status": "pending"}
            )
        if not projection["runs"]:
            return
        run = projection["runs"][-1]
        if self.fail_with and run["status"] == "running":
            run["status"] = "failed"
            projection["turnItems"].append(
                {
                    "type": "error",
                    "runId": run["id"],
                    "status": "failed",
                    "failure": {"message": self.fail_with},
                }
            )
            return
        if run["status"] == "running":
            run["_polls"] = run.get("_polls", 0) + 1
            if run["_polls"] > self.polls_until_done:
                run["status"] = "completed"
                projection["messages"].append(
                    {
                        "role": "assistant",
                        "text": "done: report",
                        "streaming": False,
                        "runId": run["id"],
                    }
                )

    def _dispatch(self, command: dict[str, Any]) -> dict[str, Any]:
        kind = command["type"]
        if kind == "thread.create":
            self.threads[command["threadId"]] = {
                "thread": {
                    "id": command["threadId"],
                    "projectId": command["projectId"],
                    "title": command["title"],
                    "modelSelection": command["modelSelection"],
                    "runtimeMode": command["runtimeMode"],
                    "archivedAt": None,
                },
                "runs": [],
                "messages": [],
                "turnItems": [],
                "runtimeRequests": [],
                "checkpoints": [],
                "providerSessions": [],
                "providerTurns": [],
                "plans": [],
            }
        elif kind == "message.dispatch":
            assert command["dispatchMode"] == {"type": "start_immediately"}
            projection = self.threads[command["threadId"]]
            run_id = f"run-{len(projection['runs']) + 1}"
            projection["runs"].append(
                {
                    "id": run_id,
                    "ordinal": len(projection["runs"]) + 1,
                    "status": "running",
                }
            )
            projection["messages"].append(
                {
                    "role": "user",
                    "text": command["text"],
                    "streaming": False,
                    "runId": run_id,
                }
            )
            if "modelSelection" in command:
                projection["thread"]["modelSelection"] = command["modelSelection"]
        elif kind == "run.interrupt":
            run = self.threads[command["threadId"]]["runs"][-1]
            assert run["id"] == command["runId"]
            run["status"] = "interrupted"
        elif kind == "runtime-request.respond":
            for request in self.threads[command["threadId"]]["runtimeRequests"]:
                if request["id"] == command["requestId"]:
                    request["status"] = "resolved"
        else:
            raise T3Error(0, {"_tag": "OrchestrationV2DispatchCommandError"})
        return {"sequence": len(self.commands)}


PROJECTS_MAC = [
    {
        "id": "p-smoke",
        "title": "t3-smoke",
        "workspaceRoot": "/Users/h/projects/playgrounds/t3-smoke",
        "defaultModelSelection": {"instanceId": "codex", "model": "gpt-5.6-sol"},
    },
    {
        "id": "p-secret",
        "title": "secret",
        "workspaceRoot": "/Users/h/secret",
        "defaultModelSelection": None,
    },
]
PROJECTS_DELL = [
    {
        "id": "p-root",
        "title": "projects",
        "workspaceRoot": "/root/projects",
        "defaultModelSelection": None,
    },
    {
        "id": "p-repo",
        "title": "beaver/x",
        "workspaceRoot": "/root/projects/beaver/x",
        "defaultModelSelection": None,
    },
]


class Router(httpx.AsyncBaseTransport):
    def __init__(self, fakes: dict[str, FakeT3]) -> None:
        self.fakes = fakes

    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
        return self.fakes[request.url.host].handle(request)


@pytest.fixture
def fakes(monkeypatch: pytest.MonkeyPatch) -> dict[str, FakeT3]:
    monkeypatch.setenv("T3_MAC_TOKEN", "tok")
    monkeypatch.setenv("T3_DELL_TOKEN", "tok")
    return {"mac": FakeT3("mac", PROJECTS_MAC), "dell": FakeT3("dell", PROJECTS_DELL)}


@pytest.fixture
def registry(fakes: dict[str, FakeT3]) -> Registry:
    machines = {
        "mac": Machine.model_validate(
            {
                "name": "mac",
                "url": "http://mac:3773",
                "token_env": "T3_MAC_TOKEN",
                "projects": ("t3-smoke",),
                "model": "claudeAgent/claude-opus-5",
                "options": {"effort": "high"},
            }
        ),
        "dell": Machine(
            name="dell",
            url="http://dell:3773",
            token_env="T3_DELL_TOKEN",
            projects=("/root/projects", "/root/projects/*"),
        ),
    }
    return Registry(machines, transport=Router(fakes), rpc=lambda name: fakes[name].rpc)


@pytest.fixture
def client(registry: Registry) -> Client:
    return Client(build_server(registry, poll=0.001))


def data(result: Any) -> Any:
    return (
        result.structured_content["result"]
        if "result" in result.structured_content
        else result.structured_content
    )


async def test_machines_and_projects(client: Client) -> None:
    async with client:
        machines = data(await client.call_tool("t3_machines"))
        assert [m["name"] for m in machines] == ["mac", "dell"]
        assert all(m["online"] for m in machines)
        projects = data(await client.call_tool("t3_projects", {"machine": "mac"}))
        assert [p["title"] for p in projects] == ["t3-smoke"]
        assert projects[0]["default_model"] == "codex/gpt-5.6-sol"
        dell = data(await client.call_tool("t3_projects", {"machine": "dell"}))
        assert [p["title"] for p in dell] == ["projects", "beaver/x"]


async def test_dispatch_wait_and_thread(
    client: Client, fakes: dict[str, FakeT3]
) -> None:
    async with client:
        started = data(
            await client.call_tool(
                "t3_dispatch",
                {
                    "machine": "mac",
                    "project": "t3-smoke",
                    "prompt": "write README\nmore",
                },
            )
        )
        assert started["title"] == "write README"
        assert started["model"] == "claudeAgent/claude-opus-5 effort=high"
        kinds = [c["type"] for c in fakes["mac"].commands]
        assert kinds == ["thread.create", "message.dispatch"]
        assert fakes["mac"].commands[0]["modelSelection"] == {
            "instanceId": "claudeAgent",
            "model": "claude-opus-5",
            "options": [{"id": "effort", "value": "high"}],
        }
        waited = data(
            await client.call_tool(
                "t3_wait", {"thread_id": started["thread_id"], "timeout": 5}
            )
        )
        assert waited["state"] == "completed"
        assert waited["messages"][-1]["text"] == "done: report"
        assert waited["timed_out"] is False
        view = data(
            await client.call_tool("t3_thread", {"thread_id": started["thread_id"]})
        )
        assert view["project"] == "t3-smoke"
        assert view["pending"] is None


async def test_follow_up_uses_same_thread(
    client: Client, fakes: dict[str, FakeT3]
) -> None:
    fakes["mac"].polls_until_done = 0
    async with client:
        started = data(
            await client.call_tool(
                "t3_dispatch",
                {"machine": "mac", "project": "t3-smoke", "prompt": "one"},
            )
        )
        await client.call_tool(
            "t3_wait", {"thread_id": started["thread_id"], "timeout": 5}
        )
        again = data(
            await client.call_tool(
                "t3_dispatch",
                {
                    "machine": "mac",
                    "project": "t3-smoke",
                    "prompt": "two",
                    "thread_id": started["thread_id"],
                },
            )
        )
        assert again["thread_id"] == started["thread_id"]
        assert [c["type"] for c in fakes["mac"].commands] == [
            "thread.create",
            "message.dispatch",
            "message.dispatch",
        ]


async def test_allowlist_and_unknown_machine(client: Client) -> None:
    async with client:
        with pytest.raises(ToolError, match="not available on mac"):
            await client.call_tool(
                "t3_dispatch", {"machine": "mac", "project": "secret", "prompt": "x"}
            )
        with pytest.raises(ToolError, match="unknown machine"):
            await client.call_tool("t3_projects", {"machine": "rpi"})


async def test_wait_timeout_and_interrupt(
    client: Client, fakes: dict[str, FakeT3]
) -> None:
    fakes["dell"].polls_until_done = 10_000
    async with client:
        started = data(
            await client.call_tool(
                "t3_dispatch",
                {
                    "machine": "dell",
                    "project": "/root/projects",
                    "prompt": "loop",
                    "model": "claudeAgent/claude-sonnet-5",
                },
            )
        )
        assert started["model"] == "claudeAgent/claude-sonnet-5"
        waited = data(
            await client.call_tool(
                "t3_wait", {"thread_id": started["thread_id"], "timeout": 5}
            )
        )
        assert waited["state"] == "running"
        assert waited["timed_out"] is True
        stopped = data(
            await client.call_tool("t3_interrupt", {"thread_id": started["thread_id"]})
        )
        assert stopped["state"] == "interrupting"
        assert fakes["dell"].commands[-1]["type"] == "run.interrupt"
        view = data(
            await client.call_tool("t3_thread", {"thread_id": started["thread_id"]})
        )
        assert view["state"] == "interrupted"


async def test_wait_returns_on_pending_input(
    client: Client, fakes: dict[str, FakeT3]
) -> None:
    fakes["mac"].polls_until_done = 10_000
    fakes["mac"].pending_input = True
    async with client:
        started = data(
            await client.call_tool(
                "t3_dispatch",
                {"machine": "mac", "project": "t3-smoke", "prompt": "ask"},
            )
        )
        waited = data(
            await client.call_tool(
                "t3_wait", {"thread_id": started["thread_id"], "timeout": 5}
            )
        )
        assert waited["pending"] == {
            "approval": False,
            "user_input": True,
            "plan": False,
        }
        assert waited["state"] == "running"


async def test_locate_without_cache(
    registry: Registry, fakes: dict[str, FakeT3]
) -> None:
    fakes["dell"].polls_until_done = 0
    async with Client(build_server(registry, poll=0.001)) as client:
        started = data(
            await client.call_tool(
                "t3_dispatch",
                {
                    "machine": "dell",
                    "project": "beaver/x",
                    "prompt": "hi",
                    "model": "claudeAgent/claude-opus-5",
                },
            )
        )
    registry.threads.clear()
    async with Client(build_server(registry, poll=0.001)) as client:
        view = data(
            await client.call_tool("t3_thread", {"thread_id": started["thread_id"]})
        )
        assert view["machine"] == "dell"


def test_config_parsing(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
    monkeypatch.setenv("T3_MAC_TOKEN", "abc")
    cfg = tmp_path / "t3code.toml"
    cfg.write_text(
        '[machines.mac]\nurl = "http://x"\ntoken_env = "T3_MAC_TOKEN"\nprojects = ["a"]\nmodel = "claudeAgent/claude-opus-5"\noptions = { effort = "high" }\n'
    )
    machines = load_machines(cfg)
    assert machines["mac"].model == ModelSpec(
        instance="claudeAgent", model="claude-opus-5", options={"effort": "high"}
    )
    assert machines["mac"].token == "abc"
    monkeypatch.delenv("T3_MAC_TOKEN")
    with pytest.raises(ValueError, match="T3_MAC_TOKEN is empty"):
        load_machines(cfg)


async def test_wait_returns_on_runtime_failure(
    client: Client, fakes: dict[str, FakeT3]
) -> None:
    fakes["dell"].fail_with = "Claude runtime stream failed."
    async with client:
        started = data(
            await client.call_tool(
                "t3_dispatch",
                {
                    "machine": "dell",
                    "project": "projects",
                    "prompt": "x",
                    "model": "claudeAgent/claude-opus-5",
                },
            )
        )
        waited = data(
            await client.call_tool(
                "t3_wait", {"thread_id": started["thread_id"], "timeout": 5}
            )
        )
        assert waited["state"] == "failed"
        assert waited["error"] == "Claude runtime stream failed."
        assert waited["waited"] < 1


def shell_thread(
    tid: str, state: str | None, *, user_input: bool = False, error: str | None = None
) -> dict[str, Any]:
    return {
        "id": tid,
        "status": state or "idle",
        "lastError": error,
        "pendingRuntimeRequest": (
            {"id": "req-1", "kind": "user_input"} if user_input else None
        ),
        "hasActionableProposedPlan": False,
    }


def test_tracker_transitions(tmp_path) -> None:
    from t3code_mcp.watch import Tracker

    tracker = Tracker(tmp_path / "state.json")
    tracker.track("t1", "dell", "projects", "do x")
    assert tracker.apply("dell", shell_thread("t1", None)) == []
    assert tracker.apply("dell", shell_thread("t1", "running")) == []
    assert [
        e.kind
        for e in tracker.apply("dell", shell_thread("t1", "running", user_input=True))
    ] == ["question"]
    assert tracker.apply("dell", shell_thread("t1", "running", user_input=True)) == []
    assert [e.kind for e in tracker.apply("dell", shell_thread("t1", "completed"))] == [
        "completed"
    ]
    assert tracker.apply("dell", shell_thread("t1", "completed")) == []
    assert tracker.apply("mac", shell_thread("t1", "running")) == []
    assert tracker.apply("dell", shell_thread("untracked", "completed")) == []
    tracker.track("t2", "dell", "projects", "fail")
    assert [
        e.kind
        for e in tracker.apply(
            "dell", shell_thread("t2", None, error="Claude runtime stream failed.")
        )
    ] == ["failed"]
    reloaded = Tracker(tmp_path / "state.json")
    assert reloaded.threads["t1"].state == "completed"
    assert reloaded.threads["t2"].error == "Claude runtime stream failed."


async def test_hook_outbox_retries(tmp_path) -> None:
    from t3code_mcp.watch import Hook, Tracker

    attempts: list[dict[str, Any]] = []
    fail_first = {"n": 1}

    def handler(request: httpx.Request) -> httpx.Response:
        assert request.headers["authorization"] == "Bearer gw"
        attempts.append(json.loads(request.content))
        if fail_first["n"]:
            fail_first["n"] -= 1
            return httpx.Response(503, text="down")
        return httpx.Response(202, json={"job": 1})

    tracker = Tracker(tmp_path / "state.json")
    hook = Hook(
        "http://gateway/hooks/t3code",
        "gw",
        tracker,
        transport=httpx.MockTransport(handler),
    )
    hook.send({"event": "completed", "thread_id": "t1"})
    assert Tracker(tmp_path / "state.json").outbox == [
        {"event": "completed", "thread_id": "t1"}
    ]
    assert await hook.deliver_once() is False
    assert await hook.deliver_once() is True
    assert tracker.outbox == [] and len(attempts) == 2
    await hook.aclose()


async def test_answer_pending_question(
    client: Client, fakes: dict[str, FakeT3]
) -> None:
    fakes["mac"].polls_until_done = 10_000
    async with client:
        started = data(
            await client.call_tool(
                "t3_dispatch",
                {"machine": "mac", "project": "t3-smoke", "prompt": "ask"},
            )
        )
        tid = started["thread_id"]
        with pytest.raises(ToolError, match="no pending question"):
            await client.call_tool(
                "t3_answer", {"thread_id": tid, "answers": {"q1": "yes"}}
            )
        projection = fakes["mac"].threads[tid]
        projection["runtimeRequests"].append(
            {"id": "req-1", "kind": "user_input", "status": "pending"}
        )
        projection["turnItems"].append(
            {
                "type": "user_input_request",
                "runId": "run-1",
                "status": "waiting",
                "requestId": "req-1",
                "questions": [
                    {
                        "id": "q1",
                        "header": "Deploy",
                        "question": "Deploy now?",
                        "options": [
                            {"label": "yes", "description": "go"},
                            {"label": "no", "description": "wait"},
                        ],
                    }
                ],
            }
        )
        view = data(await client.call_tool("t3_thread", {"thread_id": tid}))
        assert view["question"]["request_id"] == "req-1"
        assert view["question"]["questions"][0]["options"][0]["label"] == "yes"
        with pytest.raises(ToolError, match="unknown question ids"):
            await client.call_tool(
                "t3_answer", {"thread_id": tid, "answers": {"zz": "yes"}}
            )
        answered = data(
            await client.call_tool(
                "t3_answer", {"thread_id": tid, "answers": {"q1": "yes"}}
            )
        )
        assert answered["answered"] == ["q1"]
        cmd = fakes["mac"].commands[-1]
        assert (
            cmd["type"] == "runtime-request.respond"
            and cmd["requestId"] == "req-1"
            and cmd["answers"] == {"q1": "yes"}
        )


async def test_dispatch_tracks_thread(client: Client, registry: Registry) -> None:
    async with client:
        started = data(
            await client.call_tool(
                "t3_dispatch",
                {"machine": "mac", "project": "t3-smoke", "prompt": "track me"},
            )
        )
    tracked = registry.tracker.threads[started["thread_id"]]
    assert (tracked.machine, tracked.project, tracked.title) == (
        "mac",
        "t3-smoke",
        "track me",
    )


def test_tracker_watch_flag(tmp_path) -> None:
    from t3code_mcp.watch import Tracker

    tracker = Tracker(tmp_path / "state.json")
    tracker.track("t1", "dell", "projects", "quiet", watch=False)
    tracker.apply("dell", shell_thread("t1", "running"))
    assert tracker.apply("dell", shell_thread("t1", "completed")) == []
    assert tracker.threads["t1"].state == "completed"
    tracker.set_watch("t1", enabled=True)
    tracker.apply("dell", shell_thread("t1", "running"))
    assert [e.kind for e in tracker.apply("dell", shell_thread("t1", "completed"))] == [
        "completed"
    ]
    assert Tracker(tmp_path / "state.json").threads["t1"].watch is True


async def test_watch_tool_lists_and_toggles(client: Client) -> None:
    async with client:
        loud = data(
            await client.call_tool(
                "t3_dispatch",
                {"machine": "mac", "project": "t3-smoke", "prompt": "tell me"},
            )
        )
        quiet = data(
            await client.call_tool(
                "t3_dispatch",
                {
                    "machine": "mac",
                    "project": "t3-smoke",
                    "prompt": "leave me alone",
                    "watch": False,
                },
            )
        )
        assert (loud["watch"], quiet["watch"]) == (True, False)
        view = data(await client.call_tool("t3_watch"))
        assert [t["thread_id"] for t in view["watched"]] == [loud["thread_id"]]
        assert [t["thread_id"] for t in view["unwatched"]] == [quiet["thread_id"]]
        view = data(
            await client.call_tool(
                "t3_watch", {"thread_id": loud["thread_id"], "enabled": False}
            )
        )
        assert view["watched"] == []
        assert {t["thread_id"] for t in view["unwatched"]} == {
            loud["thread_id"],
            quiet["thread_id"],
        }
        view = data(
            await client.call_tool(
                "t3_watch", {"thread_id": quiet["thread_id"], "enabled": True}
            )
        )
        assert [t["thread_id"] for t in view["watched"]] == [quiet["thread_id"]]
        with pytest.raises(ToolError, match="nothing to unwatch"):
            await client.call_tool("t3_watch", {"thread_id": "nope", "enabled": False})
        with pytest.raises(ToolError, match="enabled=true or enabled=false"):
            await client.call_tool("t3_watch", {"thread_id": loud["thread_id"]})