"""Tests for S3 parsed DDEX schema."""
from ddex_ingester_common.models.s3.deal_term import DealTerm
from ddex_ingester_common.models.s3.instant_gratification import (
    InstantGratification)
from ddex_ingester_common.models.s3.marketing_highlight import (
    MarketingHighlight
)
from ddex_ingester_common.models.s3.participant import Participant
from ddex_ingester_common.models.s3.product import Product
from ddex_ingester_common.models.s3.project import Project
from ddex_ingester_common.models.s3.store import Store
from ddex_ingester_common.models.s3.track import Track
from ddex_ingester_common.schemas.s3_schema import S3Schema


def test_s3_schema_deserialize(s3_parsed_ddex):
    """Test deserializing entire context dictionary into objects."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)
    assert type(deserialized_ddex.product) is Product
    assert len(deserialized_ddex.tracks) == 1
    assert type(deserialized_ddex.tracks[0]) is Track
    assert deserialized_ddex.party_id == 'PADPIDA2007040502I'
    assert len(
        deserialized_ddex.deals[0].deal_terms[0].commercial_model_types) == 1


def test_incomplete_s3_schema_deserialize(s3_parsed_ddex):
    """Test deserializing a context with missing fields into objects."""
    s3_parsed_ddex.pop('message_id')
    s3_parsed_ddex.pop('party_id')

    s3_parsed_ddex['deals'].append({**s3_parsed_ddex['deals'][0]})
    s3_parsed_ddex['deals'][0]['deal_terms'][0].pop('commercial_model_types')
    s3_parsed_ddex['deals'][0]['deal_terms'][0].pop('usage_type')
    s3_parsed_ddex['deals'][1].pop('release_references')
    s3_parsed_ddex['deals'][1].pop('deal_terms')

    s3_parsed_ddex['tracks'][0].pop('release_reference')
    s3_parsed_ddex['tracks'][0].pop('sequence_number')
    s3_parsed_ddex['tracks'][0].pop('volume')
    s3_parsed_ddex['tracks'][0].pop('track_name')
    s3_parsed_ddex['tracks'][0].pop('resource_reference')

    s3_parsed_ddex['product']['genres'][0].pop('genre')
    s3_parsed_ddex['product'].pop('release_reference')
    s3_parsed_ddex['product'].pop('product_name')
    s3_parsed_ddex['product']['display_artists'][0].pop('name')

    deserialized_ddex = S3Schema().load(s3_parsed_ddex)

    assert not deserialized_ddex.message_id
    assert not deserialized_ddex.party_id

    deal_term = deserialized_ddex.deals[0].deal_terms[0]
    assert not deal_term.commercial_model_types
    assert not deal_term.usage_type

    deal = deserialized_ddex.deals[1]
    assert not deal.release_references
    assert not deal.deal_terms

    track = deserialized_ddex.tracks[0]
    assert not track.release_reference
    assert not track.sequence_number
    assert not track.volume
    assert not track.track_name
    assert not track.resource_reference

    product = deserialized_ddex.product
    assert not product.genres[0].genre
    assert not product.release_reference
    assert not product.product_name
    assert not product.display_artists[0].name
    assert not product.proprietary_id


def test_s3_schema_get_product_deals(s3_parsed_ddex):
    """Test getting the product deals works."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)
    product_deal_terms = deserialized_ddex.get_product_deal_terms()
    assert len(product_deal_terms) == 2
    assert type(product_deal_terms[0]) is DealTerm
    assert len(product_deal_terms[0].territories) == 1
    assert product_deal_terms[0].territories[0] == 'AE'
    assert product_deal_terms[0].price_type == '12'
    assert type(product_deal_terms[1]) is DealTerm
    assert len(product_deal_terms[1].territories) == 1
    assert product_deal_terms[1].territories[0] == 'BE'
    assert product_deal_terms[1].pre_order is True
    assert product_deal_terms[1].release_display_date == '2021-04-20T00:00:00'
    assert product_deal_terms[1].track_listing_preview_date ==\
        '2021-04-20T00:00:00'
    assert product_deal_terms[1].cover_art_preview_date ==\
        '2021-04-20T00:00:00'
    assert product_deal_terms[1].clip_preview_date == '2021-04-30T00:00:00'


