"""End-to-end coverage for the FastAPI surface (dashboard + JSON APIs)."""

from __future__ import annotations

import hashlib
import hmac
import json
from pathlib import Path

import httpx
import pytest
from fastapi.testclient import TestClient

from robomp.config import Settings, reset_settings_cache
from robomp.dashboard import tail_jsonl
from robomp.db import close_database, get_database, issue_key
from robomp.github_client import GitHubClient
from robomp.manual_triage import InvalidIssueRef, parse_issue_ref
from robomp.sandbox import LocalGitTransport
from robomp.server import create_app


def _seed_db(settings: Settings) -> None:
    db = get_database(settings.sqlite_path)
    db.record_event(
        delivery_id="d-queued",
        event_type="issues",
        repo="octo/widget",
        issue_key=issue_key("octo/widget", 1),
        payload={"action": "opened", "issue": {"number": 1}},
    )
    db.record_event(
        delivery_id="d-skipped",
        event_type="issues",
        repo="octo/widget",
        issue_key=issue_key("octo/widget", 2),
        payload={"action": "labeled"},
        state="skipped",
    )
    # Promote one event to "running" so the running_events list isn't empty.
    db.record_event(
        delivery_id="d-running",
        event_type="issue_comment",
        repo="octo/widget",
        issue_key=issue_key("octo/widget", 3),
        payload={"action": "created"},
    )
    claimed = db.claim_next_event()
    assert claimed is not None  # d-queued or d-running depending on order
    # Make sure at least one event is in running state for our assertions.
    db.upsert_issue(
        key=issue_key("octo/widget", 3),
        repo="octo/widget",
        number=3,
        state="opened",
        branch="farm/abc12345/fix",
        pr_number=42,
    )
    db.set_issue_classification(issue_key("octo/widget", 3), "bug")


def test_index_serves_dashboard_html(settings: Settings) -> None:
    app = create_app(settings)
    with TestClient(app) as client:
        resp = client.get("/")
    assert resp.status_code == 200
    assert resp.headers["content-type"].startswith("text/html")
    # A few load-bearing markers from the page; if these vanish, the dashboard
    # changed shape and the rest of the test suite should be updated too.
    assert "<title>robomp</title>" in resp.text
    assert "api/status" in resp.text
    assert "api/logs" in resp.text


def test_api_status_reports_runtime_counts_and_inflight(settings: Settings) -> None:
    app = create_app(settings)
    with TestClient(app) as client:
        _seed_db(settings)
        resp = client.get("/api/status")
    close_database()

    assert resp.status_code == 200
    body = resp.json()

    runtime = body["runtime"]
    assert runtime["bot_login"] == "robomp-bot"
    assert runtime["repo_allowlist"] == ["octo/widget"]
    assert runtime["max_concurrency"] == settings.max_concurrency
    assert runtime["model"] == settings.model
    assert runtime["uptime_seconds"] >= 0

    counts = body["event_counts"]
    # All five buckets must be present even when zero — the UI relies on it.
    assert set(counts) == {"queued", "running", "done", "failed", "skipped"}
    assert counts["queued"] + counts["running"] == 2  # d-queued + d-running
    assert counts["skipped"] == 1
    assert counts["running"] >= 1

    running = body["running_events"]
    assert running, "expected at least one running event after claim"
    assert all(r["started_at"] for r in running)

    # No worker pool was started in TestClient lifespan? It actually is — verify
    # the inflight snapshot returns a list even when empty.
    assert isinstance(body["inflight"], list)

    issues = {i["key"]: i for i in body["issues"]}
    fix_key = issue_key("octo/widget", 3)
    assert fix_key in issues
    assert issues[fix_key]["classification"] == "bug"
    assert issues[fix_key]["pr_number"] == 42
    assert issues[fix_key]["branch"] == "farm/abc12345/fix"

    delivery_ids = {e["delivery_id"] for e in body["recent_events"]}
    assert {"d-queued", "d-skipped", "d-running"}.issubset(delivery_ids)


def test_api_logs_returns_empty_when_file_missing(settings: Settings) -> None:
    app = create_app(settings)
    with TestClient(app) as client:
        resp = client.get("/api/logs?limit=10")
    close_database()
    assert resp.status_code == 200
    body = resp.json()
    assert body == {"entries": [], "count": 0, "limit": 10}


def test_api_logs_tails_jsonl_file(settings: Settings) -> None:
    log_path = settings.log_dir / "robomp.log.jsonl"
    log_path.parent.mkdir(parents=True, exist_ok=True)
    payloads = [
        {"ts": "2026-05-14T21:28:28Z", "level": "INFO", "logger": "robomp.queue", "msg": "dispatch loop online"},
        {
            "ts": "2026-05-14T21:28:54Z",
            "level": "INFO",
            "logger": "robomp.server",
            "msg": "skip",
            "event": "issues",
            "reason": "issues.labeled ignored",
        },
        {"ts": "2026-05-14T21:30:00Z", "level": "WARNING", "logger": "robomp.queue", "msg": "tool_end", "ok": False},
    ]
    log_path.write_text("\n".join(json.dumps(p) for p in payloads) + "\n", encoding="utf-8")

    app = create_app(settings)
    with TestClient(app) as client:
        resp = client.get("/api/logs?limit=2")
    close_database()

    assert resp.status_code == 200
    body = resp.json()
    assert body["count"] == 2
    assert body["limit"] == 2
    # Oldest of the requested window first.
    assert body["entries"][0]["msg"] == "skip"
    assert body["entries"][1]["msg"] == "tool_end"
    assert body["entries"][1]["level"] == "WARNING"


def test_api_logs_limit_is_clamped(settings: Settings) -> None:
    app = create_app(settings)
    with TestClient(app) as client:
        too_low = client.get("/api/logs?limit=0").json()
        too_high = client.get("/api/logs?limit=99999").json()
    close_database()
    assert too_low["limit"] == 1
    assert too_high["limit"] == 2000


