"""Tests for ChatClient."""

from unittest.mock import Mock, patch
import pytest

import httpx

from fastgpt_client.client import ChatClient
from fastgpt_client.exceptions import ValidationError


class TestChatClientCreateChatCompletion:
    """Test suite for ChatClient.create_chat_completion method."""

    def test_create_chat_completion_basic(self, api_key, sample_chat_response):
        """Test basic chat completion creation."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200
        mock_response.json = Mock(return_value=sample_chat_response)

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.create_chat_completion(
                messages=[{"role": "user", "content": "Hello"}],
                stream=False
            )

        assert response.status_code == 200
        mock_send.assert_called_once()
        call_args = mock_send.call_args
        assert call_args[0][0] == "POST"
        assert call_args[0][1] == "/api/v1/chat/completions"
        assert call_args[1]['json']['messages'] == [{"role": "user", "content": "Hello"}]
        assert call_args[1]['stream'] is False

    def test_create_chat_completion_with_chat_id(self, api_key):
        """Test chat completion with chatId parameter."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.create_chat_completion(
                messages=[{"role": "user", "content": "Hello"}],
                chatId="chat-123"
            )

        assert response.status_code == 200
        assert mock_send.call_args[1]['json']['chatId'] == "chat-123"

    def test_create_chat_completion_with_variables(self, api_key):
        """Test chat completion with variables parameter."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.create_chat_completion(
                messages=[{"role": "user", "content": "Hello"}],
                variables={"name": "John", "city": "NYC"}
            )

        assert response.status_code == 200
        assert mock_send.call_args[1]['json']['variables'] == {"name": "John", "city": "NYC"}

    def test_create_chat_completion_with_detail(self, api_key):
        """Test chat completion with detail enabled."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.create_chat_completion(
                messages=[{"role": "user", "content": "Hello"}],
                detail=True
            )

        assert response.status_code == 200
        assert mock_send.call_args[1]['json']['detail'] is True

    def test_create_chat_completion_with_response_chat_item_id(self, api_key):
        """Test chat completion with custom responseChatItemId."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.create_chat_completion(
                messages=[{"role": "user", "content": "Hello"}],
                responseChatItemId="custom-id-123"
            )

        assert response.status_code == 200
        assert mock_send.call_args[1]['json']['responseChatItemId'] == "custom-id-123"

    def test_create_chat_completion_streaming(self, api_key, mock_stream_response):
        """Test streaming chat completion."""
        client = ChatClient(api_key)

        with patch.object(client, '_send_request', return_value=mock_stream_response) as mock_send:
            response = client.create_chat_completion(
                messages=[{"role": "user", "content": "Hello"}],
                stream=True
            )

        assert response.status_code == 200
        assert mock_send.call_args[1]['stream'] is True

    def test_create_chat_completion_all_parameters(self, api_key):
        """Test chat completion with all parameters."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.create_chat_completion(
                messages=[{"role": "user", "content": "Hello"}],
                stream=True,
                chatId="chat-123",
                detail=True,
                variables={"key": "value"},
                responseChatItemId="custom-id"
            )

        assert response.status_code == 200
        json_data = mock_send.call_args[1]['json']
        assert json_data['chatId'] == "chat-123"
        assert json_data['detail'] is True
        assert json_data['variables'] == {"key": "value"}
        assert json_data['responseChatItemId'] == "custom-id"

    def test_create_chat_completion_parameter_validation(self, api_key):
        """Test that parameter validation works for known fields."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        # Test with valid chatId (should pass validation)
        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.create_chat_completion(
                messages=[{"role": "user", "content": "Hello"}],
                chatId="valid-chat-id"
            )

        # Verify the request was sent successfully
        assert response.status_code == 200
        mock_send.assert_called_once()


class TestChatClientGetChatHistories:
    """Test suite for ChatClient.get_chat_histories method."""

    def test_get_chat_histories_basic(self, api_key, sample_chat_histories_response):
        """Test getting chat histories with basic parameters."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200
        mock_response.json = Mock(return_value=sample_chat_histories_response)

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_histories(appId="app-123")

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "POST"
        assert call_args[0][1] == "/api/core/chat/getHistories"
        assert call_args[1]['json']['appId'] == "app-123"

    def test_get_chat_histories_with_pagination(self, api_key):
        """Test getting chat histories with pagination."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_histories(
                appId="app-123",
                offset=10,
                pageSize=50
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data['offset'] == 10
        assert json_data['pageSize'] == 50

    def test_get_chat_histories_with_source(self, api_key):
        """Test getting chat histories with source filter."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_histories(
                appId="app-123",
                source="online"
            )

        assert mock_send.call_args[1]['json']['source'] == "online"

    def test_get_chat_histories_all_parameters(self, api_key):
        """Test getting chat histories with all parameters."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_histories(
                appId="app-123",
                offset=5,
                pageSize=25,
                source="share"
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data == {
            "appId": "app-123",
            "offset": 5,
            "pageSize": 25,
            "source": "share"
        }


class TestChatClientGetChatInit:
    """Test suite for ChatClient.get_chat_init method."""

    def test_get_chat_init(self, api_key):
        """Test getting chat initialization."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_init(appId="app-123", chatId="chat-123")

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "GET"
        assert call_args[0][1] == "/api/core/chat/init"
        assert call_args[1]['params'] == {"appId": "app-123", "chatId": "chat-123"}


