"""Unit tests for SessionManager — no Jupyter server fixture."""
from __future__ import annotations

import pytest

from opencode_bridge.session_manager import SessionManager


class FakeClient:
    """Mimics OpenCodeClient just enough for SessionManager."""
    def __init__(self, session_id: str = "sid-from-fake") -> None:
        self._session_id = session_id
        self.calls: list = []

    async def create_session(self, title: str) -> dict:
        self.calls.append(("create_session", title))
        return {"id": self._session_id, "title": title}

    async def delete_session(self, session_id: str) -> bool:
        self.calls.append(("delete_session", session_id))
        return True


@pytest.mark.asyncio
async def test_get_or_create_first_call_creates_session():
    client = FakeClient()
    sm = SessionManager(lambda: client)
    sid = await sm.get_or_create("foo.ipynb")
    assert sid == "sid-from-fake"
    assert sm.has_session("foo.ipynb")
    assert client.calls == [("create_session", "jupyter:foo.ipynb")]


@pytest.mark.asyncio
async def test_get_or_create_second_call_returns_same_sid():
    client = FakeClient()
    sm = SessionManager(lambda: client)
    sid1 = await sm.get_or_create("foo.ipynb")
    sid2 = await sm.get_or_create("foo.ipynb")
    assert sid1 == sid2
    # Only ONE create_session call total
    create_calls = [c for c in client.calls if c[0] == "create_session"]
    assert len(create_calls) == 1


@pytest.mark.asyncio
async def test_different_notebooks_get_different_sessions():
    client1 = FakeClient(session_id="sid-1")
    client2 = FakeClient(session_id="sid-2")
    factories = [client1, client2]
    sm = SessionManager(lambda: factories.pop(0) if factories else client1)
    sid1 = await sm.get_or_create("foo.ipynb")
    sid2 = await sm.get_or_create("bar.ipynb")
    assert sid1 == "sid-1"
    assert sid2 == "sid-2"


@pytest.mark.asyncio
async def test_release_returns_true_and_clears_session():
    client = FakeClient()
    sm = SessionManager(lambda: client)
    await sm.get_or_create("foo.ipynb")
    deleted = await sm.release("foo.ipynb")
    assert deleted is True
    assert not sm.has_session("foo.ipynb")
    assert ("delete_session", "sid-from-fake") in client.calls


@pytest.mark.asyncio
async def test_release_returns_false_when_no_session():
    client = FakeClient()
    sm = SessionManager(lambda: client)
    deleted = await sm.release("never-existed.ipynb")
    assert deleted is False
    assert client.calls == []


@pytest.mark.asyncio
async def test_get_or_create_after_release_creates_new_session():
    client = FakeClient()
    sm = SessionManager(lambda: client)
    sid1 = await sm.get_or_create("foo.ipynb")
    await sm.release("foo.ipynb")
    sid2 = await sm.get_or_create("foo.ipynb")
    # Same fake client returns same ID, but two create_session calls happened
    assert sid1 == sid2
    create_calls = [c for c in client.calls if c[0] == "create_session"]
    assert len(create_calls) == 2


@pytest.mark.asyncio
async def test_invalidate_drops_cached_sid_without_calling_opencode():
    client = FakeClient()
    sm = SessionManager(lambda: client)
    await sm.get_or_create("foo.ipynb")
    calls_before = len(client.calls)
    removed = sm.invalidate("foo.ipynb")
    assert removed is True
    assert not sm.has_session("foo.ipynb")
    # No additional calls to client
    assert len(client.calls) == calls_before


def test_list_sessions_empty():
    sm = SessionManager(lambda: FakeClient())
    assert sm.list_sessions() == []


@pytest.mark.asyncio
async def test_list_sessions_returns_all_mappings():
    client = FakeClient()
    sm = SessionManager(lambda: client)
    await sm.get_or_create("a.ipynb")
    # Manually inject a second to test listing
    sm._sessions["b.ipynb"] = "sid-b"
    listing = sm.list_sessions()
    paths = {s["notebookPath"] for s in listing}
    assert paths == {"a.ipynb", "b.ipynb"}


@pytest.mark.asyncio
async def test_concurrent_get_or_create_does_not_double_create():
    """Two concurrent calls for the same path must share one session."""
    import asyncio

    client = FakeClient()
    sm = SessionManager(lambda: client)
    sids = await asyncio.gather(
        sm.get_or_create("foo.ipynb"),
        sm.get_or_create("foo.ipynb"),
        sm.get_or_create("foo.ipynb"),
    )
    assert sids[0] == sids[1] == sids[2]
    create_calls = [c for c in client.calls if c[0] == "create_session"]
    assert len(create_calls) == 1, "concurrent get_or_create must not double-create"