def test_tail_jsonl_recovers_from_garbage_lines(tmp_path: Path) -> None:
    path = tmp_path / "noisy.jsonl"
    path.write_text(
        json.dumps({"ts": "a", "level": "INFO", "msg": "ok"}) + "\n"
        "{not json}\n" + json.dumps({"ts": "b", "level": "ERROR", "msg": "bang"}) + "\n",
        encoding="utf-8",
    )
    rows = tail_jsonl(path, limit=10)
    assert len(rows) == 3
    assert rows[0]["msg"] == "ok"
    assert rows[1]["level"] == "RAW"
    assert rows[1]["msg"] == "{not json}"
    assert rows[2]["level"] == "ERROR"


# ---------- manual_triage helpers ----------


def test_parse_issue_ref_accepts_owner_repo_hash_number() -> None:
    assert parse_issue_ref("octo/widget#42") == ("octo/widget", 42)
    assert parse_issue_ref("  octo/widget#42  ") == ("octo/widget", 42)


def test_parse_issue_ref_rejects_garbage() -> None:
    for bad in ("widget#1", "octo/widget", "octo/widget#abc", "octo widget#1", ""):
        with pytest.raises(InvalidIssueRef):
            parse_issue_ref(bad)


# ---------- /api/trigger ----------


def _enable_replay(monkeypatch: pytest.MonkeyPatch) -> str:
    token = "trigger-secret"
    monkeypatch.setenv("ROBOMP_REPLAY_TOKEN", token)
    reset_settings_cache()
    return token


def _install_github_mock(app, transport: httpx.MockTransport) -> None:
    """Replace the real GitHub client with one wired to a MockTransport."""
    app.state.bag["github"] = GitHubClient("token", transport=transport)


def test_trigger_returns_404_when_token_disabled(settings: Settings) -> None:
    app = create_app(settings)
    with TestClient(app) as client:
        resp = client.post("/api/trigger", json={"mode": "triage", "issue": "octo/widget#1"})
    close_database()
    assert resp.status_code == 404
    assert "trigger disabled" in resp.json()["detail"]


def test_trigger_rejects_missing_token(env, monkeypatch: pytest.MonkeyPatch) -> None:
    _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        resp = client.post("/api/trigger", json={"mode": "triage", "issue": "octo/widget#1"})
    close_database()
    assert resp.status_code == 401


