# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
# --------------------------------------------------------------------------

"""
Integration test runner and test suite validation.
This file contains tests that verify the test suite itself and run integration scenarios.
"""

import pytest
import importlib

pytest.importorskip(
    "aiohttp",
    reason="Skipping aio tests: aiohttp not installed (whl_no_aio).",
)

# Import the modules we want to test
import azure.ai.voicelive.models as models
import azure.ai.voicelive.aio as aio_module


class TestSuiteValidation:
    """Validate that our test suite covers the main components."""

    def test_can_import_all_test_modules(self):
        """Test that all our test modules can be imported."""
        test_modules = [
            "tests.test_unit_enums",
            "tests.test_unit_models",
            "tests.test_unit_serialization",
            "tests.test_unit_connection",
            "tests.test_unit_client_events",
            "tests.test_unit_voice_config",
            "tests.test_unit_message_handling",
        ]

        for module_name in test_modules:
            try:
                module = importlib.import_module(module_name)
                assert module is not None
            except ImportError as e:
                pytest.fail(f"Failed to import {module_name}: {e}")

    def test_main_package_imports(self):
        """Test that main package components can be imported."""
        # Test main models import
        assert models is not None

        # Test async module import
        assert aio_module is not None

    def test_key_enum_coverage(self):
        """Test that we cover all key enums."""
        key_enums = [
            "AzureVoiceType",
            "MessageRole",
            "OpenAIVoiceName",
            "ClientEventType",
            "ContentPartType",
            "InputAudioFormat",
            "OutputAudioFormat",
            "Modality",
            "ResponseStatus",
        ]

        for enum_name in key_enums:
            assert hasattr(models, enum_name), f"Missing enum: {enum_name}"

    def test_key_model_coverage(self):
        """Test that we cover all key models."""
        key_models = [
            "MessageContentPart",
            "InputTextContentPart",
            "InputAudioContentPart",
            "OutputTextContentPart",
            "UserMessageItem",
            "AssistantMessageItem",
            "SystemMessageItem",
            "OpenAIVoice",
            "AzureCustomVoice",
            "AzureStandardVoice",
            "AzurePersonalVoice",
            "RequestSession",
            "ResponseSession",
        ]

        for model_name in key_models:
            assert hasattr(models, model_name), f"Missing model: {model_name}"

    def test_async_components_coverage(self):
        """Test that we cover async components."""
        async_components = [
            "VoiceLiveConnection",
            "SessionResource",
            "ResponseResource",
            "ConnectionError",
            "ConnectionClosed",
        ]

        for component_name in async_components:
            assert hasattr(aio_module, component_name), f"Missing async component: {component_name}"


class TestRecentChangesIntegration:
    """Test integration of recent changes from the staged commits."""

    def test_azure_voice_type_enum_integration(self):
        """Test that AzureVoiceType enum works with voice models."""
        # Test the new AzureVoiceType enum
        from azure.ai.voicelive.models import (
            AzureVoiceType,
            AzureCustomVoice,
            AzureStandardVoice,
            AzurePersonalVoice,
            PersonalVoiceModels,
        )

        # Test custom voice with enum discriminator
        custom_voice = AzureCustomVoice(
            name="test-custom",
            endpoint_id="endpoint-123",
        )
        assert custom_voice.type == AzureVoiceType.AZURE_CUSTOM

        # Test standard voice with enum discriminator
        standard_voice = AzureStandardVoice(name="test-standard")
        assert standard_voice.type == AzureVoiceType.AZURE_STANDARD

        # Test personal voice with enum discriminator
        personal_voice = AzurePersonalVoice(name="test-personal", model=PersonalVoiceModels.PHOENIX_LATEST_NEURAL)
        assert personal_voice.type == AzureVoiceType.AZURE_PERSONAL

    def test_message_role_enum_integration(self):
        """Test that MessageRole enum works with message items."""
        from azure.ai.voicelive.models import (
            MessageRole,
            UserMessageItem,
            AssistantMessageItem,
            SystemMessageItem,
            InputTextContentPart,
            OutputTextContentPart,
        )

        # Test user message with enum role
        user_msg = UserMessageItem(content=[InputTextContentPart(text="User message")])
        assert user_msg.role == MessageRole.USER

        # Test assistant message with enum role
        assistant_msg = AssistantMessageItem(content=[OutputTextContentPart(text="Assistant response")])
        assert assistant_msg.role == MessageRole.ASSISTANT

        # Test system message with enum role
        system_msg = SystemMessageItem(content=[InputTextContentPart(text="System instruction")])
        assert system_msg.role == MessageRole.SYSTEM

    def test_message_content_part_renaming(self):
        """Test that MessageContentPart (renamed from UserContentPart) works correctly."""
        from azure.ai.voicelive.models import (
            MessageContentPart,
            InputTextContentPart,
            InputAudioContentPart,
            OutputTextContentPart,
        )

        # Test that all content parts inherit from MessageContentPart
        text_part = InputTextContentPart(text="Test text")
        audio_part = InputAudioContentPart(audio=b"test audio")
        output_part = OutputTextContentPart(text="Test output")

        assert isinstance(text_part, MessageContentPart)
        assert isinstance(audio_part, MessageContentPart)
        assert isinstance(output_part, MessageContentPart)

    def test_cross_language_package_id_update(self):
        """Test that the cross-language package ID update doesn't break functionality."""
        # This change is in apiview-properties.json and metadata
        # The actual Python SDK functionality should be unaffected

        from azure.ai.voicelive.models import (
            UserMessageItem,
            InputTextContentPart,
            ClientEventSessionUpdate,
            RequestSession,
        )

        # Test that models still work correctly after the package ID change
        content = [InputTextContentPart(text="Test cross-language compatibility")]
        message = UserMessageItem(content=content)

        session = RequestSession(model="test-model")
        event = ClientEventSessionUpdate(session=session)

        assert message.content[0].text == "Test cross-language compatibility"
        assert event.session == session

    def test_api_version_update_compatibility(self):
        """Test that API version update doesn't break SDK functionality."""
        # API version changed from "2025-05-01-preview" to "2025-10-01"
        # This shouldn't affect the Python SDK functionality directly

        from azure.ai.voicelive.models import RequestSession, OpenAIVoice, OpenAIVoiceName

        # Test that session creation still works
        session = RequestSession(model="gpt-4o-realtime-preview", voice=OpenAIVoice(name=OpenAIVoiceName.ALLOY))

        assert session.model == "gpt-4o-realtime-preview"
        assert session.voice.name == OpenAIVoiceName.ALLOY


