"""State Machine Context Schema."""
from enum import Enum

from common.models.state_machine.genre import Genre
from common.models.state_machine.grps_ingestion_context import \
    GrpsIngestionContext
from common.models.state_machine.label_participant import LabelParticipant
from common.models.state_machine.participant import Participant
from common.models.state_machine.product import Product
from common.models.state_machine.project import Project
from common.models.state_machine.track import Track
from marshmallow import fields, INCLUDE, post_load, Schema


class ProductType(Enum):
    """GRPS product types."""

    AUDIO = 'audio'
    VIDEO = 'video'


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

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

        unknown = INCLUDE


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

    name = fields.String(required=False, allow_none=True, load_default='')
    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)

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


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

    name = fields.String(required=False, load_default=None)
    project_code = fields.String(required=False, load_default=None)
    project_id = fields.Int(required=False, load_default=None)
    artist = fields.Nested(ParticipantSchema, load_default=None)

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

    product_id = fields.Int(required=False, load_default=None)
    upc = fields.String(required=False, allow_none=True)
    display_upc = fields.String(required=False, allow_none=True)
    product_name = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    grid = fields.String(required=False, load_default=None)
    release_date = fields.String(required=False, load_default=None)
    sale_start_date = fields.String(required=False, load_default=None)
    display_artists = fields.Nested(
        ParticipantSchema,
        many=True,
        load_default=None
    )
    vendor_id = fields.Int(required=False, load_default=None)
    subaccount_id = fields.Int(required=False, load_default=None)
    not_for_distribution = fields.String(
        required=False, load_default='SMEAnalyticsDummy'
    )
    parent_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
    )
    repertoire_owner_code = fields.String(
        required=False,
        allow_none=True,
        load_default=None
    )

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

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

    catalog_number = 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 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='')
    role = 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 TrackSchema(BaseSchema):
    """Track Schema."""

    isrc = fields.String(required=False, allow_none=True, load_default='')
    track_name = fields.String(
        required=False,
        allow_none=True,
        load_default=''
    )
    tuid = fields.Int(required=False, allow_none=True, load_default=None)
    duration = fields.Int(required=False, load_default=None)
    sequence_number = fields.Int(required=False, load_default=None)
    volume = fields.Int(required=False, load_default=None)
    explicit = fields.String(allow_none=True, load_default=None)
    version = fields.String(
        required=False, allow_none=True, load_default=None)
    display_artists = fields.Nested(
        ParticipantSchema, many=True, load_default=None)

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


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

    correlation_id = fields.String(allow_none=True, load_default=None)

    product_type = fields.Enum(ProductType, allow_none=True, load_default=None)

    placeholder_upc_ingestion = fields.Bool(allow_none=True,
                                            load_default=False)

    grps_ingestion_id = fields.Int(required=False, load_default=None)

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

    product = fields.Nested(ProductSchema)
    deleted_tracks = fields.List(fields.Int(), allow_none=True,
                                 load_default=None)

    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)

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