from __future__ import annotations

from typing import Any

import pytest


def test_dashboard_plan_url_uses_plan_path(monkeypatch: pytest.MonkeyPatch) -> None:
    monkeypatch.setenv("DASHBOARD_BASE_URL", "https://example.test")
    from agent.utils.dashboard_links import dashboard_plan_url

    assert dashboard_plan_url("abc-123") == "https://example.test/agents/abc-123/plan"


def test_dashboard_plan_url_none_without_thread() -> None:
    from agent.utils.dashboard_links import dashboard_plan_url

    assert dashboard_plan_url("") is None


def test_format_comments_numbers_and_skips_blank() -> None:
    from agent.dashboard.plan_api import _format_comments

    text = _format_comments(
        [
            {"author": "alice", "body": "add a docstring"},
            {"author": "bob", "body": "looks good"},
            {"author": "carol", "body": "   "},  # blank → skipped
        ]
    )
    assert "1. alice: add a docstring" in text
    assert "2. bob: looks good" in text
    assert "carol" not in text


def test_format_comments_empty() -> None:
    from agent.dashboard.plan_api import _format_comments

    assert _format_comments([]) == ""


def test_plan_comment_helpers_exported() -> None:
    from agent.dashboard import plan_store

    assert plan_store.PLAN_COMMENTS_NAMESPACE == ["plan", "comments"]
    assert callable(plan_store.add_plan_comment)
    assert callable(plan_store.list_plan_comments)
    assert callable(plan_store.delete_plan_comment)
    assert callable(plan_store.clear_plan_comments)


def _fake_client(store: Any) -> Any:
    return type("C", (), {"store": store})()


