"""Marshmallow schema for parsed DDEX document in S3."""
from ddex_ingester_common.models.s3.asset import Asset
from ddex_ingester_common.models.s3.body import Body
from ddex_ingester_common.models.s3.deal import Deal
from ddex_ingester_common.models.s3.deal_term import DealTerm
from ddex_ingester_common.models.s3.genre import Genre
from ddex_ingester_common.models.s3.instant_gratification import (
    InstantGratification)
from ddex_ingester_common.models.s3.label_participant import LabelParticipant
from ddex_ingester_common.models.s3.localized_participant import (
    LocalizedParticipant
)
from ddex_ingester_common.models.s3.localized_title import LocalizedTitle
from ddex_ingester_common.models.s3.marketing_highlight import (
    MarketingHighlight
)
from ddex_ingester_common.models.s3.p_line import PLine
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.models.s3.video import Video
from ddex_ingester_common.models.s3.video_asset import VideoAsset
from marshmallow import fields, INCLUDE, post_load, Schema


class BaseSchema(Schema):
    """Base schema."""

    class Meta:
        """Marshmallow Meta class."""

        unknown = INCLUDE


class AssetSchema(BaseSchema):
    """Asset Schema."""

    filename = fields.String(load_default=None)
    filepath = fields.String(load_default=None)
    bucket = fields.String(load_default=None)
    key = fields.String(load_default=None)
    ows_assets_filename = fields.String(load_default=None)

    @post_load
    def make_asset(self, data, **kwargs):
        """Make Asset model object."""
        if not data['filename'] or not data['filepath']:
            return None
        return Asset(**data)


class LocalizedParticipantSchema(BaseSchema):
    """Localized Participant Schema."""

    language_code = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    name = fields.String(required=False, allow_none=True, load_default='')

    @post_load
    def make_localized_participant(self, data, **kwargs):
        """Make Localized Participant model object."""
        return LocalizedParticipant(**data)


class ParticipantSchema(BaseSchema):
    """Participant Schema."""

    name = fields.String(required=False, allow_none=True, load_default='')
    sequence_number = fields.Int(required=False, load_default=None)
    spotify_uri = fields.String(required=False, load_default=None)
    apple_id = fields.String(required=False, load_default=None)
    roles = fields.List(fields.String(), allow_none=True, load_default=None)
    localized_names = fields.Nested(
        LocalizedParticipantSchema, many=True, load_default=None)

    @post_load
    def make_participant(self, data, **kwargs):
        """Make Participant model object."""
        return Participant(**data)


class LabelParticipantSchema(BaseSchema):
    """LabelParticipantSchema Schema."""

    name = fields.String(required=False, allow_none=True, load_default='')
    artist_id = fields.String(
        required=False, allow_none=True, load_default='')
    label_participant_id = fields.String(
        required=False, allow_none=True, load_default='')
    label_participant_uuid = fields.String(
        required=False, allow_none=True, load_default='')

    @post_load
    def make_participant(self, data, **kwargs):
        """Make LabelParticipantSchema model object."""
        return LabelParticipant(**data)


class StoreSchema(BaseSchema):
    """Store Schema."""

    store_id = fields.String(load_default=None)
    link = fields.String(load_default=None)
    delivery_date = fields.String(load_default=None)
    carved_out = fields.Boolean(required=False, allow_none=True)

    @post_load
    def make_store(self, data, **kwargs):
        """Make Store model object."""
        return Store(**data)


class InstantGratificationSchema(BaseSchema):
    """Instant Gratification Schema."""

    references = fields.List(
        fields.String(),
        many=True,
        required=False,
        allow_none=True,
        load_default=[]
    )
    start_date = fields.String(allow_none=True)
    start_date_time = fields.String(allow_none=True)

    @post_load
    def make_instant_grat(self, data, **kwargs):
        """Make Instant Gratification object."""
        return InstantGratification(**data)


class DealTermSchema(BaseSchema):
    """Deal Terms Schema."""

    commercial_model_types = fields.List(
        fields.String(),
        required=False,
        allow_none=True,
        load_default=[]
    )

    usage_type = fields.List(
        fields.String(),
        required=False,
        allow_none=True,
        load_default=[]
    )

    territories = fields.List(
        fields.String(),
        required=False,
        allow_none=True,
        load_default=[]
    )

    excluded_territories = fields.List(
        fields.String(),
        required=False,
        allow_none=True,
        load_default=[]
    )

    start_date = fields.String(allow_none=True)

    start_date_time = fields.String(allow_none=True)

    end_date = fields.String(allow_none=True)

    end_date_time = fields.String(allow_none=True)

    takedown = fields.String(
        required=False,
        load_default=None,
        allow_none=True
    )

    pre_order = fields.Boolean(required=False, allow_none=True)

    release_display_date = fields.String(required=False, allow_none=True)

    track_listing_preview_date = fields.String(
        required=False,
        allow_none=True
    )

    cover_art_preview_date = fields.String(required=False, allow_none=True)

    clip_preview_date = fields.String(required=False, allow_none=True)

    instant_gratifications = fields.Nested(
        InstantGratificationSchema, allow_none=True, load_default=None)

    price_type = fields.String(required=False, allow_none=True)

    @post_load
    def make_deal_terms(self, data, **kwargs):
        """Make Deal Term model object."""
        return DealTerm(**data)


