"""Unit tests for the Claude Code session provider."""

import json

import pytest

from src.blocks import (
    BLOCK_TYPE_COLLAPSED,
    BLOCK_TYPE_TEXT,
    BLOCK_TYPE_THINKING,
    BLOCK_TYPE_TOOL_RESULT,
    BLOCK_TYPE_TOOL_USE,
    render_blocks_to_markdown,
)
from src.loss_report import LossReport
from src.providers.claude_code import ClaudeCodeProvider


def _write_session(tmp_path, records, project_dir="-home-jesse-myproj", name="abc-123"):
    proj = tmp_path / project_dir
    proj.mkdir(parents=True, exist_ok=True)
    f = proj / f"{name}.jsonl"
    f.write_text("\n".join(json.dumps(r) for r in records), encoding="utf-8")
    return f


def _records():
    """A representative session: title, harness noise, dialogue, tool traffic."""
    return [
        {"type": "ai-title", "aiTitle": "First title", "sessionId": "abc-123"},
        {
            "type": "user",
            "cwd": "/home/jesse/myproj",
            "timestamp": "2026-05-01T10:00:00.000Z",
            "message": {
                "role": "user",
                "content": (
                    "<local-command-caveat>Caveat: ignore</local-command-caveat>"
                    "<command-name>/model</command-name>"
                    "<local-command-stdout>Set model</local-command-stdout>"
                    "Please review my project."
                ),
            },
        },
        {
            "type": "assistant",
            "timestamp": "2026-05-01T10:00:05.000Z",
            "message": {
                "role": "assistant",
                "content": [
                    {"type": "thinking", "thinking": "Let me think about this."},
                    {"type": "text", "text": "I'll review it now."},
                    {"type": "tool_use", "id": "t1", "name": "Read", "input": {"file_path": "/x"}},
                    {"type": "tool_use", "id": "t2", "name": "Read", "input": {"file_path": "/y"}},
                    {"type": "tool_use", "id": "t3", "name": "Bash", "input": {"command": "ls"}},
                ],
            },
        },
        {
            "type": "user",
            "timestamp": "2026-05-01T10:00:08.000Z",
            "message": {
                "role": "user",
                "content": [
                    {"type": "tool_result", "tool_use_id": "t1", "content": "file contents " * 50},
                ],
            },
        },
        {
            "type": "assistant",
            "timestamp": "2026-05-01T10:00:20.000Z",
            "message": {
                "role": "assistant",
                "content": [{"type": "text", "text": "Here is my review: all good."}],
            },
        },
        # Harness records — skipped
        {"type": "file-history-snapshot", "snapshot": {"big": "blob"}},
        {"type": "permission-mode", "mode": "plan"},
        # Subagent and meta records — skipped
        {
            "type": "assistant",
            "isSidechain": True,
            "message": {"role": "assistant", "content": [{"type": "text", "text": "subagent noise"}]},
        },
        {
            "type": "user",
            "isMeta": True,
            "message": {"role": "user", "content": "meta noise"},
        },
        # Later title wins
        {"type": "ai-title", "aiTitle": "Review my project", "sessionId": "abc-123"},
    ]