class TestChatClientGetChatRecords:
    """Test suite for ChatClient.get_chat_records method."""

    def test_get_chat_records_basic(self, api_key, sample_chat_records_response):
        """Test getting chat records with basic parameters."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200
        mock_response.json = Mock(return_value=sample_chat_records_response)

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_records(appId="app-123", chatId="chat-123")

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "POST"
        assert call_args[0][1] == "/api/core/chat/getPaginationRecords"
        json_data = call_args[1]['json']
        assert json_data['appId'] == "app-123"
        assert json_data['chatId'] == "chat-123"

    def test_get_chat_records_with_pagination(self, api_key):
        """Test getting chat records with pagination."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_records(
                appId="app-123",
                chatId="chat-123",
                offset=20,
                pageSize=30
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data['offset'] == 20
        assert json_data['pageSize'] == 30

    def test_get_chat_records_with_custom_feedbacks(self, api_key):
        """Test getting chat records with custom feedbacks loaded."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_records(
                appId="app-123",
                chatId="chat-123",
                loadCustomFeedbacks=True
            )

        assert mock_send.call_args[1]['json']['loadCustomFeedbacks'] is True

    def test_get_chat_records_all_parameters(self, api_key):
        """Test getting chat records with all parameters."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_chat_records(
                appId="app-123",
                chatId="chat-123",
                offset=10,
                pageSize=20,
                loadCustomFeedbacks=True
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data == {
            "appId": "app-123",
            "chatId": "chat-123",
            "offset": 10,
            "pageSize": 20,
            "loadCustomFeedbacks": True
        }


class TestChatClientGetRecordDetail:
    """Test suite for ChatClient.get_record_detail method."""

    def test_get_record_detail(self, api_key):
        """Test getting record detail."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_record_detail(
                appId="app-123",
                chatId="chat-123",
                dataId="data-123"
            )

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "GET"
        assert call_args[0][1] == "/api/core/chat/getResData"
        assert call_args[1]['params'] == {
            "appId": "app-123",
            "chatId": "chat-123",
            "dataId": "data-123"
        }


class TestChatClientUpdateChatHistory:
    """Test suite for ChatClient.update_chat_history method."""

    def test_update_chat_history_title(self, api_key):
        """Test updating chat history title."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.update_chat_history(
                appId="app-123",
                chatId="chat-123",
                customTitle="New Title"
            )

        assert response.status_code == 200
        json_data = mock_send.call_args[1]['json']
        assert json_data['appId'] == "app-123"
        assert json_data['chatId'] == "chat-123"
        assert json_data['customTitle'] == "New Title"
        assert 'top' not in json_data

    def test_update_chat_history_pin(self, api_key):
        """Test pinning chat history."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.update_chat_history(
                appId="app-123",
                chatId="chat-123",
                top=True
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data['top'] is True
        assert 'customTitle' not in json_data

    def test_update_chat_history_both_parameters(self, api_key):
        """Test updating both title and pin status."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.update_chat_history(
                appId="app-123",
                chatId="chat-123",
                customTitle="Important Chat",
                top=True
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data['customTitle'] == "Important Chat"
        assert json_data['top'] is True