def test_s3_schema_track_metadata(s3_parsed_ddex):
    """Test getting the track metadata works."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)
    deserialized_track = deserialized_ddex.tracks[0]

    assert deserialized_track.isrc == 'USSM12001699'
    assert deserialized_track.release_type == 'TrackRelease'
    assert deserialized_track.track_name == 'NewTrack'
    assert deserialized_track.track_version == '2020 Remaster'
    assert deserialized_track.lyrics_language == 'en'
    assert deserialized_track.explicit == 'E'
    assert deserialized_track.p_line == \
        '(P) 2018 Sony Music Associated Records'
    assert deserialized_track.ownership_rights == 'LICENSED'
    assert deserialized_track.recording_country_code == 'US'
    assert deserialized_track.copyright_owner_country == 'US'
    assert deserialized_track.us_publishing_obligation == 'Composition'
    assert deserialized_track.publishers == [
        'ATV Music Publishing', 'Chateau Publishing'
    ]
    assert deserialized_track.lyrics == 'Allow me to introduce myself...'

    assert \
        deserialized_track.display_artists[0].name == 'Giveon'
    assert \
        deserialized_track.display_artists[0].sequence_number == 1
    assert \
        deserialized_track.display_artists[0].roles == ['MainArtist']
    assert (
        deserialized_track.resource_contributors[0].name
        == 'Giveon Evans'
    )
    assert (
        deserialized_track.resource_contributors[0].
        sequence_number == 1
    )
    assert (
        deserialized_track.resource_contributors[0].roles == [
            'Arranger',
            'Composer',
            'Lyricist'
        ])
    assert deserialized_track.preview_start_time == 30
    assert deserialized_track.resource_reference == 'A1'
    assert deserialized_track.content_type == 'Music with vocals'
    assert deserialized_track.offer_type == 'ALL'


def test_s3_schema_product_display_artists(s3_parsed_ddex):
    """Test getting the product display artists works."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)
    assert deserialized_ddex.product.display_artists[0].name == 'Giveon'
    assert deserialized_ddex.product.display_artists[0].sequence_number == 1
    assert (
        deserialized_ddex.product.display_artists[0].roles[0]
        == 'MainArtist'
    )
    assert deserialized_ddex.product.display_artists[1].name == 'Artist'
    assert deserialized_ddex.product.display_artists[1].sequence_number == 2
    assert (
        deserialized_ddex.product.display_artists[1].roles[0]
        == 'SecondaryArtist'
    )


def test_s3_schema_product(s3_parsed_ddex):
    """Test that getting the product works."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)
    store = deserialized_ddex.product.stores[0]

    assert deserialized_ddex.product.metadata_language == 'ENG'
    assert deserialized_ddex.product.product_version == 'New Version'
    assert deserialized_ddex.product.genres[0].genre == 'R&B'
    assert deserialized_ddex.product.genres[0].subgenre == 'R and B'
    assert deserialized_ddex.product.c_line ==\
        '2020 Epic Records, a division of Sony Music Entertainment'
    assert deserialized_ddex.product.p_line ==\
        '2020 Epic Records, a division of Sony Music Entertainment'
    assert deserialized_ddex.product.marketing_blurb ==\
        'A tagline to sell the Product can go here.'
    assert deserialized_ddex.product.imprint == 'BNA Records Label'
    assert deserialized_ddex.product.not_for_distribution == 'N'

    assert type(store) is Store
    assert store.store_id == 'spotify'
    assert store.link == 'spotify:album:368TKDyiyzFTwCyHJ0uWqc'
    assert store.delivery_date == '2020-12-03'
    assert store.carved_out

    assert deserialized_ddex.tracks[0].original_release_date == '2024-01-01'


def test_s3_schema_project(s3_parsed_ddex):
    """Test that getting the project works."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)
    first_highlight = deserialized_ddex.project.marketing_highlights[0]
    store_highlights = deserialized_ddex.project.marketing_highlights[2]
    project_artist = deserialized_ddex.project.artist

    assert type(deserialized_ddex.project) is Project
    assert deserialized_ddex.project.name ==\
        'HIGHER LEARNING MUSIC FROM THE MOTION PICTURE'
    assert deserialized_ddex.project.project_code == '1001247'
    assert deserialized_ddex.project.description ==\
        'The project description text enter here'

    assert type(first_highlight) is MarketingHighlight
    assert first_highlight.territory_codes == ['US', 'CA']
    assert first_highlight.highlight == 'marketing highlight enter here'
    assert store_highlights.store_codes == ['StordId1', 'StordId2']

    assert type(project_artist) is Participant
    assert project_artist.name == 'Laureano Brizuela'
    assert project_artist.spotify_uri ==\
        'spotify:artist:6vWDO969PvNqNYHIOW5v0m'
    assert project_artist.apple_id == 'itunes:artist:7vWDO969PvNqNYHIOW5v0m'


