"""Tests Meta DDEX header generation."""

from textwrap import dedent
from unittest.mock import call, patch

from freezegun import freeze_time

from soundrecording_utils.ddex.v38 import sound_recording
from soundrecording_utils.ddex.v38.e import E
from soundrecording_utils.metadata.types import (
    Asset,
    FingerprintRule,
    Language,
    OrchardSoundRecording,
    Track,
    TrackConnection,
)


def test_format_track_duration_iso_8601(mock_track: Track):
    """Test that format_track_duration formats validly."""
    formatted = sound_recording._format_track_duration_iso_8601(mock_track)
    assert formatted == 'PT1M2S'


def test_generate_language_of_performance_instrumental(
    mock_track: Track,
    helpers,
):
    """Test _generate_language_of_performance for N/A meta language."""
    mock_track = mock_track._replace(
        meta_language_code='N/A',
    )

    result = sound_recording._generate_language_of_performance(mock_track)

    result = helpers.print_xml(result)
    expected = """
        <IsInstrumental>true</IsInstrumental>
    """

    assert result == dedent(expected).strip()


def test_generate_language_of_performance_with_language(
    mock_track: Track,
    helpers,
):
    """Test _generate_language_of_performance with a language."""
    mock_track = mock_track._replace(
        meta_language_code='EN',
        language=Language(
            iso_639_1_code='ES',
        ),
    )

    result = sound_recording._generate_language_of_performance(mock_track)

    result = helpers.print_xml(result)
    expected = """
        <LanguageOfPerformance>es</LanguageOfPerformance>
    """

    assert result == dedent(expected).strip()


def test_generate_language_of_performance_without_language(
    mock_track: Track,
    helpers,
):
    """Test _generate_language_of_performance without a language."""
    mock_track = mock_track._replace(
        meta_language_code='EN', language=Language(iso_639_1_code=None)
    )

    result = sound_recording._generate_language_of_performance(mock_track)

    assert result is None


def test_generate_subtitle_with_version(
    mock_track: Track,
    helpers,
):
    """Test _generate_subtitle with a track version."""
    mock_track = mock_track._replace(
        version='Test Subtitle',
    )

    result = sound_recording._generate_subtitle(mock_track)

    result = helpers.print_xml(result)
    expected = """
        <SubTitle>Test Subtitle</SubTitle>
    """

    assert result == dedent(expected).strip()


def test_generate_subtitle_without_version(
    mock_track: Track,
    helpers,
):
    """Test _generate_subtitle with a track version."""
    mock_track = mock_track._replace(
        version=None,
    )

    result = sound_recording._generate_subtitle(mock_track)

    assert result is None


@patch('soundrecording_utils.ddex.v38.sound_recording._generate_subtitle')
def test_generate_reference_title(
    mock_generate_subtitle,
    mock_track: Track,
    helpers,
):
    """Test generate_reference_title."""
    mock_generate_subtitle.return_value = E('MockSubTitle')

    result = sound_recording.generate_reference_title(mock_track)

    result = helpers.print_xml(result)
    expected = """
        <ReferenceTitle>
            <TitleText>Test Track Name</TitleText>
            <MockSubTitle/>
        </ReferenceTitle>
    """

    assert result == dedent(expected).strip()

    mock_generate_subtitle.assert_called_once_with(mock_track)


@patch(
    'soundrecording_utils.ddex.v38.sound_recording.'
    'generate_sound_recording_details_by_territory'
)
@freeze_time('2024-01-01 12:00:00')
def test_generate_sound_recording_details_by_territory(
    mock_generate_sound_recording_details_by_territory,
    mock_orchard_sound_recording: OrchardSoundRecording,
    mock_track: Track,
    mock_fingerprint_rule: FingerprintRule,
    helpers,
):
    """Test _generate_sound_recording_details_by_territory with rules."""
    mock_generate_sound_recording_details_by_territory.side_effect = (
        lambda territories, track, rights_percent, upload_asset: E(
            'MockSoundRecordingDetailByTerritory',
            E('TrackName', track.name),
            *(E('MockTerritory', territory) for territory in territories),
        )
    )

    mock_t1_rules = [
        mock_fingerprint_rule._replace(territory='FR'),
        mock_fingerprint_rule._replace(territory='US'),
    ]
    mock_t2_rules = [
        mock_fingerprint_rule._replace(territory='ES'),
        mock_fingerprint_rule._replace(territory='JP'),
    ]

    mock_tracks = [
        mock_track._replace(tuid='123', name='Track 1', rules=mock_t1_rules),
        mock_track._replace(
            tuid='456', name='Track 2', rules=mock_t2_rules, primary=False
        ),
    ]

    mock_asset = Asset(uuid='123', filename='456', extension='flac')

    mock_orchard_sound_recording = mock_orchard_sound_recording._replace(
        track_connection=TrackConnection(tracks=mock_tracks)
    )

    xml = sound_recording._generate_sound_recording_details_by_territory(  # noqa:E501
        mock_orchard_sound_recording, mock_tracks[0], mock_asset, 'tiktok'
    )

    # only expect first track should include asset
    assert mock_generate_sound_recording_details_by_territory.call_args_list == [  # noqa:E501
        call(['ES', 'FR', 'JP', 'US'], mock_tracks[0], '100.00', mock_asset)
    ]

    track_by_territory_container = E(
        'TestContainer',
        *xml,
    )

    result = helpers.print_xml(track_by_territory_container)
    expected = """
        <TestContainer>
            <MockSoundRecordingDetailByTerritory>
                <TrackName>Track 1</TrackName>
                <MockTerritory>ES</MockTerritory>
                <MockTerritory>FR</MockTerritory>
                <MockTerritory>JP</MockTerritory>
                <MockTerritory>US</MockTerritory>
            </MockSoundRecordingDetailByTerritory>
        </TestContainer>
    """  # noqa: E501

    assert result == dedent(expected).strip()


