from apollo_utils.service.schemas.fields.datetime import DateTimeStringField
from apollo_utils.service.schemas.fields.enum import EnumListField
from apollo_utils.service.schemas.mixins.isrc import IsrcListRequiredMixin
from apollo_utils.service.schemas.mixins.market import MarketNoneMixin
from functools import partial
from marshmallow import fields

from server.constants.playlists.delphi.by_api.track_positions_previous_playlists import TrackPositionsPreviousPlaylists
from server.constants.playlists.delphi.core.include import StreamsForPeriod
from server.constants.playlists.delphi.core.streams_country_code import StreamsCountryCode
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_history import V3PlaylistCommonByTrackHistory
from server.utils.mappers.core.getters import getter
from server.utils.mappers.misc import format_id


class V1PlaylistSpotifyByTrackHistory:
    class Request(RequestSchema, IsrcListRequiredMixin, MarketNoneMixin, get_pagination_mixin(page_limit=None)):
        """Request schema to get history for spotify playlists by tracks."""

        include_list = EnumListField(StreamsForPeriod, data_key="include", as_enum=True, allow_all=True, missing=[])
        streams_country_code = fields.String(missing=TrackPositionsPreviousPlaylists.STREAMS_COUNTRY_CODE.LOCAL.value)

    class Response(Schema, PaginationResultMixin):
        """Response for historical playlists with track."""

        class NestedItem(Schema):
            class ItemNestedStreams(Schema):
                global7Days = fields.Function(
                    lambda i: getter(item=i, key=f"{StreamsCountryCode.WORLDWIDE.value}.7.playlist")
                )
                local7Days = fields.Function(lambda i, c: getter(item=i, key=f"{c['local_streams_key']}.7.playlist"))

            class ItemNestedPlaylist(Schema):
                uri = fields.String(data_key="spotifyLink")
                name = fields.String()
                followers = fields.Integer(data_key="subscribers")
                country_code = fields.String(data_key="countryCode")
                is_personalized = fields.Boolean(attribute="is_personalised")
                buzzCategoryId = fields.Integer(attribute="owner.owner_category.owner_category_id")
                accountName = fields.String(attribute="owner.display_name")
                imageFileName = fields.Url(attribute="image_url")
                accountId = fields.Function(
                    lambda i: getter(item=i, key=f"owner.username", f=partial(format_id, remove_prefix=True))
                )

            isrc = fields.String()
            earliest_position_date_time = DateTimeStringField(data_key="earliestTrackDate")
            removed_date_time = DateTimeStringField(data_key="latestTrackDate")
            playlist = fields.Nested(ItemNestedPlaylist)
            num_days_on = fields.Integer(data_key="daysInPlaylist")
            streaming_info = fields.Nested(ItemNestedStreams, data_key="streams")

        items = fields.List(fields.Nested(NestedItem))


class V3PlaylistSpotifyByTrackHistory:
    class Request(V3PlaylistCommonByTrackHistory.Request):
        pass

    class Response(Schema, PaginationResultMixin):
        class PlaylistCategoriesItemResponse(V3PlaylistCommonByTrackHistory.PlaylistCategoriesItemResponse):
            owner_category_id = fields.Integer(data_key="category_id")
            name = fields.String(data_key="category_name")

        class NestedItem(V3PlaylistCommonByTrackHistory.NestedItemResponse):
            """Response for apollo playlists with track historical item V3."""

            personalized = fields.Bool(attribute="playlist.is_personalised", default=False)

        items = fields.List(fields.Nested(NestedItem))
        categories = fields.Nested(PlaylistCategoriesItemResponse(many=True))