"""DDEX schema AWAL specific tests."""
from ddex_ingester_common.helpers.xml_document_helper import (
    get_root_element
)
from ddex_ingester_common.models.ddex.product import Product
from ddex_ingester_common.models.ddex.track import Track
from ddex_ingester_common.models.ddex.video import Video
from ddex_ingester_common.schemas.ddex_schema import DDEXSchema
import pytest


def test_awal_ddex_schema_deserialize(awal_ddex_document_single):
    """Test deserializing AWAL DDEX document into context dict with objects."""
    deserialized_context = DDEXSchema().load(awal_ddex_document_single)
    assert type(deserialized_context.product) is Product
    assert len(deserialized_context.tracks) == 2
    assert type(deserialized_context.tracks[0]) is Track
    assert deserialized_context.message_id == \
        '12BD53F7B857436297EB4CA2F76F2F58'
    assert deserialized_context.party_id == 'PADPIDA20100409010'
    assert deserialized_context.product.product_name == "Ain't Never Gonna Be"
    assert deserialized_context.product.genres[0].genre == 'DANCE & ELECTRONIC'
    assert deserialized_context.product.p_line == '2020 FYTEO'
    assert deserialized_context.product.c_line == '2020 FYTEO'
    assert deserialized_context.product.original_release_date == '2021-01-29'
    assert deserialized_context.product.display_artists[0].name == 'FYTEO'
    assert \
        deserialized_context.product.display_artists[0].sequence_number == 1
    assert (
        deserialized_context.product.display_artists[0].roles[0]
        == 'MainArtist'
    )
    assert deserialized_context.tracks[0].track_name == "Ain't Never Gonna Be"
    assert deserialized_context.product.proprietary_id == 'EXPV488260'


@pytest.mark.parametrize('doc,expected', [
    ('awal_ddex_document_album', {
        'upc': '5054526846562',
        'filename': 'testImage',
        'filepath': '/resources/'
    })
])
def test_awal_ddex_schema_deserialize_product_information(
        doc, expected, request):
    """Test deseralizing AWAL DDEX document into context dict with objects."""
    deserialized_context = DDEXSchema().load(request.getfixturevalue(doc))
    product = deserialized_context.product
    assert product.upc == expected['upc']
    assert product.is_main_release
    assert product.release_type == 'Album'
    assert not product.product_id
    assert product.artwork.filename == expected['filename']
    assert product.artwork.filepath == expected['filepath']


@pytest.mark.parametrize('document,expected', [
    ('awal_ddex_document_album', {
        'track_name': "Ain't Never Gonna Be",
        'track_version': 'TNM Remix',
        'track_p_line': '2020 Alan Stephenson',
        'artist_name': 'FYTEO',
        'artist_roles': ['MainArtist'],
        'contributor_name': 'TNM',
        'contributor_sequence_number': 1,
        'last_contributor_sequence_number': 2,
        'contributor_roles': [
            'Singer', 'Remixer', 'Chorus', 'DJ', 'Orchestra', 'Conductor',
            'Soloist', 'Actor', 'Producer', 'Engineer', 'Ensemble'
        ],
        'contributors_count': 2,
        'localized_titles_count': 0,
        'preview_start_time': 60,
    })
])
def test_awal_ddex_schema_deserialize_track_metadata(
        document, expected, request):
    """Test deseralizing DDEX document into context dict with objects."""
    deserialized_context = DDEXSchema().load(request.getfixturevalue(document))
    deserialized_track = deserialized_context.tracks[0]

    assert deserialized_track.track_name == expected['track_name']
    assert deserialized_track.track_version == expected['track_version']
    assert deserialized_track.lyrics_language == 'ENG'
    assert deserialized_track.explicit == 'N'
    assert deserialized_track.p_line == expected['track_p_line']
    assert deserialized_track.lyrics is None
    assert deserialized_track.ownership_rights is None
    assert deserialized_track.recording_country_code is None
    assert deserialized_track.us_publishing_obligation is None
    assert deserialized_track.publishers is None
    assert \
        deserialized_track.display_artists[0].name == expected['artist_name']
    assert \
        deserialized_track.display_artists[0].sequence_number == 1
    assert \
        deserialized_track.display_artists[0].apple_id is None
    assert \
        deserialized_track.display_artists[0].spotify_uri is None
    assert (
        deserialized_track.display_artists[0].roles == expected['artist_roles']
    )
    assert (
        deserialized_track.resource_contributors[0].name
        == expected['contributor_name']
    )
    assert (
        deserialized_track.resource_contributors[0].
        sequence_number == expected['contributor_sequence_number']
    )
    assert (
        deserialized_track.resource_contributors[-1].
        sequence_number == expected['last_contributor_sequence_number']
    )
    assert (
        set(deserialized_track.resource_contributors[0].roles)
        == set(expected['contributor_roles']))
    assert (
        deserialized_track.resource_contributors[0].apple_id
        is None
    )
    assert (
        deserialized_track.resource_contributors[0].spotify_uri
        is None
    )
    assert len(deserialized_track.resource_contributors) \
        == expected['contributors_count']
    assert len(deserialized_track.localized_titles) \
        == expected['localized_titles_count']
    assert deserialized_track.preview_start_time \
        == expected['preview_start_time']


