from apollo_utils.service.schemas.fields.datetime import DateTimeStringField
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.core.streams_country_code import StreamsCountryCode
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
from server.utils.mappers.misc import format_id


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

        pass

    class Response(Schema, PaginationResultMixin):
        """Response playlists bulk schema."""

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

            class ItemNestedOwner(Schema):
                accountId = fields.Function(
                    lambda i: getter(
                        item=i, key=f"username", f=partial(format_id, remove_prefix=True, all_except_prefix=True)
                    )
                )
                accountName = fields.String(attribute="display_name")
                categoryId = fields.Integer(attribute="owner_category.owner_category_id")
                categoryName = fields.String(attribute="owner_category.name")

            spotifyLink = fields.String(attribute="playlist.uri", dump_default=None)
            name = fields.String(attribute="playlist.name", dump_default=None)
            num_tracks = fields.Integer(attribute="num_tracks", data_key="trackCount")
            is_personalized = fields.Boolean(attribute="playlist.is_personalised")
            countryCode = fields.String(attribute="playlist.country_code")
            subscribers = fields.Integer(attribute="playlist.followers")
            current = fields.Integer(data_key="position")
            trend = fields.Integer(data_key="positionChange")
            change_position_date_time = DateTimeStringField(data_key="positionChangeDate")
            last_added_date_time = DateTimeStringField(data_key="added")
            earliest_position_date_time = DateTimeStringField(data_key="earliestAdded")
            owner = fields.Nested(ItemNestedOwner, data_key="owner", attribute="playlist.owner")
            streaming_info = fields.Nested(ItemNestedStreams, data_key="streams")
            imageFileName = fields.String(attribute="playlist.image_url")
            globalStreams7Days = fields.Function(
                lambda i: getter(item=i, key=f"streaming_info.{StreamsCountryCode.WORLDWIDE.value}.7.playlist")
            )
            localStreams7Days = fields.Function(
                lambda i, c: getter(item=i, key=f"streaming_info.{c['local_streams_key']}.7.playlist")
            )

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


class V3PlaylistSpotifyByTrack:
    class Request(V3PlaylistCommonByTrack.Request):
        """(v3) Request schema to get spotify playlists by track."""

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

        class NestedItem(V3PlaylistCommonByTrack.NestedItemResponse):
            personalized = fields.Boolean(attribute="playlist.is_personalised")

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