"""
Integration tests for shared session functionality in main.py
"""

import os
import sys
from unittest.mock import MagicMock, patch

import pytest

# Add the litellm directory to the path
sys.path.insert(0, os.path.abspath("../../.."))

import litellm


class TestSharedSessionIntegration:
    """Test cases for shared session integration in main.py"""

    def test_acompletion_shared_session_parameter(self):
        """Test that acompletion accepts shared_session parameter"""
        import inspect

        # Get the function signature
        sig = inspect.signature(litellm.acompletion)
        params = list(sig.parameters.keys())

        # Verify shared_session parameter exists
        assert "shared_session" in params

        # Verify the parameter type annotation
        shared_session_param = sig.parameters["shared_session"]
        assert "ClientSession" in str(shared_session_param.annotation)

        # Verify default value is None
        assert shared_session_param.default is None

    def test_completion_shared_session_parameter(self):
        """Test that completion accepts shared_session parameter"""
        import inspect

        # Get the function signature
        sig = inspect.signature(litellm.completion)
        params = list(sig.parameters.keys())

        # Verify shared_session parameter exists
        assert "shared_session" in params

        # Verify the parameter type annotation
        shared_session_param = sig.parameters["shared_session"]
        assert "ClientSession" in str(shared_session_param.annotation)

        # Verify default value is None
        assert shared_session_param.default is None

    @pytest.mark.asyncio
    async def test_acompletion_with_shared_session_mock(self):
        """Test acompletion with mocked shared session (no actual API call)"""
        import inspect

        # Create a mock session
        mock_session = MagicMock()
        mock_session.closed = False

        # Mock the completion function to avoid actual API calls
        with patch("litellm.completion") as mock_completion:
            mock_completion.return_value = {
                "choices": [{"message": {"content": "test"}}]
            }

            # This should not raise an error even though we can't make actual API calls
            try:
                # We can't actually call acompletion without proper setup,
                # but we can verify the parameter is accepted
                sig = inspect.signature(litellm.acompletion)
                assert "shared_session" in sig.parameters
            except Exception as e:
                # Expected to fail due to missing API keys, but parameter should be valid
                sig = inspect.signature(litellm.acompletion)
                assert "shared_session" in sig.parameters

    def test_shared_session_passed_to_completion_kwargs(self):
        """Test that shared_session is passed through completion_kwargs"""
        # This test verifies that the shared_session parameter
        # is properly included in the completion_kwargs dictionary

        # We can't easily test the internal logic without mocking,
        # but we can verify the parameter exists in the function signature
        import inspect

        sig = inspect.signature(litellm.acompletion)
        shared_session_param = sig.parameters["shared_session"]

        # Verify the parameter is properly typed
        assert "ClientSession" in str(shared_session_param.annotation)
        assert shared_session_param.default is None

    def test_backward_compatibility(self):
        """Test that existing code without shared_session still works"""
        import inspect

        # Verify that shared_session has a default value of None
        sig = inspect.signature(litellm.acompletion)
        shared_session_param = sig.parameters["shared_session"]

        # This ensures backward compatibility
        assert shared_session_param.default is None

    def test_type_annotations_consistency(self):
        """Test that type annotations are consistent between acompletion and completion"""
        import inspect

        # Get signatures for both functions
        acompletion_sig = inspect.signature(litellm.acompletion)
        completion_sig = inspect.signature(litellm.completion)

        # Get the shared_session parameters
        acompletion_param = acompletion_sig.parameters["shared_session"]
        completion_param = completion_sig.parameters["shared_session"]

        # Verify they have the same type annotation
        assert str(acompletion_param.annotation) == str(completion_param.annotation)

        # Verify they have the same default value
        assert acompletion_param.default == completion_param.default

    def test_shared_session_parameter_position(self):
        """Test that shared_session parameter is in the correct position"""
        import inspect

        sig = inspect.signature(litellm.acompletion)
        params = list(sig.parameters.keys())

        # Find the position of shared_session
        shared_session_index = params.index("shared_session")

        # It should be near the end, before **kwargs
        assert shared_session_index > 0
        assert shared_session_index < len(params) - 1  # Should be before **kwargs

        # Verify it's after the main parameters
        assert "model" in params[:shared_session_index]
        assert "messages" in params[:shared_session_index]


class TestSharedSessionUsage:
    """Test cases demonstrating proper usage of shared sessions"""

    def test_shared_session_usage_example(self):
        """Test example usage pattern for shared sessions"""
        # This test demonstrates the expected usage pattern
        # without actually making API calls

        import inspect

        # Verify the function signature allows for the expected usage
        sig = inspect.signature(litellm.acompletion)
        params = sig.parameters

        # Verify all expected parameters exist
        expected_params = ["model", "messages", "shared_session"]

        for param in expected_params:
            assert (
                param in params
            ), f"Parameter {param} not found in acompletion signature"

        # Verify shared_session is optional
        assert params["shared_session"].default is None

    def test_shared_session_with_other_parameters(self):
        """Test that shared_session works with other parameters"""
        import inspect

        sig = inspect.signature(litellm.acompletion)
        params = sig.parameters

        # Verify shared_session doesn't conflict with other parameters
        assert "shared_session" in params
        assert "model" in params
        assert "messages" in params
        assert "timeout" in params

        # Verify the parameter order makes sense
        param_list = list(params.keys())
        shared_session_index = param_list.index("shared_session")

        # shared_session should be after the main parameters but before **kwargs
        assert shared_session_index > param_list.index("model")
        assert shared_session_index > param_list.index("messages")

        # Should be before **kwargs (last parameter)
        assert shared_session_index < len(param_list) - 1