"""Tests for DDEX generation wrapper."""

from unittest.mock import MagicMock, patch

import pytest

from soundrecording_utils.constants.ddex.constants import RuleService
from soundrecording_utils.ddex.generate import generate_ddex
from soundrecording_utils.metadata.types import Asset, OrchardSoundRecording


def test_generate_ddex_version_38(
    mock_orchard_sound_recording: OrchardSoundRecording,
    mock_asset: Asset,
    execution_meta: dict,
):
    """Test that version 3.8 calls the correct generator."""
    mock_generator = MagicMock(return_value='<xml>v3.8</xml>')
    with patch.dict(
        'soundrecording_utils.ddex.generate._VERSION_GENERATORS',
        {'3.8': mock_generator}
    ):
        result = generate_ddex(
            mock_orchard_sound_recording,
            mock_asset,
            execution_meta,
            'test-app',
            RuleService.TIKTOK,
            selected_version='3.8',
            takedown=False,
        )

        assert result == '<xml>v3.8</xml>'
        mock_generator.assert_called_once_with(
            mock_orchard_sound_recording,
            mock_asset,
            execution_meta,
            'test-app',
            RuleService.TIKTOK,
            False,
        )


def test_generate_ddex_version_43(
    mock_orchard_sound_recording: OrchardSoundRecording,
    mock_asset: Asset,
    execution_meta: dict,
):
    """Test that version 4.3 calls the correct generator."""
    mock_generator = MagicMock(return_value='<xml>v4.3</xml>')
    with patch.dict(
        'soundrecording_utils.ddex.generate._VERSION_GENERATORS',
        {'4.3': mock_generator}
    ):
        result = generate_ddex(
            mock_orchard_sound_recording,
            mock_asset,
            execution_meta,
            'test-app',
            RuleService.YOUTUBE,
            selected_version='4.3',
            takedown=False,
        )

        assert result == '<xml>v4.3</xml>'
        mock_generator.assert_called_once_with(
            mock_orchard_sound_recording,
            mock_asset,
            execution_meta,
            'test-app',
            RuleService.YOUTUBE,
            False,
        )


def test_generate_ddex_normalizes_whitespace(
    mock_orchard_sound_recording: OrchardSoundRecording,
    execution_meta: dict,
):
    """Test that version strings with whitespace are normalized."""
    mock_generator = MagicMock(return_value='<xml>normalized</xml>')
    with patch.dict(
        'soundrecording_utils.ddex.generate._VERSION_GENERATORS',
        {'3.8': mock_generator}
    ):
        # Test with leading/trailing whitespace
        result = generate_ddex(
            mock_orchard_sound_recording,
            None,
            execution_meta,
            'test-app',
            RuleService.YOUTUBE,
            selected_version='  3.8  ',
        )

        assert result == '<xml>normalized</xml>'
        mock_generator.assert_called_once()


def test_generate_ddex_normalizes_newlines(
    mock_orchard_sound_recording: OrchardSoundRecording,
    execution_meta: dict,
):
    """Test that version strings with newlines are normalized."""
    mock_generator = MagicMock(return_value='<xml>normalized</xml>')
    with patch.dict(
        'soundrecording_utils.ddex.generate._VERSION_GENERATORS',
        {'3.8': mock_generator}
    ):
        # Test with trailing newline (common from env vars)
        result = generate_ddex(
            mock_orchard_sound_recording,
            None,
            execution_meta,
            'test-app',
            RuleService.YOUTUBE,
            selected_version='3.8\n',
        )

        assert result == '<xml>normalized</xml>'
        mock_generator.assert_called_once()


def test_generate_ddex_unsupported_version_raises_error(
    mock_orchard_sound_recording: OrchardSoundRecording,
    execution_meta: dict,
):
    """Test that unsupported version raises ValueError."""
    with pytest.raises(ValueError) as exc_info:
        generate_ddex(
            mock_orchard_sound_recording,
            None,
            execution_meta,
            'test-app',
            RuleService.YOUTUBE,
            selected_version='5.0',
        )

    error_message = str(exc_info.value)
    assert 'Unsupported DDEX version' in error_message
    assert "'5.0'" in error_message
    assert '3.8' in error_message
    assert '4.3' in error_message


def test_generate_ddex_empty_version_raises_error(
    mock_orchard_sound_recording: OrchardSoundRecording,
    execution_meta: dict,
):
    """Test that empty version string raises ValueError."""
    with pytest.raises(ValueError) as exc_info:
        generate_ddex(
            mock_orchard_sound_recording,
            None,
            execution_meta,
            'test-app',
            RuleService.YOUTUBE,
            selected_version='',
        )

    error_message = str(exc_info.value)
    assert 'Unsupported DDEX version' in error_message


def test_generate_ddex_whitespace_only_version_raises_error(
    mock_orchard_sound_recording: OrchardSoundRecording,
    execution_meta: dict,
):
    """Test that whitespace-only version string raises ValueError."""
    with pytest.raises(ValueError) as exc_info:
        generate_ddex(
            mock_orchard_sound_recording,
            None,
            execution_meta,
            'test-app',
            RuleService.YOUTUBE,
            selected_version='   \n  ',
        )

    error_message = str(exc_info.value)
    assert 'Unsupported DDEX version' in error_message


def test_generate_ddex_invalid_version_format_raises_error(
    mock_orchard_sound_recording: OrchardSoundRecording,
    execution_meta: dict,
):
    """Test that invalid version format raises ValueError with helpful message."""
    with pytest.raises(ValueError) as exc_info:
        generate_ddex(
            mock_orchard_sound_recording,
            None,
            execution_meta,
            'test-app',
            RuleService.YOUTUBE,
            selected_version='v4.3',
        )

    error_message = str(exc_info.value)
    assert 'Unsupported DDEX version' in error_message
    assert "'v4.3'" in error_message
    assert 'Supported versions:' in error_message