import json

import pytest

from src.api import endpoints
from src.api.endpoints import get_info, set_info
from src.schemas.models import ProcessRequest_get, ProcessRequest_set


class FakeResponse:
    def __init__(self, payload):
        self._payload = payload

    def raise_for_status(self):
        return None

    def json(self):
        return self._payload


class FakeInfoClient:
    def __init__(self, state):
        self.state = state
        self.completion_calls = []

    async def create_chat_completion(self, **kwargs):
        self.completion_calls.append(kwargs)
        if "variables" in kwargs:
            self.state = kwargs["variables"]["state"]
        return FakeResponse({"newVariables": {"state": self.state}})


@pytest.fixture
def skip_helper_record_deletion(monkeypatch):
    calls = []

    async def fake_delete(client, session_id):
        calls.append(session_id)

    monkeypatch.setattr(endpoints, "delete_last_two_chat_records", fake_delete)
    return calls


def make_set_request(**overrides):
    payload = {
        "sessionId": "session-001",
        "timeStamp": "20260726120000",
        "key": "hphm1",
        "value": "<PLATE_1>",
    }
    payload.update(overrides)
    return ProcessRequest_set(**payload)


def make_get_request(**overrides):
    payload = {
        "sessionId": "session-001",
        "timeStamp": "20260726120000",
        "key": "all",
    }
    payload.update(overrides)
    return ProcessRequest_get(**payload)


@pytest.mark.asyncio
async def test_set_info_reads_then_writes_fastgpt_state(
    skip_helper_record_deletion,
):
    client = FakeInfoClient({"hphm1": "<PLATE_OLD>", "jdcsl": 1})

    response = await set_info(make_set_request(), client=client)

    assert response.code == "200"
    assert client.state == {"hphm1": "<PLATE_1>", "jdcsl": 1}
    assert len(client.completion_calls) == 2
    assert client.completion_calls[1]["variables"]["state"] == client.state
    assert skip_helper_record_deletion == ["session-001", "session-001"]


@pytest.mark.asyncio
async def test_set_info_include_input_info_keeps_legacy_magic_payload(
    skip_helper_record_deletion,
):
    client = FakeInfoClient({})

    await set_info(make_set_request(includeInputInfo=True), client=client)

    message = client.completion_calls[0]["messages"][0]["content"]
    assert message == '<setInfo>{"key": "hphm1", "value": "<PLATE_1>"}</setInfo>'


@pytest.mark.asyncio
async def test_get_info_all_keeps_json_string_and_boolean_encoding(
    skip_helper_record_deletion,
):
    client = FakeInfoClient(
        {
            "ywrysw": False,
            "ywfjdc": True,
            "jdcsl": 2,
            "xm1": "<PERSON_1>",
            "hphm1": "<PLATE_1>",
            "xm2": "<PERSON_2>",
        }
    )

    response = await get_info(make_get_request(), client=client)
    value = json.loads(response.value)

    assert response.code == "200"
    assert isinstance(response.value, str)
    assert value["acdinfo"]["ywrysw"] == "0"
    assert value["acdinfo"]["ywfjdc"] == "1"
    assert value["acdinfo"]["jdcsl"] == 2
    assert value["acdhuman1"]["xm1"] == "<PERSON_1>"
    assert value["acdhuman2"]["xm2"] == "<PERSON_2>"
    assert skip_helper_record_deletion == ["session-001"]


@pytest.mark.asyncio
async def test_get_info_unknown_key_returns_json_encoded_empty_string(
    skip_helper_record_deletion,
):
    client = FakeInfoClient({})

    response = await get_info(
        make_get_request(key="unknown_legacy_key"),
        client=client,
    )

    assert response.code == "200"
    assert response.value == '""'


@pytest.mark.asyncio
async def test_get_info_fastgpt_shape_error_keeps_legacy_business_error():
    class InvalidClient:
        async def create_chat_completion(self, **kwargs):
            return FakeResponse({})

    response = await get_info(make_get_request(), client=InvalidClient())

    assert response.code == "500"
    assert response.value == ""
    assert response.msg == "大模型服务器无响应"