from apollo_utils.core.constants.dsp import DSP
from apollo_utils.core.constants.market import GLOBAL_MARKET_CODE, Market
from apollo_utils.service.legacy.schemas.mixins.vendor import RequiredAllVendorMixin
from apollo_utils.service.schemas.base import RequestSchema
from apollo_utils.service.schemas.fields.list import SplitUniqueListField
from apollo_utils.service.schemas.mixins.date import DateRangeMixin
from apollo_utils.service.schemas.mixins.market import DelphiMarketsListMixin
from apollo_utils.service.utils.market import convert_market
from marshmallow import Schema, ValidationError, fields, post_load
from typing import Optional


class GlobalMarketOutputField(fields.Str):
    """Custom field for replacing various Global country codes values to _gl."""

    def _serialize(self, value, attr, obj, **kwargs) -> Optional[str]:
        value = super()._deserialize(value, attr, obj, **kwargs)
        if value:
            value = convert_market(value, GLOBAL_MARKET_CODE)
        return value


class PlaylistStreamsGraph:
    class Request(RequestSchema, DateRangeMixin, RequiredAllVendorMixin, DelphiMarketsListMixin):
        playlist_id = SplitUniqueListField(fields.String(), required=True)
        """Playlists Search Request params Schema."""

        @post_load
        def validate_user(self, data, **kwargs):
            if (
                DSP.AMAZON.value in data["vendor"]
                and Market.WORLDWIDE in data["markets"]
                and len(data["playlist_id"]) > 1
            ):
                raise ValidationError(
                    f"Only one passed playlist_id is allowed for vendor: {DSP.AMAZON.value} "
                    f"if market {Market.WORLDWIDE} is provided."
                    f"Passed data: {data}"
                )
            return data

    class Response(Schema):
        class PlaylistStreamsItem(Schema):
            class Meta:
                class CoordinatesSchema(Schema):
                    class Meta:
                        include = {
                            "y": fields.Int(missing=None, default=None),
                            "x": fields.Int(required=True),
                        }

                include = {
                    "playlist_id": fields.String(),
                    "country_code": GlobalMarketOutputField(),
                    "coordinates": fields.List(fields.Nested(CoordinatesSchema)),
                }

        include = {
            "dates": fields.Dict(),
            "items": fields.List(fields.Nested(PlaylistStreamsItem)),
        }