"""Tests for opencode_bridge.opencode_client."""

import json
from io import BytesIO
from unittest.mock import MagicMock

import pytest
import tornado.httpclient
import tornado.httputil

from opencode_bridge.config import OpenCodeConfig
from opencode_bridge.opencode_client import OpenCodeClient, OpenCodeError


class MockHTTPClient:
    def __init__(self) -> None:
        self.calls: list[dict] = []
        self.responses: list[tuple[int, object]] = []

    async def fetch(self, request, **kwargs) -> tornado.httpclient.HTTPResponse:
        self.calls.append({"request": request, "kwargs": kwargs})
        status, body = self.responses.pop(0)
        buffer = BytesIO(json.dumps(body).encode("utf-8"))
        return tornado.httpclient.HTTPResponse(
            request=request,
            code=status,
            headers=tornado.httputil.HTTPHeaders(),
            buffer=buffer,
        )


@pytest.fixture
def base_config() -> OpenCodeConfig:
    return OpenCodeConfig(
        url="http://127.0.0.1:4096",
        user="opencode",
        password="",
        request_timeout_seconds=120,
    )


def _make_client(
    config: OpenCodeConfig, responses: list[tuple[int, object]]
) -> tuple[OpenCodeClient, MockHTTPClient]:
    mock = MockHTTPClient()
    mock.responses = responses
    return OpenCodeClient(config, http_client=mock), mock


@pytest.mark.asyncio
async def test_health_gets_global_health(base_config: OpenCodeConfig) -> None:
    client, mock = _make_client(base_config, [(200, {"status": "ok"})])
    result = await client.health()
    assert result == {"status": "ok"}
    assert len(mock.calls) == 1
    call = mock.calls[0]
    assert call["request"].url == "http://127.0.0.1:4096/global/health"
    assert call["request"].method == "GET"


@pytest.mark.asyncio
async def test_create_session_posts_title(base_config: OpenCodeConfig) -> None:
    client, mock = _make_client(base_config, [(200, {"id": "s1"})])
    result = await client.create_session("foo")
    assert result == {"id": "s1"}
    call = mock.calls[0]
    assert call["request"].url == "http://127.0.0.1:4096/session"
    assert call["request"].method == "POST"
    body = json.loads(call["request"].body.decode("utf-8"))
    assert body == {"title": "foo"}


@pytest.mark.asyncio
async def test_auth_set_on_request_when_password_present(
    base_config: OpenCodeConfig,
) -> None:
    """Bug fix: auth must live on the HTTPRequest, not as fetch kwargs
    (tornado rejects fetch(request, **kwargs) for request-construction kwargs)."""
    config = base_config._replace(password="secret")
    client, mock = _make_client(config, [(200, {"status": "ok"})])
    await client.health()
    call = mock.calls[0]
    # No kwargs forwarded to fetch.
    assert call["kwargs"] == {}
    # Auth is on the HTTPRequest.
    assert call["request"].auth_username == "opencode"
    assert call["request"].auth_password == "secret"


@pytest.mark.asyncio
async def test_auth_absent_when_no_password(base_config: OpenCodeConfig) -> None:
    client, mock = _make_client(base_config, [(200, {"status": "ok"})])
    await client.health()
    call = mock.calls[0]
    assert call["kwargs"] == {}
    assert call["request"].auth_username is None
    assert call["request"].auth_password is None


@pytest.mark.asyncio
async def test_send_message_sync_includes_model_when_provider_and_model_given(
    base_config: OpenCodeConfig,
) -> None:
    client, mock = _make_client(base_config, [(200, {"done": True})])
    parts = [{"type": "text", "text": "hello"}]
    result = await client.send_message_sync("s1", parts, provider_id="p1", model_id="m1")
    assert result == {"done": True}
    call = mock.calls[0]
    assert call["request"].url == "http://127.0.0.1:4096/session/s1/message"
    body = json.loads(call["request"].body.decode("utf-8"))
    assert body["parts"] == parts
    assert body["model"] == {"providerID": "p1", "modelID": "m1"}


@pytest.mark.asyncio
async def test_send_message_sync_omits_model_when_provider_or_model_missing(
    base_config: OpenCodeConfig,
) -> None:
    client, mock = _make_client(base_config, [(200, {"done": True})])
    parts = [{"type": "text", "text": "hello"}]
    result = await client.send_message_sync("s1", parts)
    assert result == {"done": True}
    call = mock.calls[0]
    body = json.loads(call["request"].body.decode("utf-8"))
    assert body["parts"] == parts
    assert "model" not in body


@pytest.mark.asyncio
async def test_send_message_sync_includes_system_when_provided() -> None:
    """system param is forwarded into the request body when not None."""
    config = OpenCodeConfig(
        url="http://x:1", user="u", password="", request_timeout_seconds=120
    )
    mock = MockHTTPClient()
    mock.responses.append((200, {"info": {}, "parts": []}))
    client = OpenCodeClient(config, http_client=mock)

    await client.send_message_sync("sid", [{"type": "text", "text": "hi"}], system="be brief")

    assert len(mock.calls) == 1
    body = json.loads(mock.calls[0]["request"].body.decode("utf-8"))
    assert body["system"] == "be brief"
    assert body["parts"] == [{"type": "text", "text": "hi"}]


@pytest.mark.asyncio
async def test_delete_session_returns_bool_by_status(base_config: OpenCodeConfig) -> None:
    client, mock = _make_client(base_config, [(200, True), (404, False)])
    assert await client.delete_session("s1") is True
    assert await client.delete_session("s1") is False
    assert len(mock.calls) == 2
    assert mock.calls[0]["request"].method == "DELETE"
    assert mock.calls[0]["request"].url == "http://127.0.0.1:4096/session/s1"


@pytest.mark.asyncio
async def test_non_2xx_response_raises_with_body(base_config: OpenCodeConfig) -> None:
    client, mock = _make_client(base_config, [(500, {"error": "boom"})])
    with pytest.raises(OpenCodeError) as exc_info:
        await client.health()
    assert "boom" in str(exc_info.value)


def test_close_is_idempotent() -> None:
    """close() can be called multiple times safely."""
    client = OpenCodeClient(OpenCodeConfig(
        url="http://x", user="u", password="", request_timeout_seconds=10
    ))
    client.close()
    client.close()  # must not raise
    assert client._http_client is None


def test_close_does_not_close_injected_client() -> None:
    """close() must not call .close() on a client it didn't create."""
    injected = MagicMock()
    client = OpenCodeClient(OpenCodeConfig(
        url="http://x", user="u", password="", request_timeout_seconds=10
    ), http_client=injected)
    client.close()
    injected.close.assert_not_called()
    assert client._http_client is None