def test_s3_schema_video_metadata(s3_parsed_video_ddex):
    """Test getting the video metadata works."""
    deserialized_ddex = S3Schema().load(s3_parsed_video_ddex)
    assert deserialized_ddex.video.isrc == 'USRV80200058'
    assert deserialized_ddex.video.release_type == 'VideoTrackRelease'
    assert deserialized_ddex.video.video_name == 'Before Your Love'
    assert deserialized_ddex.video.video_version == 'VIDEO'
    assert deserialized_ddex.video.explicit == 'E'
    assert deserialized_ddex.video.p_line.line == 'SG Productions'
    assert deserialized_ddex.video.p_line.year == 2018
    assert deserialized_ddex.video.c_line.line == 'SG Productions'
    assert deserialized_ddex.video.c_line.year == 2018
    assert deserialized_ddex.video.display_artists[0].name ==\
        'Kelly Clarkson'
    assert deserialized_ddex.video.display_artists[0].roles ==\
        ['MainArtist']
    assert deserialized_ddex.video.title_language == 'ENG'
    assert deserialized_ddex.video.content_language == 'ENG'
    assert deserialized_ddex.video.product_code == 'G010000025264A'
    assert deserialized_ddex.video.imprint == '19 Recordings'
    assert deserialized_ddex.video.video_type == 'Official Music Video'
    assert deserialized_ddex.video.genres[0].genre == 'Pop'
    assert deserialized_ddex.video.associated_track_isrc == 'TRAIM1800040'
    assert deserialized_ddex.video.description == 'Some video description'
    assert deserialized_ddex.video.parental_advisory == 'No'
    assert deserialized_ddex.video.keywords == ['keyword1', 'keyword2']
    assert deserialized_ddex.video.lyrics == 'Some lyrics'
    assert deserialized_ddex.video.content_type == 'Music with vocals'


def test_s3_schema_track_localization(s3_parsed_ddex):
    """Test getting the track localization works."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)
    deserialized_track = deserialized_ddex.tracks[0]

    assert len(deserialized_track.localized_titles) == 1
    assert deserialized_track.localized_titles[0].language_code == 'ru'
    assert deserialized_track.localized_titles[0].title == \
        'Не позволяйте никому оборачивать вас'
    assert deserialized_track.localized_titles[0].version == 'Прямой эфир'


def test_s3_schema_product_localization(s3_parsed_ddex):
    """Test getting the product localization works."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)
    deserialized_product = deserialized_ddex.product

    assert len(deserialized_product.localized_titles) == 1
    assert deserialized_product.localized_titles[0].language_code == 'ru'
    assert deserialized_product.localized_titles[0].title == \
        'Песни Церкви - Живите в Мемфисе'
    assert deserialized_product.localized_titles[0].version is None

    assert deserialized_product.display_artists[0].localized_names[0].\
        language_code == 'RU'
    assert deserialized_product.display_artists[0].localized_names[0].\
        name == 'Альбертина Уокер'


def test_s3_schema_serialize(deserialized_s3_context, s3_parsed_ddex):
    """Test serializing context into dictionary."""
    serialized_ddex = S3Schema().dump(deserialized_s3_context)
    assert serialized_ddex == s3_parsed_ddex


def test_s3_schema_deal_instant_grats(s3_parsed_ddex):
    """Test deserializing instant grats."""
    ddex = S3Schema().load(s3_parsed_ddex)
    instant_grat = ddex.deals[0].deal_terms[1].instant_gratifications
    assert type(instant_grat) is InstantGratification
    assert instant_grat.references == ['A1', 'A2']
    assert instant_grat.start_date_time == '2021-04-25T00:00:00'
    assert instant_grat.start_date == '2021-04-20'


def test_s3_schema_label_participants(s3_parsed_ddex):
    """Test that getting the label_participants."""
    deserialized_ddex = S3Schema().load(s3_parsed_ddex)

    assert deserialized_ddex.label_participants[1].artist_id == '2903134'
    assert deserialized_ddex.label_participants[1].name == 'Various Artists'