class DealSchema(BaseSchema):
    """Deal Schema."""

    release_references = fields.List(
        fields.String(),
        required=False,
        allow_none=True,
        load_default=[]
    )

    deal_terms = fields.Nested(
        DealTermSchema,
        many=True,
        required=False,
        load_default=[]
    )

    @post_load
    def make_deal(self, data, **kwargs):
        """Make Deal model object."""
        return Deal(**data)


class LocalizedTitleSchema(BaseSchema):
    """Localized Title Schema."""

    language_code = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    title = fields.String(required=False, allow_none=True, load_default='')
    version = fields.String(load_default=None)

    @post_load
    def make_localized_title(self, data, **kwargs):
        """Make Localized Title model object."""
        return LocalizedTitle(**data)


class TrackSchema(BaseSchema):
    """Track Schema."""

    isrc = fields.String(required=False, allow_none=True, load_default='')
    release_type = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    sequence_number = fields.Int(required=False, load_default=None)
    volume = fields.Int(required=False, load_default=None)
    asset = fields.Nested(AssetSchema, required=False, load_default=None)
    release_reference = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    track_name = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    track_version = fields.String(allow_none=True, load_default=None)
    lyrics = fields.String(allow_none=True, load_default=None)
    lyrics_language = fields.String(allow_none=True, load_default=None)
    explicit = fields.String(allow_none=True, load_default=None)
    p_line = fields.String(allow_none=True, load_default=None)
    c_line = fields.String(allow_none=True, load_default=None)
    ownership_rights = fields.String(allow_none=True, load_default=None)
    recording_country_code = fields.String(allow_none=True, load_default=None)
    us_publishing_obligation = fields.String(
        allow_none=True,
        load_default=None
    )
    publishers = fields.List(
        fields.String(),
        allow_none=True,
        load_default=None
    )
    display_artists = fields.Nested(
        ParticipantSchema, many=True, load_default=None)
    resource_contributors = fields.Nested(
        ParticipantSchema, many=True, load_default=None)
    copyright_owner_country = fields.String(load_default=None)
    localized_titles = fields.Nested(
        LocalizedTitleSchema, many=True, load_default=None)
    preview_start_time = fields.Int(load_default=None)
    resource_reference = fields.String(
        required=False, allow_none=True, load_default='')
    content_type = fields.String(allow_none=True, load_default=None)
    offer_type = fields.String(allow_none=True, load_default=None)
    is_instrumental = fields.Boolean(load_default=False)
    original_release_date = fields.String(allow_none=True, load_default=None)

    @post_load
    def make_track(self, data, **kwargs):
        """Make Track model object."""
        return Track(**data)


class GenreSchema(BaseSchema):
    """Genre Schema."""

    genre = fields.String(required=False, allow_none=True, load_default='')
    subgenre = fields.String(required=False, load_default=None)

    @post_load
    def make_genre(self, data, **kwargs):
        """Make genre model object."""
        return Genre(**data)


class ProductSchema(BaseSchema):
    """Product Schema."""

    upc = fields.String(required=False, allow_none=True, load_default='')
    display_upc = fields.String(required=False, allow_none=True,
                                load_default='')
    is_main_release = fields.Boolean(
        required=False,
        allow_none=True,
        load_default=None
    )
    release_type = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    artwork = fields.Nested(AssetSchema, required=False, load_default=None)
    release_reference = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    sale_start_date = fields.Date(required=False, load_default=None)
    original_release_date = fields.String(required=False, load_default=None)
    grid = fields.String(required=False, load_default=None)
    catalog_number = fields.String(required=False, load_default=None)
    display_artist_name = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    product_name = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    display_artists = fields.Nested(
        ParticipantSchema,
        many=True,
        load_default=None
    )
    metadata_language = fields.String(load_default=None)
    product_version = fields.String(load_default=None)
    genres = fields.Nested(
        GenreSchema,
        required=False,
        many=True,
        load_default=[]
    )
    p_line = fields.String(load_default=None)
    c_line = fields.String(load_default=None)
    marketing_blurb = fields.String(load_default=None)
    stores = fields.Nested(StoreSchema, load_default=None, many=True)
    artist_profile_page = fields.String(load_default=None)
    localized_titles = fields.Nested(
        LocalizedTitleSchema, many=True, load_default=None)
    imprint = fields.String(allow_none=True, load_default=None)
    product_id = fields.Integer(
        required=False,
        allow_none=True,
        load_default=None
    )
    vendor_id = fields.Int(required=False, load_default=None)
    subaccount_id = fields.Int(required=False, load_default=None)
    status = fields.String(required=False, allow_none=True, load_default=None)
    not_for_distribution = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    display_status = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    special_instructions = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    genre_id = fields.Integer(required=False, load_default=None)
    subgenre_id = fields.Integer(required=False, load_default=None)
    product_version_notes = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    proprietary_id = fields.String(allow_none=True, load_default=None)
    manufacturer_upc = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    major_label = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    parent_repertoire_owner_code = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    parent_repertoire_owner_name = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    repertoire_owner_code = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    repertoire_owner_name = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    is_confidential = fields.Boolean(
        required=False,
        allow_none=True,
        load_default=False
    )
    duration = fields.String(
        required=False,
        allow_none=True,
        load_default=False
    )
    maintenance_owner_code = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )
    maintenance_owner_name = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )

    @post_load
    def make_product(self, data, **kwargs):
        """Make Product model object."""
        return Product(**data)