class TestClaudeCodeProvider:
    def _provider(self, tmp_path, policy="placeholder"):
        return ClaudeCodeProvider(projects_dir=tmp_path, hidden_content=policy)

    def test_listing_metadata(self, tmp_path):
        _write_session(tmp_path, _records())
        p = self._provider(tmp_path)
        convs = p.fetch_all_conversations()
        assert len(convs) == 1
        c = convs[0]
        assert c["id"] == "abc-123"
        assert c["title"] == "Review my project"  # last ai-title wins
        assert c["_project_name"] == "myproj"  # from cwd basename
        assert c["created_at"] == "2026-05-01T10:00:00.000Z"
        assert c["updated_at"]  # file mtime

    def test_empty_files_skipped(self, tmp_path):
        proj = tmp_path / "-home-x"
        proj.mkdir()
        (proj / "empty.jsonl").write_text("")
        p = self._provider(tmp_path)
        assert p.fetch_all_conversations() == []

    def test_normalize_prose_only_default(self, tmp_path):
        _write_session(tmp_path, _records())
        p = self._provider(tmp_path)
        p.fetch_all_conversations()
        raw = p.get_conversation("abc-123")
        result = p.normalize_conversation(raw)

        assert result["provider"] == "claude-code"
        assert result["title"] == "Review my project"
        assert result["project"] == "myproj"

        roles = [m["role"] for m in result["messages"]]
        assert roles == ["user", "assistant", "assistant"]

        # Harness tags stripped, dialogue kept
        user_text = result["messages"][0]["blocks"][0]["text"]
        assert user_text == "Please review my project."
        assert "Caveat" not in user_text

        # Tool activity collapsed into one grouped placeholder on the
        # assistant message that ran the tools (includes the tool_result
        # bytes from the following user record).
        first_assistant = result["messages"][1]
        types = [b["type"] for b in first_assistant["blocks"]]
        assert types == [BLOCK_TYPE_TEXT, BLOCK_TYPE_COLLAPSED]
        collapsed = first_assistant["blocks"][1]
        assert "3 calls" in collapsed["origin"]
        assert "Read ×2" in collapsed["origin"]
        assert "Bash ×1" in collapsed["origin"]
        assert collapsed["size_bytes"] > 500

        # Thinking dropped without placeholder; sidechain/meta absent
        all_blocks = [b for m in result["messages"] for b in m["blocks"]]
        assert not any(b["type"] == BLOCK_TYPE_THINKING for b in all_blocks)
        assert not any(
            "subagent noise" in (b.get("text") or "") or "meta noise" in (b.get("text") or "")
            for b in all_blocks
        )

    def test_collapsed_counted_in_loss_report(self, tmp_path):
        _write_session(tmp_path, _records())
        p = self._provider(tmp_path)
        p.fetch_all_conversations()
        report = LossReport()
        p.normalize_conversation(p.get_conversation("abc-123"), report)
        assert report.collapsed["Read"] == 2
        assert report.collapsed["Bash"] == 1
        assert report.collapsed["tool_result"] == 1
        assert report.collapsed["thinking"] == 1
        assert report.collapsed_bytes > 500

    def test_full_policy_keeps_everything(self, tmp_path):
        _write_session(tmp_path, _records())
        p = self._provider(tmp_path, policy="full")
        p.fetch_all_conversations()
        result = p.normalize_conversation(p.get_conversation("abc-123"))
        all_blocks = [b for m in result["messages"] for b in m["blocks"]]
        types = {b["type"] for b in all_blocks}
        assert BLOCK_TYPE_THINKING in types
        assert BLOCK_TYPE_TOOL_USE in types
        assert BLOCK_TYPE_TOOL_RESULT in types
        assert BLOCK_TYPE_COLLAPSED not in types

    def test_updated_at_consistent_with_listing(self, tmp_path):
        """Listing and normalized updated_at must match or the cache would
        consider every session stale on every run (mtime vs last timestamp)."""
        _write_session(tmp_path, _records())
        p = self._provider(tmp_path)
        listing = p.fetch_all_conversations()[0]
        normalized = p.normalize_conversation(p.get_conversation("abc-123"))
        assert normalized["updated_at"] == listing["updated_at"]

    def test_title_falls_back_to_first_prompt(self, tmp_path):
        records = [r for r in _records() if r.get("type") != "ai-title"]
        _write_session(tmp_path, records)
        p = self._provider(tmp_path)
        p.fetch_all_conversations()
        result = p.normalize_conversation(p.get_conversation("abc-123"))
        assert result["title"] == "Please review my project."

    def test_unknown_block_type_surfaces(self, tmp_path):
        records = [
            {
                "type": "assistant",
                "timestamp": "2026-05-01T10:00:00.000Z",
                "cwd": "/home/jesse/myproj",
                "message": {
                    "role": "assistant",
                    "content": [
                        {"type": "text", "text": "hello"},
                        {"type": "future_block_xyz", "data": 1},
                    ],
                },
            },
        ]
        _write_session(tmp_path, records)
        p = self._provider(tmp_path)
        p.fetch_all_conversations()
        report = LossReport()
        result = p.normalize_conversation(p.get_conversation("abc-123"), report)
        assert report.unknown_blocks["claude-code.future_block_xyz"] == 1
        rendered = render_blocks_to_markdown(result["messages"][0]["blocks"])
        assert "Unsupported content" in rendered

    def test_collapsed_placeholder_renders_grouped_line(self, tmp_path):
        _write_session(tmp_path, _records())
        p = self._provider(tmp_path)
        p.fetch_all_conversations()
        result = p.normalize_conversation(p.get_conversation("abc-123"))
        rendered = render_blocks_to_markdown(result["messages"][1]["blocks"])
        assert "> 🔧 **Tool output** — `3 calls: Read ×2, Bash ×1`" in rendered
        assert "omitted (EXPORTER_HIDDEN_CONTENT=full to keep)" in rendered