"""DDEX marshmallow context schema."""
from ddex_ingester_common.models.state_machine.asset import Asset
from ddex_ingester_common.models.state_machine.body import Body
from ddex_ingester_common.models.state_machine.correction_item import (
    CorrectionItem
)
from ddex_ingester_common.models.state_machine.error_correction import (
    ErrorCorrection
)
from ddex_ingester_common.models.state_machine.original_values import (
    OriginalValues
)
from ddex_ingester_common.models.state_machine.product import (
    Product
)
from ddex_ingester_common.models.state_machine.track import Track
from ddex_ingester_common.models.state_machine.video import Video
from ddex_ingester_common.models.state_machine.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 TrackSchema(BaseSchema):
    """Track Schema."""

    tuid = fields.Integer(allow_none=True, required=False, load_default=None)
    isrc = fields.String(required=False, allow_none=True, load_default='')
    asset = fields.Nested(AssetSchema, required=False, load_default=None)
    release_reference = fields.String(
        required=False, allow_none=True, load_default='')
    resource_reference = fields.String(
        required=False, allow_none=True, load_default='')

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


class OriginalValuesSchema(BaseSchema):
    """Original values schema.

    Used in conjunction with sending emails for
    high importance fields on complete
    products that have been modified.
    """

    sale_start_date = fields.String(load_default=None)
    carveout_country_codes = fields.List(
        fields.String(), allow_none=True, load_default=None)
    release_date = fields.String(load_default=None)

    @post_load
    def make_original_values(self, data, **kwargs):
        """Make Original Values model object."""
        return OriginalValues(**data)


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

    product_id = fields.Integer(allow_none=True, load_default=None)
    upc = fields.String(required=False, allow_none=True, load_default='')
    display_upc = fields.String(required=False, allow_none=True,
                                load_default='')
    release_type = fields.String(allow_none=True, load_default=None)
    artwork = fields.Nested(AssetSchema, required=False, load_default=None)
    release_reference = fields.String(allow_none=True, load_default=None)
    sale_start_date = fields.Date(required=False, load_default=None)
    original_release_date = fields.String(required=False, load_default=None)
    vendor_id = fields.Int(required=False, load_default=None)
    subaccount_id = fields.Int(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(allow_none=True, load_default=None)
    original_values = fields.Nested(
        OriginalValuesSchema,
        allow_none=True
    )
    status = fields.String(allow_none=True, load_default=None)
    product_name = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    not_for_distribution = fields.String(allow_none=True, load_default=None)
    display_status = fields.String(allow_none=True, load_default=None)
    special_instructions = fields.String(allow_none=True, load_default=None)
    genre_id = fields.Integer(required=False, load_default=None)
    subgenre_id = fields.Integer(required=False, load_default=None)

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


class CorrectionItemSchema(BaseSchema):
    """Correction Item Schema."""

    release_correction_detail_id = fields.Integer(
        required=False,
        allow_none=True
    )
    field_name = fields.String(
        required=False, allow_none=True, load_default='')
    key_value = fields.Raw(required=False, load_default=None)
    key_id = fields.Integer(required=False, load_default=None)
    table_name = fields.String(
        required=False, allow_none=True, load_default='')

    @post_load
    def make_correction_item(self, data, **kwargs):
        """Make Correction Item model object."""
        return CorrectionItem(**data)


class ErrorCorrectionSchema(BaseSchema):
    """Error Correction Schema."""

    release_correction_id = fields.Integer(required=False, allow_none=True)
    release_id = fields.Integer(required=False, load_default=None)
    items = fields.Nested(CorrectionItemSchema, many=True, allow_none=True)

    @post_load
    def make_error_correction(self, data, **kwargs):
        """Make Error Correction model object."""
        return ErrorCorrection(**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."""

    tuid = fields.Integer(allow_none=True, required=False, load_default=None)
    isrc = fields.String(required=False, allow_none=True, load_default='')
    assets = fields.Nested(
        VideoAssetSchema, required=False, load_default=None, many=True)
    release_reference = fields.String(
        required=False, allow_none=True, load_default='')
    workflow_id = fields.Int(
        load_default=None, required=False, allow_none=True)
    associated_track_tuid = fields.Integer(required=False, load_default=None)
    current_channel = fields.String(allow_none=True, load_default=None)

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


class StateMachineSchema(BaseSchema):
    """State Machine Context Schema."""

    product = fields.Nested(ProductSchema)

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

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

    validation_results = fields.Dict(
        many=True, allow_none=True, load_default=None)

    error_correction = fields.Nested(
        ErrorCorrectionSchema,
        required=False,
        load_default=None
    )

    is_purged_release = fields.Bool()

    bucket = fields.String()
    key = fields.String()
    errors = fields.Raw(allow_none=True, load_default=None)

    message_id = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    message_thread_id = fields.String(required=False, load_default=None)
    update_indicator = fields.String(allow_none=True, load_default=None)
    maintenance_owner = fields.String(allow_none=True)
    orchard_label = fields.String(allow_none=True, 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)
    project_id = fields.Integer(load_default=None)
    warnings = fields.List(fields.Dict(), allow_none=True, load_default=None)
    ddex_provider = fields.String(required=False, load_default=None)
    ingest_id = fields.Integer(required=False, load_default=None)
    correlation_id = fields.String(required=False, load_default=None)
    validate_product_retry_counter =\
        fields.Integer(allow_none=False, load_default=0)

    # For storing a list of deal coordinator emails
    deal_coordinators = fields.List(
        fields.String(), allow_none=True, load_default=None)

    has_switchboard_deal = fields.Bool()

    artwork_ingestion_only = fields.Boolean(
        required=False,
        allow_none=True,
        load_default=False
    )

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