class TestChatClientDeleteChatHistory:
    """Test suite for ChatClient.delete_chat_history method."""

    def test_delete_chat_history(self, api_key):
        """Test deleting a chat history."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.delete_chat_history(appId="app-123", chatId="chat-123")

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "DELETE"
        assert call_args[0][1] == "/api/core/chat/delHistory"
        assert call_args[1]['params'] == {"appId": "app-123", "chatId": "chat-123"}


class TestChatClientClearChatHistories:
    """Test suite for ChatClient.clear_chat_histories method."""

    def test_clear_chat_histories(self, api_key):
        """Test clearing all chat histories."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.clear_chat_histories(appId="app-123")

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "DELETE"
        assert call_args[0][1] == "/api/core/chat/clearHistories"
        assert call_args[1]['params'] == {"appId": "app-123"}


class TestChatClientDeleteChatRecord:
    """Test suite for ChatClient.delete_chat_record method."""

    def test_delete_chat_record(self, api_key):
        """Test deleting a single chat record."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.delete_chat_record(
                appId="app-123",
                chatId="chat-123",
                contentId="content-123"
            )

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "DELETE"
        assert call_args[0][1] == "/api/core/chat/item/delete"
        assert call_args[1]['json'] == {
            "appId": "app-123",
            "chatId": "chat-123",
            "contentId": "content-123"
        }


class TestChatClientSendFeedback:
    """Test suite for ChatClient.send_feedback method."""

    def test_send_feedback_good(self, api_key):
        """Test sending positive feedback."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.send_feedback(
                appId="app-123",
                chatId="chat-123",
                dataId="data-123",
                userGoodFeedback="Great response!"
            )

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "POST"
        assert call_args[0][1] == "/api/core/chat/feedback/updateUserFeedback"
        json_data = call_args[1]['json']
        assert json_data['userGoodFeedback'] == "Great response!"
        assert 'userBadFeedback' not in json_data

    def test_send_feedback_bad(self, api_key):
        """Test sending negative feedback."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.send_feedback(
                appId="app-123",
                chatId="chat-123",
                dataId="data-123",
                userBadFeedback="Not helpful"
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data['userBadFeedback'] == "Not helpful"
        assert 'userGoodFeedback' not in json_data

    def test_send_feedback_cancel_good(self, api_key):
        """Test canceling positive feedback by passing empty string."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.send_feedback(
                appId="app-123",
                chatId="chat-123",
                dataId="data-123",
                userGoodFeedback=""
            )

        # Empty string is still sent (to cancel the feedback)
        json_data = mock_send.call_args[1]['json']
        assert 'userGoodFeedback' in json_data

    def test_send_feedback_only_required_params(self, api_key):
        """Test sending feedback with only required parameters."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.send_feedback(
                appId="app-123",
                chatId="chat-123",
                dataId="data-123"
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data == {
            "appId": "app-123",
            "chatId": "chat-123",
            "dataId": "data-123"
        }


class TestChatClientGetSuggestedQuestions:
    """Test suite for ChatClient.get_suggested_questions method."""

    def test_get_suggested_questions_basic(self, api_key):
        """Test getting suggested questions."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_suggested_questions(
                appId="app-123",
                chatId="chat-123"
            )

        assert response.status_code == 200
        call_args = mock_send.call_args
        assert call_args[0][0] == "POST"
        assert call_args[0][1] == "/api/core/ai/agent/v2/createQuestionGuide"
        json_data = call_args[1]['json']
        assert json_data['appId'] == "app-123"
        assert json_data['chatId'] == "chat-123"
        assert 'questionGuide' not in json_data

    def test_get_suggested_questions_with_guide(self, api_key):
        """Test getting suggested questions with custom question guide."""
        client = ChatClient(api_key)

        mock_response = Mock(spec=httpx.Response)
        mock_response.status_code = 200

        question_guide = {
            "maxQuestions": 5,
            "contextWindow": 10
        }

        with patch.object(client, '_send_request', return_value=mock_response) as mock_send:
            response = client.get_suggested_questions(
                appId="app-123",
                chatId="chat-123",
                questionGuide=question_guide
            )

        json_data = mock_send.call_args[1]['json']
        assert json_data['questionGuide'] == question_guide