async def test_list_plan_comments_swallows_errors_by_default(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from agent.dashboard import plan_store

    class _Store:
        async def search_items(self, *a: Any, **k: Any) -> Any:
            raise RuntimeError("boom")

    monkeypatch.setattr(plan_store, "_client", lambda: _fake_client(_Store()))
    assert await plan_store.list_plan_comments("t") == []


async def test_list_plan_comments_raises_with_flag(monkeypatch: pytest.MonkeyPatch) -> None:
    from agent.dashboard import plan_store

    class _Store:
        async def search_items(self, *a: Any, **k: Any) -> Any:
            raise RuntimeError("boom")

    monkeypatch.setattr(plan_store, "_client", lambda: _fake_client(_Store()))
    with pytest.raises(RuntimeError):
        await plan_store.list_plan_comments("t", raise_on_error=True)


async def test_clear_plan_comments_deletes_each(monkeypatch: pytest.MonkeyPatch) -> None:
    from agent.dashboard import plan_store

    deleted: list[str] = []

    class _Store:
        async def search_items(self, *a: Any, **k: Any) -> Any:
            return {"items": [{"value": {"id": "a"}}, {"value": {"id": "b"}}]}

        async def delete_item(self, _ns: Any, key: str) -> None:
            deleted.append(key)

    monkeypatch.setattr(plan_store, "_client", lambda: _fake_client(_Store()))
    await plan_store.clear_plan_comments("t")
    assert deleted == ["a", "b"]


async def test_save_plan_requires_run_context() -> None:
    from agent.tools.save_plan import save_plan

    # No LangGraph run context → no thread_id → graceful error, not a crash.
    result = await save_plan("## Plan")
    assert result["success"] is False
    assert "thread_id" in result["error"]


async def test_save_plan_rejects_empty_markdown() -> None:
    from agent.tools.save_plan import save_plan

    result = await save_plan("   ")
    assert result["success"] is False
    assert "empty" in result["error"]


def test_plan_routes_registered() -> None:
    from agent.webapp import app

    paths = set()
    for route in app.routes:
        if hasattr(route, "path"):
            paths.add(route.path)
        included = getattr(route, "original_router", None)
        if included is not None:
            paths.update(r.path for r in included.routes if hasattr(r, "path"))
    assert "/dashboard/api/plan/{thread_id}" in paths
    assert "/dashboard/api/plan/{thread_id}/approve" in paths
    assert "/dashboard/api/plan/{thread_id}/reject" in paths
    assert "/dashboard/api/plan/{thread_id}/comments" in paths
    assert "/dashboard/api/plan/{thread_id}/comments/{comment_id}" in paths
    assert "/dashboard/api/plan/yjs/{thread_id}" not in paths


def test_save_plan_exported_and_wired() -> None:
    from agent.tools import save_plan

    assert callable(save_plan)


def test_plan_status_constants() -> None:
    from agent.dashboard import plan_store

    assert plan_store.PLAN_STATUS_READY == "ready"
    assert plan_store.PLAN_STATUS_PLANNING == "planning"
    assert plan_store.PLAN_STATUS_APPROVED == "approved"
    assert plan_store.PLAN_STATUS_REVISING == "revising"


def test_http_request_excluded_in_plan_mode() -> None:
    from agent.server import PLAN_MODE_EXCLUDED_TOOLS

    assert "http_request" in PLAN_MODE_EXCLUDED_TOOLS


class _FakeReq:
    def __init__(self, tools: list[Any], state: dict[str, Any]) -> None:
        self.tools = tools
        self.state = state

    def override(self, **kw: Any) -> _FakeReq:
        return _FakeReq(kw.get("tools", self.tools), self.state)


def _names(req: _FakeReq) -> set[str]:
    return {t["name"] for t in req.tools}


def test_plan_mode_middleware_initial_always_filters() -> None:
    from agent.middleware import PlanModeMiddleware

    mw = PlanModeMiddleware(excluded=frozenset({"write_file"}), initial=True)
    req = _FakeReq([{"name": "read_file"}, {"name": "write_file"}], {})
    assert _names(mw._filter(req)) == {"read_file"}


def test_plan_mode_middleware_self_activation_via_state() -> None:
    from agent.middleware import PlanModeMiddleware

    mw = PlanModeMiddleware(excluded=frozenset({"write_file"}), initial=False)
    # Plan mode not yet active: nothing filtered.
    off = _FakeReq([{"name": "read_file"}, {"name": "write_file"}], {})
    assert _names(mw._filter(off)) == {"read_file", "write_file"}
    # After enter_plan_mode sets state: the next request is filtered.
    on = _FakeReq([{"name": "read_file"}, {"name": "write_file"}], {"plan_mode": True})
    assert _names(mw._filter(on)) == {"read_file"}


def test_plan_approved_slack_text_mentions_comments_actor_and_start() -> None:
    from agent.dashboard.plan_api import _plan_approved_slack_text

    text = _plan_approved_slack_text(3, "Alice")
    assert text == "Plan approved with 3 comments by Alice\nbeginning implementation"


async def test_approve_plan_posts_slack_approval_notice(monkeypatch: pytest.MonkeyPatch) -> None:
    from agent.dashboard import plan_api

    metadata = {
        "github_login": "alice",
        "source_context": {"slack_thread": {"channel_id": "C1", "thread_ts": "1700000000.0001"}},
    }
    posted: dict[str, Any] = {}

    async def fake_thread_metadata(thread_id: str) -> dict[str, Any]:
        return metadata

    def fake_user_owns_thread(md: dict, sub: str, email: str | None) -> bool:
        return True

    async def fake_list_plan_comments(
        thread_id: str, *, raise_on_error: bool = False
    ) -> list[dict]:
        return [{"author": "bob", "body": "tweak this"}]

    async def fake_set_plan_status(thread_id: str, status: str, *, plan_mode: bool) -> None:
        posted["status"] = {"status": status, "plan_mode": plan_mode}

    async def fake_dispatch_followup(
        thread_id: str, md: dict, text: str, *, plan_mode: bool
    ) -> None:
        posted["dispatch"] = {"text": text, "plan_mode": plan_mode}

    async def fake_post_slack_thread_reply(channel_id: str, thread_ts: str, text: str) -> bool:
        posted["slack"] = {"channel_id": channel_id, "thread_ts": thread_ts, "text": text}
        return True

    monkeypatch.setattr(plan_api, "_thread_metadata", fake_thread_metadata)
    monkeypatch.setattr(plan_api, "_user_owns_thread", fake_user_owns_thread)
    monkeypatch.setattr(plan_api, "list_plan_comments", fake_list_plan_comments)
    monkeypatch.setattr(plan_api, "set_plan_status", fake_set_plan_status)
    monkeypatch.setattr(plan_api, "_dispatch_followup", fake_dispatch_followup)
    monkeypatch.setattr(plan_api, "post_slack_thread_reply", fake_post_slack_thread_reply)

    result = await plan_api.approve_plan("tid", session={"sub": "u1", "name": "Alice"})

    assert result == {"status": plan_api.PLAN_STATUS_APPROVED}
    assert posted["dispatch"]["plan_mode"] is False
    assert posted["slack"] == {
        "channel_id": "C1",
        "thread_ts": "1700000000.0001",
        "text": "Plan approved with 1 comments by Alice\nbeginning implementation",
    }