from apollo_utils.core.constants.dsp import DSP_SPOTIFY_APPLE_AMAZON
from apollo_utils.core.constants.market import Market
from apollo_utils.service.schemas.fields.datetime import DateStringField
from apollo_utils.service.schemas.fields.enum import EnumListField
from apollo_utils.service.schemas.fields.list import SplitUniqueListField
from apollo_utils.service.schemas.fields.market import MarketField
from apollo_utils.service.schemas.mixins.date import DateRangeMixin
from marshmallow import fields, validate

from server.schemas.base.schemas import RequestSchema, Schema


class ArtistsStreams:
    class Request(RequestSchema, DateRangeMixin):
        spotify_artist_id = fields.String(required=True)
        country_code_list = SplitUniqueListField(
            MarketField(validate=validate.Length(max=10, min=2), gl=Market.WORLDWIDE),
            missing=[Market.WORLDWIDE],
            data_key="country_code",
        )
        dsp_list = EnumListField(
            DSP_SPOTIFY_APPLE_AMAZON,
            allow_all=True,
            as_enum=False,
            unify=True,
            data_key="dsp",
            missing=[DSP_SPOTIFY_APPLE_AMAZON.SPOTIFY.value],
        )

    class Response(Schema):
        country_code = fields.String()
        data = fields.List(fields.Raw())


class ArtistsStreamsTotals:
    class Request(RequestSchema):
        spotify_artist_id = fields.String(required=True)
        country_code = MarketField(validate=validate.Length(max=10, min=2), gl=Market.WORLDWIDE, missing=None)
        dsp_list = EnumListField(
            DSP_SPOTIFY_APPLE_AMAZON,
            allow_all=True,
            as_enum=False,
            unify=True,
            data_key="dsp",
            missing=DSP_SPOTIFY_APPLE_AMAZON.values(),
        )

    class Response(Schema):
        class FirstStreamDate(Schema):
            spotify = DateStringField()
            apple = DateStringField()
            amazon = DateStringField()

        first_stream_date = fields.Nested(FirstStreamDate)
        worldwide = fields.Integer()
        country = fields.Integer()


class ArtistsDemographics:
    class Request(RequestSchema, DateRangeMixin):
        spotify_artist_id = fields.String(required=True)
        country_code_list = SplitUniqueListField(
            MarketField(validate=validate.Length(max=10, min=2), gl=Market.WORLDWIDE),
            missing=[Market.WORLDWIDE],
            data_key="country_code",
        )
        dsp_list = EnumListField(
            DSP_SPOTIFY_APPLE_AMAZON,
            allow_all=True,
            as_enum=False,
            unify=True,
            data_key="dsp",
            missing=DSP_SPOTIFY_APPLE_AMAZON.values(),
        )
        include_list = SplitUniqueListField(fields.String(required=True), missing=["demographics"], data_key="include")
        per_day = fields.Boolean(missing=False)
        sort_by = fields.String(missing=None)
        sort_order = fields.String(missing=None)

    class Response(Schema):
        items = fields.List(fields.Raw())


class ArtistsMarketsTopItem(Schema):
    market = fields.Str()
    streams = fields.Int()


class ArtistsMarketsTop:
    class Request(RequestSchema, DateRangeMixin):
        dsp_list = EnumListField(
            DSP_SPOTIFY_APPLE_AMAZON,
            allow_all=True,
            as_enum=False,
            unify=True,
            data_key="dsp",
            missing=DSP_SPOTIFY_APPLE_AMAZON.values(),
        )
        spotify_artist_id = fields.String(required=True)
        limit = fields.Int(missing=15)
        include_worldwide = fields.Boolean(missing=False)
        combine = fields.Boolean(missing=False)

    class Response(Schema):
        class Meta:
            include = {
                dsp: fields.List(fields.Nested(ArtistsMarketsTopItem))
                for dsp in DSP_SPOTIFY_APPLE_AMAZON.values(with_all=True)
            }