@patch(
    'soundrecording_utils.ddex.v38.sound_recording.'
    'generate_sound_recording_details_by_territory'
)
def test_generate_sound_recording_details_by_territory_takedown(
    mock_generate_sound_recording_details_by_territory,
    mock_orchard_sound_recording: OrchardSoundRecording,
    mock_track: Track,
    mock_fingerprint_rule: FingerprintRule,
    helpers,
):
    """Test _generate_sound_recording_details_by_territory no territories."""
    mock_generate_sound_recording_details_by_territory.side_effect = (
        lambda territories, track, rights_percent, upload_asset: E(
            'MockSoundRecordingDetailByTerritory',
            E('TrackName', track.name),
            *(E('MockTerritory', territory) for territory in territories),
        )
    )

    mock_t1_rules = [
        mock_fingerprint_rule._replace(policy='carveout', territory='*'),
    ]
    mock_t2_rules = [
        mock_fingerprint_rule._replace(policy='carveout', territory='FR'),
    ]

    mock_tracks = [
        mock_track._replace(
            tuid='123',
            name='Track 1',
            rules=mock_t1_rules,
            primary=False,
        ),
        mock_track._replace(
            tuid='456',
            name='Track 2',
            rules=mock_t2_rules,
        ),
    ]
    mock_orchard_sound_recording = mock_orchard_sound_recording._replace(
        track_connection=TrackConnection(tracks=mock_tracks)
    )

    xml = sound_recording._generate_sound_recording_details_by_territory(  # noqa:E501
        mock_orchard_sound_recording, mock_tracks[1], None, 'tiktok'
    )

    assert mock_generate_sound_recording_details_by_territory.call_args_list == [  # noqa:E501
        call(['Worldwide'], mock_tracks[1], '0.00', None)
    ]

    track_by_territory_container = E(
        'TestContainer',
        *xml,
    )

    result = helpers.print_xml(track_by_territory_container)
    expected = """
        <TestContainer>
            <MockSoundRecordingDetailByTerritory>
                <TrackName>Track 2</TrackName>
                <MockTerritory>Worldwide</MockTerritory>
            </MockSoundRecordingDetailByTerritory>
        </TestContainer>
    """  # noqa: E501

    assert result == dedent(expected).strip()


@patch(
    'soundrecording_utils.ddex.v38.sound_recording.'
    '_generate_sound_recording_details_by_territory'
)
@patch('soundrecording_utils.ddex.v38.sound_recording._format_track_duration_iso_8601')
@patch(
    'soundrecording_utils.ddex.v38.sound_recording._generate_language_of_performance'
)
def test_generate_sound_recording_resource(
    mock_generate_language_of_performance,
    mock_format_track_duration_iso_8601,
    mock_generate_sound_recording_details_by_territory,
    mock_orchard_sound_recording: OrchardSoundRecording,
    mock_track: Track,
    helpers,
):
    """Test generate_sound_recording_release."""
    mock_generate_language_of_performance.return_value = E(
        'MockLanguageOfPerformance',
    )
    mock_format_track_duration_iso_8601.return_value = 'Mock Duration'
    mock_generate_sound_recording_details_by_territory.return_value = [
        E('MockSoundRecordingDetailsByTerritory1'),
        E('MockSoundRecordingDetailsByTerritory2'),
    ]
    mock_orchard_sound_recording = mock_orchard_sound_recording._replace(
        track_connection=TrackConnection(
            tracks=[
                mock_track._replace(primary=False, name='Track 1', tuid='123'),
                mock_track._replace(primary=True, name='Track 2', tuid='456'),
            ],
        ),
    )

    xml = sound_recording.generate_sound_recording_resource(
        'A1',
        mock_orchard_sound_recording,
        mock_orchard_sound_recording.track_connection.tracks[1],
        None,
        'tiktok',
    )

    result = helpers.print_xml(xml)
    expected = """
        <SoundRecording>
            <SoundRecordingType>MusicalWorkSoundRecording</SoundRecordingType>
            <SoundRecordingId>
                <ISRC>isrc-123</ISRC>
            </SoundRecordingId>
            <ResourceReference>A1</ResourceReference>
            <ReferenceTitle>
                <TitleText>Track 2</TitleText>
            </ReferenceTitle>
            <MockLanguageOfPerformance/>
            <Duration>Mock Duration</Duration>
            <MockSoundRecordingDetailsByTerritory1/>
            <MockSoundRecordingDetailsByTerritory2/>
        </SoundRecording>
    """

    assert result == dedent(expected).strip()