class TestErrorHandlingIntegration:
    """Test error handling across the SDK."""

    def test_connection_errors_are_properly_typed(self):
        """Test that connection errors inherit correctly."""
        from azure.ai.voicelive.aio import ConnectionError, ConnectionClosed

        # Test basic error
        basic_error = ConnectionError("Test error")
        assert isinstance(basic_error, Exception)

        # Test connection closed error
        closed_error = ConnectionClosed(1000, "Normal closure")
        assert isinstance(closed_error, ConnectionError)
        assert isinstance(closed_error, Exception)
        assert closed_error.code == 1000
        assert closed_error.reason == "Normal closure"


class TestSerializationIntegration:
    """Test serialization integration across the SDK."""

    def test_enum_serialization_fix(self):
        """Test that the enum serialization fix works correctly."""
        from azure.ai.voicelive._utils.serialization import Serializer
        from azure.ai.voicelive.models import AzureVoiceType, MessageRole, OpenAIVoiceName

        serializer = Serializer()

        # Test that enums serialize correctly (this tests the cast(type, data.__class__) fix)
        voice_type_result = serializer.serialize_data(AzureVoiceType.AZURE_CUSTOM, "str")
        role_result = serializer.serialize_data(MessageRole.ASSISTANT, "str")
        oai_voice_result = serializer.serialize_data(OpenAIVoiceName.ALLOY, "str")

        assert voice_type_result == "azure-custom"
        assert role_result == "assistant"
        assert oai_voice_result == "alloy"

    def test_model_serialization_compatibility(self):
        """Test that models can be serialized properly."""
        from azure.ai.voicelive.models import UserMessageItem, InputTextContentPart, AzureStandardVoice, RequestSession

        # Create complex nested structure
        content = [InputTextContentPart(text="Serialization test")]
        message = UserMessageItem(content=content, id="test-msg")

        voice = AzureStandardVoice(name="test-voice", temperature=0.7)
        session = RequestSession(model="test-model", voice=voice)

        # Test that all objects have the necessary attributes for serialization
        for obj in [content[0], message, voice, session]:
            assert hasattr(obj, "__dict__")


