from apollo_utils.service.schemas.fields.datetime import DateTimeStringField
from apollo_utils.service.schemas.fields.list import SplitUniqueListField
from apollo_utils.service.schemas.mixins.isrc import IsrcListRequiredMixin
from marshmallow import fields, validate

from server.constants.playlists.delphi.core.streams_country_code import StreamsCountryCode
from server.constants.playlists.markets import APPLE_PLAYLISTS_TOP_28_MARKETS
from server.constants.playlists.v0.misc import StreamsType
from server.schemas.base.pagination import PaginationResultMixin, get_pagination_mixin
from server.schemas.base.schemas import RequestSchema, Schema
from server.schemas.playlists.common.v3_playlists_by_track import V3PlaylistCommonByTrack
from server.utils.mappers.core.getters import getter


class V1PlaylistsAppleByTrack:
    class Request(RequestSchema, IsrcListRequiredMixin, get_pagination_mixin(page_limit=None)):
        """Request schema to get spotify playlists by tracks from delphi."""

        country = SplitUniqueListField(
            fields.String(validate=validate.Length(max=10, min=2)),
            required=False,
            missing=APPLE_PLAYLISTS_TOP_28_MARKETS,
        )
        meta_country_code = fields.String(validate=validate.Length(max=10, min=2), load_default="us")

    class Response(Schema, PaginationResultMixin):
        """Response V1PlaylistsAppleByTrack schema used as adapter."""

        class NestedItem(Schema):
            class ItemNestedOwner(Schema):
                accountId = fields.String(attribute="display_name", dump_default=None)
                categoryId = fields.Integer(attribute="owner_category.owner_category_id", dump_default=None)
                categoryName = fields.String(attribute="owner_category.name", dump_default=None)

            class ItemNestedCountries(Schema):
                countryCode = fields.String(attribute="playlist.country_code")
                num_tracks = fields.Integer(data_key="playlistTrackCount")
                current = fields.Integer(data_key="trackPosition")
                trend = fields.Integer(data_key="positionChange")
                change_position_date_time = DateTimeStringField(data_key="positionChangeDate")
                last_added_date_time = DateTimeStringField(data_key="tracksLastAdded")
                earliest_position_date_time = DateTimeStringField(data_key="earliestAdded")
                streams7Days = fields.Function(
                    lambda i: getter(item=i, key=f"streaming_info.{StreamsCountryCode.LOCAL.value}.7.playlist")
                )
                streams1Days = fields.Function(
                    lambda i: getter(item=i, key=f"streaming_info.{StreamsCountryCode.LOCAL.value}.1.playlist")
                )
                isrcStreams7Days = fields.Function(
                    lambda i: getter(item=i, key=f"streaming_info.{StreamsCountryCode.LOCAL.value}.7.isrc_in_playlist")
                )
                isrcStreams1Days = fields.Function(
                    lambda i: getter(item=i, key=f"streaming_info.{StreamsCountryCode.LOCAL.value}.1.isrc_in_playlist")
                )
                isrc = fields.String()

            playlist_id = fields.String(data_key="id")
            name = fields.String(attribute="playlist.name")
            owner = fields.Nested(ItemNestedOwner, attribute="playlist.owner")
            countries = fields.Nested(ItemNestedCountries(many=True))
            artwork = fields.Url(attribute="playlist.image_url")
            streamsGlobal7Days = fields.Function(
                lambda i: getter(item=i, key=f"streaming_info.{StreamsCountryCode.WORLDWIDE.value}.7.playlist")
            )
            streamsGlobal1Days = fields.Function(
                lambda i: getter(item=i, key=f"streaming_info.{StreamsCountryCode.WORLDWIDE.value}.1.playlist")
            )
            isrcStreamsGlobal7Days = fields.Function(
                lambda i, c: getter(
                    item=i, key=f"streaming_info.{StreamsCountryCode.WORLDWIDE.value}.7.isrc_in_playlist"
                )
            )
            isrcStreamsGlobal1Days = fields.Function(
                lambda i, c: getter(
                    item=i, key=f"streaming_info.{StreamsCountryCode.WORLDWIDE.value}.1.isrc_in_playlist"
                )
            )

        items = fields.Nested(NestedItem(many=True))


class V3PlaylistAppleByTrack:
    class Request(V3PlaylistCommonByTrack.Request):
        pass

    class Response(Schema, PaginationResultMixin):
        class PlaylistCategoriesItemResponse(V3PlaylistCommonByTrack.PlaylistCategoriesItemResponse):
            pass

        class NestedItem(V3PlaylistCommonByTrack.NestedItemResponse):
            pass

        items = fields.List(fields.Nested(NestedItem))
        streams_type = fields.String(default=StreamsType.TRACK)
        categories = fields.Nested(PlaylistCategoriesItemResponse(many=True))