def test_trigger_triage_fetches_and_enqueues(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()

    captured: list[str] = []

    def handler(request: httpx.Request) -> httpx.Response:
        captured.append(request.url.path)
        if request.url.path.endswith("/issues/7"):
            return httpx.Response(
                200,
                json={
                    "number": 7,
                    "title": "boom",
                    "body": "details here",
                    "state": "open",
                    "user": {"login": "alice"},
                    "labels": [{"name": "bug"}],
                },
            )
        if request.url.path.endswith("/repos/octo/widget"):
            return httpx.Response(
                200,
                json={
                    "full_name": "octo/widget",
                    "default_branch": "main",
                    "clone_url": "https://github.com/octo/widget.git",
                    "private": False,
                },
            )
        return httpx.Response(404)

    app = create_app(cfg)
    with TestClient(app) as client:
        _install_github_mock(app, httpx.MockTransport(handler))
        resp = client.post(
            "/api/trigger",
            json={"mode": "triage", "issue": "octo/widget#7"},
            headers={"X-Robomp-Replay-Token": token},
        )
    close_database()

    assert resp.status_code == 202, resp.text
    body = resp.json()
    assert body["mode"] == "triage"
    assert body["state"] == "queued"
    assert body["delivery"] == "manual-octo__widget-7"
    # Both endpoints should have been hit on GitHub.
    assert any(p.endswith("/issues/7") for p in captured)
    assert any(p.endswith("/repos/octo/widget") for p in captured)


@pytest.mark.parametrize("state", ["queued", "running"])
def test_trigger_triage_conflicts_when_manual_delivery_is_active(
    env, monkeypatch: pytest.MonkeyPatch, state: str
) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    delivery = "manual-octo__widget-7"
    original_payload = {"action": "opened", "issue": {"number": 7, "title": "old"}}

    calls: list[str] = []

    def handler(request: httpx.Request) -> httpx.Response:
        calls.append(request.url.path)
        return httpx.Response(500, json={"message": "should not fetch active manual event"})

    app = create_app(cfg)
    with TestClient(app) as client:
        db = get_database(cfg.sqlite_path)
        db.record_event(
            delivery_id=delivery,
            event_type="issues",
            repo="octo/widget",
            issue_key=issue_key("octo/widget", 7),
            payload=original_payload,
            state=state,
        )
        _install_github_mock(app, httpx.MockTransport(handler))
        resp = client.post(
            "/api/trigger",
            json={"mode": "triage", "issue": "octo/widget#7"},
            headers={"X-Robomp-Replay-Token": token},
        )
        row = get_database(cfg.sqlite_path).get_event(delivery)
    close_database()

    assert resp.status_code == 409, resp.text
    assert row is not None
    assert row.state == state
    assert row.payload == original_payload
    assert calls == []


@pytest.mark.parametrize("state", ["done", "failed", "skipped"])
def test_trigger_triage_replaces_inactive_manual_delivery(env, monkeypatch: pytest.MonkeyPatch, state: str) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    delivery = "manual-octo__widget-7"

    def handler(request: httpx.Request) -> httpx.Response:
        if request.url.path.endswith("/issues/7"):
            return httpx.Response(
                200,
                json={
                    "number": 7,
                    "title": "fresh",
                    "body": "new details",
                    "state": "open",
                    "user": {"login": "alice"},
                    "labels": [{"name": "bug"}],
                },
            )
        if request.url.path.endswith("/repos/octo/widget"):
            return httpx.Response(
                200,
                json={
                    "full_name": "octo/widget",
                    "default_branch": "main",
                    "clone_url": "https://github.com/octo/widget.git",
                    "private": False,
                },
            )
        return httpx.Response(404)

    app = create_app(cfg)
    with TestClient(app) as client:
        db = get_database(cfg.sqlite_path)
        db.record_event(
            delivery_id=delivery,
            event_type="issues",
            repo="octo/widget",
            issue_key=issue_key("octo/widget", 7),
            payload={"action": "opened", "issue": {"number": 7, "title": "old"}},
            state=state,
        )
        _install_github_mock(app, httpx.MockTransport(handler))
        resp = client.post(
            "/api/trigger",
            json={"mode": "triage", "issue": "octo/widget#7"},
            headers={"X-Robomp-Replay-Token": token},
        )
        row = get_database(cfg.sqlite_path).get_event(delivery)
    close_database()

    assert resp.status_code == 202, resp.text
    assert row is not None
    assert row.state == "queued"
    assert row.attempts == 0
    assert row.payload["issue"]["title"] == "fresh"


def test_trigger_triage_rejects_pull_request_issue_payload(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()

    captured: list[str] = []

    def handler(request: httpx.Request) -> httpx.Response:
        captured.append(request.url.path)
        if request.url.path.endswith("/issues/7"):
            return httpx.Response(
                200,
                json={
                    "number": 7,
                    "title": "change",
                    "body": "details here",
                    "state": "open",
                    "user": {"login": "alice"},
                    "labels": [{"name": "bug"}],
                    "pull_request": {"url": "https://api.github.com/repos/octo/widget/pulls/7"},
                },
            )
        if request.url.path.endswith("/repos/octo/widget"):
            return httpx.Response(
                200,
                json={
                    "full_name": "octo/widget",
                    "default_branch": "main",
                    "clone_url": "https://github.com/octo/widget.git",
                    "private": False,
                },
            )
        return httpx.Response(404)

    app = create_app(cfg)
    with TestClient(app) as client:
        _install_github_mock(app, httpx.MockTransport(handler))
        resp = client.post(
            "/api/trigger",
            json={"mode": "triage", "issue": "octo/widget#7"},
            headers={"X-Robomp-Replay-Token": token},
        )
        assert get_database(cfg.sqlite_path).get_event("manual-octo__widget-7") is None
    close_database()

    assert resp.status_code == 400, resp.text
    assert "pull request" in resp.json()["detail"]
    assert any(p.endswith("/issues/7") for p in captured)
    assert not any(p.endswith("/repos/octo/widget") for p in captured)


def test_trigger_triage_rejects_repo_not_in_allowlist(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        _install_github_mock(app, httpx.MockTransport(lambda r: httpx.Response(500)))
        resp = client.post(
            "/api/trigger",
            json={"mode": "triage", "issue": "evil/repo#1"},
            headers={"X-Robomp-Replay-Token": token},
        )
    close_database()
    assert resp.status_code == 403
    assert "ROBOMP_REPO_ALLOWLIST" in resp.json()["detail"]


@pytest.mark.parametrize("state", ["queued", "running"])
def test_trigger_retry_by_delivery_rejects_active_events(
    env,
    monkeypatch: pytest.MonkeyPatch,
    state: str,
) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        db = get_database(cfg.sqlite_path)
        db.record_event(
            delivery_id=f"d-{state}",
            event_type="issues",
            repo="octo/widget",
            issue_key=issue_key("octo/widget", 5),
            payload={"action": "opened", "issue": {"number": 5}},
            state=state,
        )
        resp = client.post(
            "/api/trigger",
            json={"mode": "retry", "delivery_id": f"d-{state}"},
            headers={"X-Robomp-Replay-Token": token},
        )
        assert resp.status_code == 409
        assert state in resp.json()["detail"]
        assert get_database(cfg.sqlite_path).get_event(f"d-{state}").state == state
    close_database()


def test_trigger_triage_surfaces_github_failure(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    transport = httpx.MockTransport(lambda r: httpx.Response(404, json={"message": "Not Found"}))
    app = create_app(cfg)
    with TestClient(app) as client:
        _install_github_mock(app, transport)
        resp = client.post(
            "/api/trigger",
            json={"mode": "triage", "issue": "octo/widget#999"},
            headers={"X-Robomp-Replay-Token": token},
        )
    close_database()
    assert resp.status_code == 502
    assert "github error" in resp.json()["detail"]


def test_trigger_retry_by_delivery_id_requeues(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        db = get_database(cfg.sqlite_path)
        db.record_event(
            delivery_id="d-old",
            event_type="issues",
            repo="octo/widget",
            issue_key=issue_key("octo/widget", 4),
            payload={"action": "opened", "issue": {"number": 4}},
            state="failed",
        )
        resp = client.post(
            "/api/trigger",
            json={"mode": "retry", "delivery_id": "d-old"},
            headers={"X-Robomp-Replay-Token": token},
        )
        assert resp.status_code == 202
        assert get_database(cfg.sqlite_path).get_event("d-old").state == "queued"
    close_database()


def test_trigger_retry_by_issue_finds_latest_event(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        db = get_database(cfg.sqlite_path)
        key = issue_key("octo/widget", 9)
        db.record_event(
            delivery_id="d-old-1",
            event_type="issues",
            repo="octo/widget",
            issue_key=key,
            payload={"a": 1},
            state="failed",
        )
        db.record_event(
            delivery_id="d-old-2",
            event_type="issue_comment",
            repo="octo/widget",
            issue_key=key,
            payload={"a": 2},
            state="done",
        )
        resp = client.post(
            "/api/trigger",
            json={"mode": "retry", "issue": "octo/widget#9"},
            headers={"X-Robomp-Replay-Token": token},
        )
        body = resp.json()
        assert resp.status_code == 202, body
        # Most recently-received row wins.
        assert body["delivery"] == "d-old-2"
        assert get_database(cfg.sqlite_path).get_event("d-old-2").state == "queued"
    close_database()


def test_trigger_retry_by_issue_rejects_active_latest_event(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        db = get_database(cfg.sqlite_path)
        key = issue_key("octo/widget", 10)
        db.record_event(
            delivery_id="d-inactive",
            event_type="issues",
            repo="octo/widget",
            issue_key=key,
            payload={"a": 1},
            state="failed",
        )
        db.record_event(
            delivery_id="d-active",
            event_type="issue_comment",
            repo="octo/widget",
            issue_key=key,
            payload={"a": 2},
            state="running",
        )
        resp = client.post(
            "/api/trigger",
            json={"mode": "retry", "issue": "octo/widget#10"},
            headers={"X-Robomp-Replay-Token": token},
        )
        assert resp.status_code == 409
        assert "running" in resp.json()["detail"]
        assert get_database(cfg.sqlite_path).get_event("d-active").state == "running"
        assert get_database(cfg.sqlite_path).get_event("d-inactive").state == "failed"
    close_database()


def test_trigger_retry_by_issue_rejects_repo_not_in_allowlist(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        db = get_database(cfg.sqlite_path)
        db.record_event(
            delivery_id="d-evil",
            event_type="issues",
            repo="evil/repo",
            issue_key=issue_key("evil/repo", 1),
            payload={"a": 1},
            state="failed",
        )
        resp = client.post(
            "/api/trigger",
            json={"mode": "retry", "issue": "evil/repo#1"},
            headers={"X-Robomp-Replay-Token": token},
        )
        assert resp.status_code == 403
        assert "ROBOMP_REPO_ALLOWLIST" in resp.json()["detail"]
        assert get_database(cfg.sqlite_path).get_event("d-evil").state == "failed"
    close_database()


def test_trigger_retry_unknown_delivery_404s(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        resp = client.post(
            "/api/trigger",
            json={"mode": "retry", "delivery_id": "nope"},
            headers={"X-Robomp-Replay-Token": token},
        )
    close_database()
    assert resp.status_code == 404


def test_trigger_rejects_bad_mode(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        resp = client.post(
            "/api/trigger",
            json={"mode": "explode"},
            headers={"X-Robomp-Replay-Token": token},
        )
    close_database()
    assert resp.status_code == 400


# -------- /webhook/github rate-limiting --------------------------------


def _signed_headers(secret: str, body: bytes, *, event: str, delivery: str) -> dict[str, str]:
    sig = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
    return {
        "X-GitHub-Event": event,
        "X-GitHub-Delivery": delivery,
        "X-Hub-Signature-256": f"sha256={sig}",
        "Content-Type": "application/json",
    }


def _post_issue_opened(
    client: TestClient,
    *,
    delivery: str,
    user: str,
    number: int,
    association: str = "NONE",
    secret: str = "test-webhook-secret",
):
    payload = {
        "action": "opened",
        "issue": {
            "number": number,
            "user": {"login": user},
            "author_association": association,
        },
        "repository": {"full_name": "octo/widget"},
    }
    body = json.dumps(payload).encode()
    return client.post(
        "/webhook/github",
        content=body,
        headers=_signed_headers(secret, body, event="issues", delivery=delivery),
    )


def _post_pr_issue_comment(
    client: TestClient,
    *,
    delivery: str,
    user: str,
    pr_number: int,
    association: str = "NONE",
    secret: str = "test-webhook-secret",
):
    payload = {
        "action": "created",
        "comment": {
            "user": {"login": user},
            "author_association": association,
            "body": "follow-up",
        },
        "issue": {
            "number": pr_number,
            "pull_request": {"url": f"https://api.github.com/repos/octo/widget/pulls/{pr_number}"},
        },
        "repository": {"full_name": "octo/widget"},
    }
    body = json.dumps(payload).encode()
    return client.post(
        "/webhook/github",
        content=body,
        headers=_signed_headers(secret, body, event="issue_comment", delivery=delivery),
    )


@pytest.fixture
def rate_limited_settings(monkeypatch: pytest.MonkeyPatch, env: dict[str, str]) -> Settings:
    monkeypatch.setenv("ROBOMP_RATE_LIMIT_DEFAULT", "2")
    monkeypatch.setenv("ROBOMP_RATE_LIMIT_CONTRIBUTOR", "4")
    monkeypatch.setenv("ROBOMP_RATE_LIMIT_WINDOW_SECONDS", "3600")
    monkeypatch.setenv("ROBOMP_RATE_LIMIT_UNLIMITED", "can1357")
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    return cfg


def test_webhook_rate_limits_unknown_submitter_at_default_cap(rate_limited_settings: Settings) -> None:
    app = create_app(rate_limited_settings)
    with TestClient(app) as client:
        # Default cap is 2 → first two queued, third throttled.
        states = []
        for i in range(3):
            resp = _post_issue_opened(
                client,
                delivery=f"d-{i}",
                user="stranger",
                number=100 + i,
                association="NONE",
            )
            assert resp.status_code == 202
            states.append(resp.json()["state"])
    close_database()
    assert states == ["queued", "queued", "skipped"]


def test_webhook_unmapped_pr_comment_does_not_consume_submitter_budget(
    rate_limited_settings: Settings,
) -> None:
    app = create_app(rate_limited_settings)
    with TestClient(app) as client:
        skipped = _post_pr_issue_comment(
            client,
            delivery="pr-unmapped",
            user="stranger",
            pr_number=900,
            association="NONE",
        )
        assert skipped.status_code == 202
        assert skipped.json()["state"] == "skipped"

        states = []
        for i in range(3):
            resp = _post_issue_opened(
                client,
                delivery=f"real-{i}",
                user="stranger",
                number=100 + i,
                association="NONE",
            )
            assert resp.status_code == 202
            states.append(resp.json()["state"])

        db = get_database(rate_limited_settings.sqlite_path)
        unmapped = db.get_event("pr-unmapped")
    close_database()

    assert unmapped is not None
    assert unmapped.issue_key is None
    assert unmapped.last_error is not None
    assert "not mapped" in unmapped.last_error
    assert states == ["queued", "queued", "skipped"]


def test_webhook_contributor_gets_higher_cap(rate_limited_settings: Settings) -> None:
    app = create_app(rate_limited_settings)
    with TestClient(app) as client:
        # Default cap (2) would block at i=2; CONTRIBUTOR cap (4) allows it.
        for i in range(4):
            resp = _post_issue_opened(
                client,
                delivery=f"c-{i}",
                user="bob",
                number=200 + i,
                association="CONTRIBUTOR",
            )
            assert resp.status_code == 202
            assert resp.json()["state"] == "queued", i
        resp = _post_issue_opened(
            client,
            delivery="c-x",
            user="bob",
            number=299,
            association="CONTRIBUTOR",
        )
        assert resp.json()["state"] == "skipped"
    close_database()


def test_webhook_owner_association_bypasses_limit(rate_limited_settings: Settings) -> None:
    app = create_app(rate_limited_settings)
    with TestClient(app) as client:
        for i in range(5):  # well over default cap
            resp = _post_issue_opened(
                client,
                delivery=f"o-{i}",
                user="acme-staff",
                number=300 + i,
                association="OWNER",
            )
            assert resp.json()["state"] == "queued", i
    close_database()


def test_webhook_unlimited_allowlist_bypasses_limit(rate_limited_settings: Settings) -> None:
    app = create_app(rate_limited_settings)
    with TestClient(app) as client:
        # NONE association would normally cap at 2, but `can1357` is whitelisted.
        for i in range(5):
            resp = _post_issue_opened(
                client,
                delivery=f"u-{i}",
                user="can1357",
                number=400 + i,
                association="NONE",
            )
            assert resp.json()["state"] == "queued", i
    close_database()


def test_webhook_rate_limit_per_user_is_independent(rate_limited_settings: Settings) -> None:
    """One user's cap doesn't drain another user's budget."""
    app = create_app(rate_limited_settings)
    with TestClient(app) as client:
        # alice exhausts default cap.
        for i in range(2):
            assert (
                _post_issue_opened(
                    client,
                    delivery=f"a-{i}",
                    user="alice",
                    number=500 + i,
                    association="NONE",
                ).json()["state"]
                == "queued"
            )
        # alice's next attempt is skipped.
        assert (
            _post_issue_opened(
                client,
                delivery="a-x",
                user="alice",
                number=599,
                association="NONE",
            ).json()["state"]
            == "skipped"
        )
        # bob is untouched.
        for i in range(2):
            assert (
                _post_issue_opened(
                    client,
                    delivery=f"b-{i}",
                    user="bob",
                    number=600 + i,
                    association="NONE",
                ).json()["state"]
                == "queued"
            )
    close_database()


def test_webhook_rate_limited_event_records_reason(rate_limited_settings: Settings) -> None:
    """Throttled events must surface a useful reason on the dashboard feed."""
    app = create_app(rate_limited_settings)
    with TestClient(app) as client:
        for i in range(3):
            _post_issue_opened(
                client,
                delivery=f"r-{i}",
                user="charlie",
                number=700 + i,
                association="NONE",
            )
        db = get_database(rate_limited_settings.sqlite_path)
        skipped = db.get_event("r-2")
    close_database()
    assert skipped is not None
    assert skipped.state == "skipped"
    assert skipped.last_error is not None
    assert "rate limit" in skipped.last_error
    assert "@charlie" in skipped.last_error


# ---------- /api/github/issues ----------


def _allowlist(monkeypatch: pytest.MonkeyPatch, repos: str) -> None:
    monkeypatch.setenv("ROBOMP_REPO_ALLOWLIST", repos)
    reset_settings_cache()


def _make_issues_handler(
    by_repo: dict[str, list[dict]],
    *,
    expected_state: str = "open",
    expected_limit: int = 30,
    failing_repos: tuple[str, ...] = (),
) -> httpx.MockTransport:
    expected_params = {
        "state": expected_state,
        "per_page": str(expected_limit),
        "sort": "updated",
        "direction": "desc",
    }

    def handler(request: httpx.Request) -> httpx.Response:
        assert request.method == "GET"
        params = request.url.params
        assert set(params.keys()) == set(expected_params)
        for key, expected in expected_params.items():
            assert params.get(key) == expected

        path = request.url.path
        for repo, items in by_repo.items():
            if path == f"/repos/{repo}/issues":
                return httpx.Response(200, json=items)
        for repo in failing_repos:
            if path == f"/repos/{repo}/issues":
                return httpx.Response(500, json={"message": "boom"})
        return httpx.Response(404, json={"message": "not found"})

    return httpx.MockTransport(handler)


def test_browse_returns_404_without_token(settings: Settings) -> None:
    app = create_app(settings)
    with TestClient(app) as client:
        resp = client.get("/api/github/issues")
    close_database()
    assert resp.status_code == 404


def test_browse_returns_401_with_replay_enabled_without_valid_token(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)

    with TestClient(app) as client:
        missing = client.get("/api/github/issues")
        wrong = client.get(
            "/api/github/issues",
            headers={"X-Robomp-Replay-Token": f"{token}-wrong"},
        )
    close_database()

    assert missing.status_code == 401
    assert wrong.status_code == 401


def test_browse_fans_out_across_allowlist_and_filters_prs(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    _allowlist(monkeypatch, "octo/widget,octo/gadget")
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    transport = _make_issues_handler(
        {
            "octo/widget": [
                {
                    "number": 7,
                    "title": "newest",
                    "state": "open",
                    "user": {"login": "alice"},
                    "labels": [{"name": "bug"}],
                    "comments": 3,
                    "updated_at": "2026-05-14T10:00:00Z",
                    "created_at": "2026-05-01T10:00:00Z",
                    "html_url": "https://github.com/octo/widget/issues/7",
                },
                {
                    "number": 8,
                    "title": "a PR not an issue",
                    "state": "open",
                    "user": {"login": "bob"},
                    "labels": [],
                    "comments": 0,
                    "updated_at": "2026-05-14T11:00:00Z",
                    "created_at": "2026-05-14T11:00:00Z",
                    "html_url": "https://github.com/octo/widget/pull/8",
                    "pull_request": {"url": "..."},
                },  # GitHub /issues returns these too
            ],
            "octo/gadget": [
                {
                    "number": 2,
                    "title": "older",
                    "state": "open",
                    "user": {"login": "carol"},
                    "labels": [],
                    "comments": 1,
                    "updated_at": "2026-05-12T09:00:00Z",
                    "created_at": "2026-05-12T09:00:00Z",
                    "html_url": "https://github.com/octo/gadget/issues/2",
                },
            ],
        },
        expected_limit=20,
    )
    app = create_app(cfg)
    with TestClient(app) as client:
        _install_github_mock(app, transport)
        resp = client.get(
            "/api/github/issues?state=open&limit=20",
            headers={"X-Robomp-Replay-Token": token},
        )
    close_database()

    assert resp.status_code == 200, resp.text
    body = resp.json()
    assert body["repos"] == ["octo/gadget", "octo/widget"]
    assert body["errors"] == []
    # PR row dropped; issues sorted newest-updated first.
    titles = [(i["repo"], i["number"]) for i in body["issues"]]
    assert titles == [("octo/widget", 7), ("octo/gadget", 2)]
    first = body["issues"][0]
    assert first["author"] == "alice"
    assert first["labels"] == ["bug"]
    assert first["comments"] == 3
    assert first["html_url"].endswith("/issues/7")


def test_browse_per_repo_failure_does_not_take_down_panel(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    _allowlist(monkeypatch, "octo/widget,octo/dead")
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()

    transport = _make_issues_handler(
        {
            "octo/widget": [
                {
                    "number": 1,
                    "title": "ok",
                    "state": "open",
                    "user": {"login": "u"},
                    "labels": [],
                    "comments": 0,
                    "updated_at": "2026-05-14T00:00:00Z",
                    "created_at": "2026-05-14T00:00:00Z",
                    "html_url": "https://github.com/octo/widget/issues/1",
                },
            ],
        },
        failing_repos=("octo/dead",),
    )

    app = create_app(cfg)
    with TestClient(app) as client:
        _install_github_mock(app, transport)
        resp = client.get(
            "/api/github/issues",
            headers={"X-Robomp-Replay-Token": token},
        )
    close_database()

    assert resp.status_code == 200
    body = resp.json()
    assert len(body["issues"]) == 1
    assert body["issues"][0]["repo"] == "octo/widget"
    assert len(body["errors"]) == 1
    assert body["errors"][0]["repo"] == "octo/dead"


def test_browse_rejects_bad_state(env, monkeypatch: pytest.MonkeyPatch) -> None:
    token = _enable_replay(monkeypatch)
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        _install_github_mock(app, httpx.MockTransport(lambda r: httpx.Response(500)))
        resp = client.get(
            "/api/github/issues?state=garbage",
            headers={"X-Robomp-Replay-Token": token},
        )
    close_database()
    assert resp.status_code == 400


# -------- maintainer directives ----------------------------------------


def _post_issue_comment(
    client: TestClient,
    *,
    delivery: str,
    user: str,
    number: int,
    body: str,
    association: str = "NONE",
    secret: str = "test-webhook-secret",
):
    payload = {
        "action": "created",
        "comment": {
            "user": {"login": user},
            "author_association": association,
            "body": body,
        },
        "issue": {"number": number},
        "repository": {"full_name": "octo/widget"},
    }
    raw = json.dumps(payload).encode()
    return client.post(
        "/webhook/github",
        content=raw,
        headers=_signed_headers(secret, raw, event="issue_comment", delivery=delivery),
    )


def test_webhook_directive_on_unknown_issue_is_queued_with_metadata(env) -> None:
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()
    app = create_app(cfg)
    with TestClient(app) as client:
        resp = _post_issue_comment(
            client,
            delivery="dir-1",
            user="can1357",
            number=77,
            body="@robomp-bot please refactor X",
            association="OWNER",
        )
        assert resp.status_code == 202
        assert resp.json()["state"] == "queued"
        row = get_database(cfg.sqlite_path).get_event("dir-1")
    close_database()
    assert row is not None
    assert row.state == "queued"
    directive = row.payload.get("_robomp_directive")
    assert directive == {"body": "please refactor X", "author": "can1357", "pragmas": []}


def test_webhook_maintainer_bypasses_rate_limit(
    rate_limited_settings: Settings,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """Login in ROBOMP_MAINTAINER_LOGINS is always unlimited, even with NONE association."""
    monkeypatch.setenv("ROBOMP_MAINTAINER_LOGINS", "can1357")
    reset_settings_cache()
    cfg = Settings()  # type: ignore[call-arg]
    cfg.ensure_paths()

    app = create_app(cfg)
    with TestClient(app) as client:
        states = []
        # cap=2 from rate_limited_settings — 3rd would normally be skipped.
        for i in range(4):
            resp = _post_issue_comment(
                client,
                delivery=f"m-{i}",
                user="can1357",
                number=300 + i,
                body=("@robomp-bot do X" if i == 3 else "comment"),
                association="NONE",
            )
            assert resp.status_code == 202
            states.append(resp.json()["state"])
    close_database()
    assert states == ["queued"] * 4, states


# -------- handler-level: bootstrap + reopen ----------------------------


class _RecordingSandbox:
    """Stand-in for SandboxManager: records calls, hands back a fake Workspace."""

    def __init__(self, tmp_root: Path) -> None:
        self.tmp_root = tmp_root
        self.ensure_calls: list[dict] = []
        self.remove_calls: list[tuple[str, int]] = []

    def ensure_workspace(
        self,
        *,
        repo: str,
        number: int,
        title: str,
        clone_url: str,
        default_branch: str,
        existing_branch=None,
        author_name: str = "",
        author_email: str = "",
    ):
        self.ensure_calls.append(
            {
                "repo": repo,
                "number": number,
                "title": title,
                "default_branch": default_branch,
                "existing_branch": existing_branch,
            }
        )
        # Mimic Workspace shape — only the attributes ensure_workspace's
        # downstream callers touch.
        from dataclasses import dataclass

        @dataclass(slots=True, frozen=True)
        class _W:
            branch: str
            session_dir: Path
            context_dir: Path
            repo_dir: Path

        wid = f"{repo.replace('/', '__')}__{number}"
        return _W(
            branch=existing_branch or f"farm/auto/{wid}",
            session_dir=self.tmp_root / wid / "session",
            context_dir=self.tmp_root / wid / "context",
            repo_dir=self.tmp_root / wid / "repo",
        )

    def remove_workspace(self, *, repo: str, number: int) -> None:
        self.remove_calls.append((repo, number))


@pytest.fixture
def stub_run_task(monkeypatch: pytest.MonkeyPatch) -> list[dict]:
    """Capture run_task invocations instead of spinning up RpcClient."""
    captured: list[dict] = []

    async def _stub(**kwargs):
        captured.append(kwargs)
        return None

    from robomp import tasks as tasks_module

    monkeypatch.setattr(tasks_module, "run_task", _stub)
    return captured


async def test_handle_comment_directive_bootstraps_untriaged_issue(
    settings: Settings, tmp_path: Path, stub_run_task, monkeypatch
) -> None:
    """Directive on an unknown issue → DB row created, triage_issue task with directive."""
    from robomp import tasks
    from robomp.github_client import GitHubClient, IssueInfo, RepoInfo

    sandbox = _RecordingSandbox(tmp_path)
    db = get_database(settings.sqlite_path)
    repo = RepoInfo(
        full_name="octo/widget", default_branch="main", clone_url="https://github.com/octo/widget.git", private=False
    )
    issue = IssueInfo(
        repo="octo/widget",
        number=88,
        title="boom",
        body="details",
        state="open",
        author="alice",
        labels=(),
        is_pull_request=False,
    )

    async def _resolve(_gh, _payload):
        return repo, issue

    monkeypatch.setattr(tasks, "_resolve_repo_and_issue", _resolve)

    payload = {
        "action": "created",
        "issue": {"number": 88, "user": {"login": "alice"}, "title": "boom"},
        "comment": {"user": {"login": "can1357"}, "body": "do it", "id": 1, "created_at": "2026-05-14T20:00:00Z"},
        "repository": {"full_name": "octo/widget"},
        "_robomp_directive": {"body": "please refactor X", "author": "can1357"},
    }
    await tasks.handle_comment(
        settings=settings,
        db=db,
        github=GitHubClient("t"),
        git_transport=LocalGitTransport(token=None),
        sandbox=sandbox,
        payload=payload,
        delivery_id="test-delivery-1",
    )
    assert len(stub_run_task) == 1
    call = stub_run_task[0]
    assert call["task_kind"] == "triage_issue"
    assert call["directive"] is not None
    assert call["directive"].body == "please refactor X"
    assert call["directive"].author == "can1357"
    row = db.get_issue("octo/widget#88")
    assert row is not None
    assert row.state == "reproducing"
    assert sandbox.ensure_calls, "ensure_workspace must be called"
    assert sandbox.remove_calls == [], "no removal on bootstrap"
    close_database()


async def test_handle_comment_directive_reopens_finalized_issue(
    settings: Settings, tmp_path: Path, stub_run_task, monkeypatch
) -> None:
    """Directive on a closed issue → workspace torn down, state reset, no auto-reply."""
    from robomp import tasks
    from robomp.github_client import GitHubClient, IssueInfo, RepoInfo

    sandbox = _RecordingSandbox(tmp_path)
    db = get_database(settings.sqlite_path)
    db.upsert_issue(
        key="octo/widget#88", repo="octo/widget", number=88, state="closed", branch="farm/old/branch", pr_number=99
    )

    repo = RepoInfo(
        full_name="octo/widget", default_branch="main", clone_url="https://github.com/octo/widget.git", private=False
    )
    issue = IssueInfo(
        repo="octo/widget",
        number=88,
        title="boom",
        body="details",
        state="open",
        author="alice",
        labels=(),
        is_pull_request=False,
    )

    async def _resolve(_gh, _payload):
        return repo, issue

    monkeypatch.setattr(tasks, "_resolve_repo_and_issue", _resolve)

    post_comment_calls: list = []

    async def _no_post_comment(*args, **kwargs):
        post_comment_calls.append((args, kwargs))
        return None

    monkeypatch.setattr(GitHubClient, "post_comment", _no_post_comment)

    payload = {
        "action": "created",
        "issue": {"number": 88, "user": {"login": "alice"}, "title": "boom"},
        "comment": {"user": {"login": "can1357"}, "body": "redo", "id": 2, "created_at": "2026-05-14T21:00:00Z"},
        "repository": {"full_name": "octo/widget"},
        "_robomp_directive": {"body": "redo the fix", "author": "can1357"},
    }
    await tasks.handle_comment(
        settings=settings,
        db=db,
        github=GitHubClient("t"),
        git_transport=LocalGitTransport(token=None),
        sandbox=sandbox,
        payload=payload,
        delivery_id="test-delivery-2",
    )
    assert len(stub_run_task) == 1
    call = stub_run_task[0]
    assert call["task_kind"] == "handle_comment"
    assert call["directive"].body == "redo the fix"
    assert sandbox.remove_calls == [("octo/widget", 88)]
    assert sandbox.ensure_calls
    # Reopen branches afresh (no existing_branch passed).
    assert sandbox.ensure_calls[0]["existing_branch"] is None
    assert post_comment_calls == [], "no 'this is closed' comment on reopen"
    row = db.get_issue("octo/widget#88")
    assert row is not None and row.state == "reproducing"
    close_database()


async def test_handle_comment_finalized_without_directive_still_replies(
    settings: Settings, tmp_path: Path, stub_run_task, monkeypatch
) -> None:
    """Non-maintainer on a closed issue → original behavior preserved."""
    from robomp import tasks
    from robomp.github_client import GitHubClient, IssueInfo, RepoInfo

    sandbox = _RecordingSandbox(tmp_path)
    db = get_database(settings.sqlite_path)
    db.upsert_issue(
        key="octo/widget#88", repo="octo/widget", number=88, state="closed", branch="farm/old/branch", pr_number=99
    )

    repo = RepoInfo(
        full_name="octo/widget", default_branch="main", clone_url="https://github.com/octo/widget.git", private=False
    )
    issue = IssueInfo(
        repo="octo/widget",
        number=88,
        title="boom",
        body="details",
        state="closed",
        author="alice",
        labels=(),
        is_pull_request=False,
    )

    async def _resolve(_gh, _payload):
        return repo, issue

    monkeypatch.setattr(tasks, "_resolve_repo_and_issue", _resolve)

    post_comment_calls: list = []

    async def _capture_post(self, *args, **kwargs):
        post_comment_calls.append((args, kwargs))
        return None

    monkeypatch.setattr(GitHubClient, "post_comment", _capture_post)

    payload = {
        "action": "created",
        "issue": {"number": 88, "user": {"login": "stranger"}, "title": "boom"},
        "comment": {
            "user": {"login": "stranger"},
            "body": "still broken",
            "id": 3,
            "created_at": "2026-05-14T22:00:00Z",
        },
        "repository": {"full_name": "octo/widget"},
    }
    await tasks.handle_comment(
        settings=settings,
        db=db,
        github=GitHubClient("t"),
        git_transport=LocalGitTransport(token=None),
        sandbox=sandbox,
        payload=payload,
        delivery_id="test-delivery-3",
    )
    assert stub_run_task == [], "must not invoke run_task on plain finalized comment"
    assert post_comment_calls, "should post the finalized-issue reply"
    assert sandbox.remove_calls == []
    close_database()


async def test_directive_handler_attaches_thread_from_github(
    settings: Settings, tmp_path: Path, stub_run_task, monkeypatch
) -> None:
    """When a directive lands, the handler must hydrate the thread before run_task."""
    from robomp import tasks
    from robomp.github_client import (
        CommentInfo,
        GitHubClient,
        IssueInfo,
        RepoInfo,
    )

    sandbox = _RecordingSandbox(tmp_path)
    db = get_database(settings.sqlite_path)

    repo = RepoInfo(
        full_name="octo/widget", default_branch="main", clone_url="https://github.com/octo/widget.git", private=False
    )
    issue = IssueInfo(
        repo="octo/widget",
        number=88,
        title="boom",
        body="the body",
        state="open",
        author="alice",
        labels=(),
        is_pull_request=False,
    )

    async def _resolve(_gh, _payload):
        return repo, issue

    monkeypatch.setattr(tasks, "_resolve_repo_and_issue", _resolve)

    # Stub GitHubClient endpoints used by _fetch_thread.
    async def _get_issue(self, _repo, _number):
        return issue

    async def _list_comments(self, _repo, _number):
        return [
            CommentInfo(id=1, author="alice", body="me too", created_at="2026-05-01T10:00:00Z"),
            CommentInfo(id=2, author="bob", body="confirmed", created_at="2026-05-02T10:00:00Z"),
        ]

    monkeypatch.setattr(GitHubClient, "get_issue", _get_issue)
    monkeypatch.setattr(GitHubClient, "list_comments", _list_comments)

    payload = {
        "action": "created",
        "issue": {"number": 88, "user": {"login": "alice"}, "title": "boom"},
        "comment": {
            "user": {"login": "can1357"},
            "body": "@roboomp do X",
            "id": 10,
            "created_at": "2026-05-03T20:00:00Z",
        },
        "repository": {"full_name": "octo/widget"},
        "_robomp_directive": {"body": "do X", "author": "can1357"},
    }
    # Pre-seed an issue row so we exercise the "existing, non-finalized" path
    # (otherwise we'd hit the bootstrap branch which is covered elsewhere).
    db.upsert_issue(key="octo/widget#88", repo="octo/widget", number=88, state="reproducing", branch="farm/x/y")

    await tasks.handle_comment(
        settings=settings,
        db=db,
        github=GitHubClient("t"),
        git_transport=LocalGitTransport(token=None),
        sandbox=sandbox,
        payload=payload,
        delivery_id="test-delivery-4",
    )

    assert len(stub_run_task) == 1
    directive = stub_run_task[0]["directive"]
    assert directive is not None
    assert directive.body == "do X"
    # Thread must include the body + both comments, in chronological order.
    kinds_authors = [(m.kind, m.author) for m in directive.thread]
    assert ("issue_body", "alice") in kinds_authors
    assert ("comment", "alice") in kinds_authors
    assert ("comment", "bob") in kinds_authors
    close_database()