class TestRealWorldScenarios:
    """Test real-world usage scenarios."""

    def test_complete_voice_assistant_setup(self):
        """Test setting up a complete voice assistant configuration."""
        from azure.ai.voicelive.models import (
            RequestSession,
            AzureStandardVoice,
            Modality,
            SystemMessageItem,
            UserMessageItem,
            InputTextContentPart,
            ClientEventSessionUpdate,
            ClientEventConversationItemCreate,
        )

        # Set up voice configuration
        voice = AzureStandardVoice(name="en-US-JennyNeural", style="friendly", temperature=0.7)

        # Set up session
        session = RequestSession(
            model="gpt-4o-realtime-preview",
            voice=voice,
            modalities=[Modality.TEXT, Modality.AUDIO],
            instructions="You are a helpful voice assistant. Be concise and friendly.",
        )

        # Create system message
        system_content = [InputTextContentPart(text="You are a helpful voice assistant.")]
        system_message = SystemMessageItem(content=system_content)

        # Create user message
        user_content = [InputTextContentPart(text="Hello, can you help me?")]
        user_message = UserMessageItem(content=user_content)

        # Create events
        session_update = ClientEventSessionUpdate(session=session)
        create_system = ClientEventConversationItemCreate(item=system_message)
        create_user = ClientEventConversationItemCreate(item=user_message)

        # Verify everything is set up correctly
        assert session.voice.name == "en-US-JennyNeural"
        assert session.voice.style == "friendly"
        assert len(session.modalities) == 2
        assert system_message.role == "system"
        assert user_message.role == "user"
        assert session_update.session == session

    def test_multi_modal_conversation(self):
        """Test a multi-modal conversation with text and audio."""
        from azure.ai.voicelive.models import (
            UserMessageItem,
            AssistantMessageItem,
            InputTextContentPart,
            InputAudioContentPart,
            OutputTextContentPart,
            MessageRole,
        )

        # User message with text and audio
        user_content = [
            InputTextContentPart(text="I have a question:"),
            InputAudioContentPart(audio=b"fake spoken question audio data"),
        ]
        user_message = UserMessageItem(content=user_content)

        # Assistant text response
        assistant_content = [OutputTextContentPart(text="I understand your question. Let me help you with that.")]
        assistant_message = AssistantMessageItem(content=assistant_content)

        # Verify conversation structure
        conversation = [user_message, assistant_message]

        assert user_message.role == MessageRole.USER
        assert assistant_message.role == MessageRole.ASSISTANT
        assert len(user_message.content) == 2
        assert len(assistant_message.content) == 1
        assert user_message.content[0].type == "input_text"
        assert user_message.content[1].type == "input_audio"
        assert assistant_message.content[0].type == "text"

    def test_voice_switching_scenario(self):
        """Test switching between different voice types."""
        from azure.ai.voicelive.models import (
            OpenAIVoice,
            AzureStandardVoice,
            AzurePersonalVoice,
            OpenAIVoiceName,
            PersonalVoiceModels,
            RequestSession,
        )

        # Start with OpenAI voice
        openai_voice = OpenAIVoice(name=OpenAIVoiceName.ALLOY)
        session1 = RequestSession(model="gpt-4o-realtime-preview", voice=openai_voice)

        # Switch to Azure standard voice
        azure_standard = AzureStandardVoice(name="en-US-AriaNeural", style="cheerful")
        session2 = RequestSession(model="gpt-4o-realtime-preview", voice=azure_standard)

        # Switch to Azure personal voice
        azure_personal = AzurePersonalVoice(
            name="my-personal-voice", model=PersonalVoiceModels.PHOENIX_LATEST_NEURAL, temperature=0.8
        )
        session3 = RequestSession(model="gpt-4o-realtime-preview", voice=azure_personal)

        # Verify each configuration
        assert session1.voice.type == "openai"
        assert session2.voice.type == "azure-standard"
        assert session3.voice.type == "azure-personal"

        # Verify voice-specific properties
        assert session2.voice.style == "cheerful"
        assert session3.voice.temperature == 0.8


class TestBackwardsCompatibility:
    """Test backwards compatibility with previous versions."""

    def test_enum_string_compatibility(self):
        """Test that enums maintain string compatibility."""
        from azure.ai.voicelive.models import MessageRole, AzureVoiceType, OpenAIVoiceName
        from enum import Enum

        # Test that enums can still be compared to strings
        assert MessageRole.USER == "user"
        assert AzureVoiceType.AZURE_CUSTOM == "azure-custom"
        assert OpenAIVoiceName.ALLOY == "alloy"

        # Test case insensitive behavior
        assert MessageRole["USER"] == MessageRole.USER
        assert AzureVoiceType["AZURE_CUSTOM"] == AzureVoiceType.AZURE_CUSTOM

    def test_model_attribute_compatibility(self):
        """Test that model attributes are still accessible."""
        from azure.ai.voicelive.models import UserMessageItem, InputTextContentPart, AzureStandardVoice

        # Test that all expected attributes are accessible
        content = [InputTextContentPart(text="Test message")]
        message = UserMessageItem(content=content, id="test-123")

        voice = AzureStandardVoice(name="test-voice", temperature=0.5)

        # These should all work as before
        assert message.role == "user"  # String comparison should still work
        assert message.content[0].text == "Test message"
        assert message.id == "test-123"
        assert voice.name == "test-voice"
        assert voice.temperature == 0.5


if __name__ == "__main__":
    # Run the tests when this file is executed directly
    pytest.main([__file__])