@pytest.mark.parametrize('document,expected', [
    ('awal_ddex_document_single', {'tracks': 2}),
    ('awal_ddex_document_album', {'tracks': 7})
])
def test_awal_ddex_get_tracks(document, expected, request):
    """Should be able to get a list of tracks."""
    ddex_document = get_root_element(request.getfixturevalue(document))
    release_list =\
        ddex_document['ReleaseList']['Release']
    sound_recordings = ddex_document['ResourceList']['SoundRecording']
    output = DDEXSchema().get_tracks(
        ddex_document,
        release_list,
        sound_recordings,
        {},
        'en'
    )
    assert len(output) == expected['tracks']


@pytest.mark.parametrize('document,expected', [
    ('awal_ddex_document_album', {
        'filename': 'testAudioWRC3935208'
    }),
    ('awal_ddex_document_single', {
        'filename': 'testAudioWRC3935211'
    })
])
def test_awal_ddex_get_asset(document, expected, request):
    """Should be able to grab an asset file by resource reference of Track."""
    ddex_document = get_root_element(request.getfixturevalue(document))
    track = {
        'ReleaseResourceReferenceList': {
            'ReleaseResourceReference': {'#text': 'A2'},
        }
    }

    output = DDEXSchema().get_track_asset(ddex_document, track)
    assert (
        output['FileName'] == expected['filename']
    )


@pytest.mark.parametrize(
    'document', ['awal_ddex_document_album', 'awal_ddex_document_single']
)
def test_awal_ddex_get_track_sequence(document, request):
    """Should be able to grab Track sequence number."""
    ddex_document = get_root_element(request.getfixturevalue(document))
    track = {
        'ReleaseResourceReferenceList': {
            'ReleaseResourceReference': {'#text': 'A2'},
        }
    }
    output = DDEXSchema().get_track_sequence(ddex_document, track)
    assert output == '2'


@pytest.mark.parametrize(
    'document', ['awal_ddex_document_album', 'awal_ddex_document_single']
)
def test_awal_ddex_get_track_side(document, request):
    """Should be able to grab Track side number."""
    ddex_document = get_root_element(request.getfixturevalue(document))
    track = {
        'ReleaseResourceReferenceList': {
            'ReleaseResourceReference': {'#text': 'A2'},
        }
    }
    output = DDEXSchema().get_track_side(ddex_document, track)
    assert output == '1'


def test_awal_ddex_schema_territory_codes(awal_ddex_document_album):
    """Test deserializing DDEX document with territory codes."""
    deserialized_context = DDEXSchema().load(awal_ddex_document_album)
    territories = deserialized_context.deals[0].deal_terms[0].territories
    assert len(territories) == 1
    assert territories[0] == 'Worldwide'


def test_awal_ddex_schema_deserialize_video(awal_video_ddex):
    """Test deseralizing DDEX video document into context dict with objects."""
    deserialized_context = DDEXSchema().load(awal_video_ddex)

    assert type(deserialized_context.product) is Product
    assert len(deserialized_context.tracks) == 0
    assert type(deserialized_context.video) is Video
    assert deserialized_context.message_id == 'C0673797327D467AB300BC66D9EDBDEE'  # noqa
    assert deserialized_context.message_thread_id == 'EB0D4E0A83A7404A9B5286E14DFAD028_5054526321649'  # noqa
    assert deserialized_context.product.product_name == 'Changes'
    assert deserialized_context.product.genres[0].genre == 'Electronic'
    assert deserialized_context.product.p_line == '2020 Lauv under exclusive license to AWAL Recordings America, Inc.'  # noqa
    assert deserialized_context.product.c_line == '2020 Lauv under exclusive license to AWAL Recordings America, Inc.'  # noqa
    assert deserialized_context.update_indicator is None
    assert deserialized_context.product.original_release_date == '2020-01-02'
    assert deserialized_context.product.product_version is None
    assert deserialized_context.product.display_artists[0].name == 'Lauv'
    assert (
        deserialized_context.product.display_artists[0].roles[0]
        == 'MainArtist'
    )
    assert deserialized_context.video.display_artists[0].name == 'Lauv'
    assert (
        deserialized_context.video.display_artists[0].roles[0]
        == 'MainArtist'
    )
    assert deserialized_context.video.resource_contributors[0].name ==\
        'Ari Leff'
    assert (
        deserialized_context.video.resource_contributors[0].roles[0]
        == 'ComposerLyricist'
    )
    assert deserialized_context.video.video_name == 'Changes'
    assert deserialized_context.video.video_version is None
    assert len(deserialized_context.video.assets) == 1
    assert deserialized_context.video.assets[0].aspect_ratio is None
    assert deserialized_context.video.title_language == 'ENG'
    assert deserialized_context.video.content_language == 'ENG'