class MarketingHighlightSchema(BaseSchema):
    """Marketing Highlight Schema."""

    highlight = fields.String(load_default=None)
    store_codes = fields.List(
        fields.String(), allow_none=True, load_default=None)
    territory_codes = fields.List(
        fields.String(), allow_none=True, load_default=None)

    @post_load
    def make_highlights(self, data, **kwargs):
        """Make Project model object."""
        return MarketingHighlight(**data)


class ProjectSchema(BaseSchema):
    """Project Schema."""

    name = fields.String(required=False, load_default=None)
    project_code = fields.String(required=False, load_default=None)
    description = fields.String(required=False, load_default=None)
    artist = fields.Nested(ParticipantSchema, load_default=None)
    marketing_highlights = fields.Nested(
        MarketingHighlightSchema,
        many=True,
        load_default=None
    )

    @post_load
    def make_project(self, data, **kwargs):
        """Make Project model object."""
        return Project(**data)


class PLineSchema(Schema):
    """Genre schema."""

    line = fields.String(required=False, allow_none=True, load_default='')
    year = fields.Int(required=False, load_default=None)

    @post_load
    def make_genre(self, data, **kwargs):
        """Make pline model object."""
        return PLine(**data)


class VideoAssetSchema(BaseSchema):
    """VideoAsset Schema."""

    filename = fields.String(load_default=None)
    filepath = fields.String(load_default=None)
    bucket = fields.String(load_default=None)
    key = fields.String(load_default=None)
    aspect_ratio = fields.String(load_default=None)

    @post_load
    def make_video_asset(self, data, **kwargs):
        """Make Asset model object."""
        if not data['filename'] or not data['filepath']:
            return None
        return VideoAsset(**data)


class VideoSchema(BaseSchema):
    """Video Schema."""

    isrc = fields.String(required=False, allow_none=True, load_default='')
    assets = fields.Nested(
        VideoAssetSchema,
        many=True,
        required=False,
        load_default=None
    )
    release_reference = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    release_type = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    video_name = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    video_version = fields.String(allow_none=True, load_default=None)
    explict = fields.String(allow_none=True, load_default=None)
    p_line = fields.Nested(PLineSchema, allow_none=True, load_default=None)
    c_line = fields.Nested(PLineSchema, allow_none=True, load_default=None)
    display_artists = fields.Nested(
        ParticipantSchema,
        many=True,
        load_default=[]
    )
    resource_contributors = fields.Nested(
        ParticipantSchema,
        many=True,
        allow_none=True,
        load_default=None
    )
    title_language = fields.String(allow_none=True, load_default=None)
    content_language = fields.String(allow_none=True, load_default=None)
    product_code = fields.String(allow_none=True, load_default=None)
    imprint = fields.String(allow_none=True, load_default=None)
    video_type = fields.String(allow_none=True, load_default=None)
    genres = fields.Nested(
        GenreSchema,
        many=True,
        allow_none=True,
        load_default=None
    )
    associated_track_isrc = fields.String(allow_none=True, load_default=None)
    description = fields.String(allow_none=True, load_default=None)
    parental_advisory = fields.String(allow_none=True, load_default=None)
    keywords = fields.List(
        fields.String(),
        allow_none=True,
        load_default=None
    )
    lyrics = fields.String(load_default=None)
    content_type = fields.String(allow_none=True, load_default=None)

    @post_load
    def make_video(self, data, **kwargs):
        """Make Video model object."""
        return Video(**data)


class S3Schema(BaseSchema):
    """Context Schema."""

    project = fields.Nested(ProjectSchema, load_default=None)

    product = fields.Nested(ProductSchema)

    tracks = fields.Nested(
        TrackSchema,
        required=False,
        many=True,
        allow_none=True,
        load_default=None
    )

    label_participants = fields.Nested(
        LabelParticipantSchema, many=True, allow_none=True, load_default=None)

    video = fields.Nested(
        VideoSchema, required=False, allow_none=True, load_default=None)

    deals = fields.Nested(DealSchema, many=True, allow_none=True)

    bucket = fields.String()
    key = fields.String()

    message_id = fields.String(
        required=False, allow_none=True, load_default='')
    message_thread_id = fields.String(required=False, load_default=None)
    party_id = fields.String(required=False, allow_none=True, load_default='')
    update_indicator = fields.String(required=False, load_default=None)
    execution_name = fields.String(allow_none=True)
    state_machine_name = fields.String(allow_none=True)
    execution_start_time = fields.String(allow_none=True)

    @post_load
    def make_context(self, data, **kwargs):
        """Make Context model object."""
        return Body(**data)