"""Tests Meta DDEX header generation."""
from textwrap import dedent
from unittest.mock import call
from unittest.mock import patch

from src.ddex import sound_recording
from src.ddex.e import E
from soundrecording_utils.metadata.types import Asset
from soundrecording_utils.metadata.types import Language
from soundrecording_utils.metadata.types import OrchardSoundRecording
from soundrecording_utils.metadata.types import Track
from soundrecording_utils.metadata.types import 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('src.ddex.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(
    'src.ddex.sound_recording.'
    'generate_sound_recording_details_by_territory'
)
@patch(
    'src.ddex.sound_recording.'
    'deduplicate_territories'
)
def test_generate_sound_recording_details_by_territory(
    mock_deduplicate_territories,
    mock_generate_sound_recording_details_by_territory,
    mock_orchard_sound_recording: OrchardSoundRecording,
    mock_track: Track,
    helpers,
):
    """Test _generate_sound_recording_details_by_territory with 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_tracks = [
        mock_track._replace(
            name='Track 1',
            territories=['AA', 'BB', 'DD'],
        ),
        mock_track._replace(
            name='Track 2',
            territories=['CC', 'EE', 'FF'],
        ),
        mock_track._replace(
            name='Track 3',
            territories=[],
        )
    ]
    mock_asset = Asset(uuid='123', filename='456', extension='flac')

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

    mock_deduplicate_territories.return_value = \
        mock_orchard_sound_recording.track_connection.tracks

    result = sound_recording._generate_sound_recording_details_by_territory(
        mock_orchard_sound_recording,
        mock_asset
    )

    assert mock_deduplicate_territories.call_args_list == [
        call(mock_orchard_sound_recording)
    ]

    # only expect first track should include asset
    assert mock_generate_sound_recording_details_by_territory.call_args_list == [  # noqa:E501
        call(
            ['AA', 'BB', 'DD'],
            mock_tracks[0],
            '100.00',
            mock_asset
        ),
        call(
            ['CC', 'EE', 'FF'],
            mock_tracks[1],
            '100.00',
            None
        )
    ]

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

    result = helpers.print_xml(track_by_territory_container)
    expected = """
        <TestContainer>
            <MockSoundRecordingDetailByTerritory>
                <TrackName>Track 1</TrackName>
                <MockTerritory>AA</MockTerritory>
                <MockTerritory>BB</MockTerritory>
                <MockTerritory>DD</MockTerritory>
            </MockSoundRecordingDetailByTerritory>
            <MockSoundRecordingDetailByTerritory>
                <TrackName>Track 2</TrackName>
                <MockTerritory>CC</MockTerritory>
                <MockTerritory>EE</MockTerritory>
                <MockTerritory>FF</MockTerritory>
            </MockSoundRecordingDetailByTerritory>
        </TestContainer>
    """  # noqa: E501

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


@patch(
    'src.ddex.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,
    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_tracks = [
        mock_track._replace(
            name='Track 1',
            territories=[],
            primary=False
        ),
        mock_track._replace(
            name='Track 2',
            territories=[]
        )
    ]
    mock_orchard_sound_recording = mock_orchard_sound_recording._replace(
        track_connection=TrackConnection(tracks=mock_tracks)
    )

    result = sound_recording._generate_sound_recording_details_by_territory(
        mock_orchard_sound_recording,
        None
    )

    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',
        *result,
    )

    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(
    'src.ddex.sound_recording.'
    '_generate_sound_recording_details_by_territory'
)
@patch('src.ddex.sound_recording._format_track_duration_iso_8601')
@patch('src.ddex.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'),
                mock_track._replace(primary=True, name='Track 2')
            ],
        ),
    )

    result = sound_recording.generate_sound_recording_resource(
        'A1',
        mock_orchard_sound_recording,
        None
    )

    result = helpers.print_xml(result)
    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()