from apollo_utils.service.legacy.schemas.mixins.vendor import VendorMixin, VendorRequiredMixin
from apollo_utils.service.schemas.base import RequestSchema
from apollo_utils.service.schemas.fields.isrc import IsrcField
from apollo_utils.service.schemas.fields.list import SplitUniqueListField
from apollo_utils.service.schemas.fields.market import DelphiMarketField
from apollo_utils.service.schemas.mixins.date import DateRangeMixin
from apollo_utils.service.schemas.mixins.isrc import get_isrc_list_mixin
from apollo_utils.service.schemas.mixins.market import DelphiDefaultMarketMixin
from marshmallow import Schema, ValidationError, fields, validate, validates_schema

from server.legacy.analytics.mixins import AllMarketsNullBooleanMixin, PlaylistIdField
from server.legacy.core import constants


class TrackPlaylistSummaryDeserializer(RequestSchema, DelphiDefaultMarketMixin, VendorRequiredMixin):
    """Track playlist summary deserializer for global and specific markets."""

    isrc = IsrcField(required=True)
    last_date = fields.Date(required=False, format="iso")


class TrackPlaylistSummaryV1Deserializer(
    RequestSchema,
    DelphiDefaultMarketMixin,
    get_isrc_list_mixin(),
    DateRangeMixin,
    VendorRequiredMixin,
    AllMarketsNullBooleanMixin,
):
    """Track playlist bulk isrc summary deserializer for global and specific markets."""


class TracksStreamsCountParams(
    RequestSchema, DelphiDefaultMarketMixin, get_isrc_list_mixin(), DateRangeMixin, VendorMixin
):
    """Schema for total tracks streams in specific time range."""

    pass


class TrackPerCountryViewParams(RequestSchema, DateRangeMixin, VendorRequiredMixin):
    """Schema for input validation of tracks_per_country_view."""

    isrc = IsrcField(required=True)
    streams_only = fields.Boolean(missing=True)


class TrackPerCountryV1:
    class Request(get_isrc_list_mixin(), DateRangeMixin, VendorRequiredMixin, RequestSchema):
        market_list = SplitUniqueListField(
            DelphiMarketField(required=True),
            data_key="market",
            missing=[],
            description="Market code value, leave empty for all.",
        )
        streams_only = fields.Boolean(missing=True)
        combine_isrc = fields.Boolean(missing=False)
        exclude_global = fields.Boolean(missing=False)

    class Response(Schema):
        class MarketItem(Schema):
            class DateItem(Schema):
                date = fields.Date(required=True)
                streams = fields.Integer(required=True)

            countryCode = fields.Str(required=True)
            data = fields.List(fields.Nested(DateItem))

        isrc: fields.Str(required=True)
        data = fields.List(fields.Nested(MarketItem))


class TracksFirstStreamDatesViewParams(RequestSchema, get_isrc_list_mixin(), VendorRequiredMixin):
    """Schema for input validation of tracks_first_stream_dates_view."""

    pass


class CAMarketMixin:
    market = fields.Str(required=False, data_key="countryCode")


class CADateRangeMixin:
    """Date range validation mixin."""

    start_date = fields.Date(
        required=True, format="iso", description="Date range start value (ISO8601-formatted).", data_key="startDate"
    )
    end_date = fields.Date(
        required=True, format="iso", description="Date range end value (ISO8601-formatted).", data_key="endDate"
    )

    @validates_schema
    def validate_time_range(self, data, **kwargs):
        if data["start_date"] > data["end_date"]:
            raise ValidationError("The date range end date cannot be before the start date ")


class CATrackDemographicsViewParams(RequestSchema, get_isrc_list_mixin(), CADateRangeMixin):
    """Schema for input validation of track_demographics_view."""

    pass


class CAAppleTrackInContainerViewParams(RequestSchema, CADateRangeMixin, CAMarketMixin):
    """Schema for input validation of track_demographics_view."""

    isrc = IsrcField(required=True)
    playlist_id = PlaylistIdField(constants.APPLE, required=True, data_key="containerId")


class CASpotifyTrackInPlaylistV2ViewParams(RequestSchema, CADateRangeMixin, CAMarketMixin):
    """Schema for input validation of track_in_playlist_summary_v2_view."""

    isrc = IsrcField(required=True)
    playlist_id = PlaylistIdField(constants.SPOTIFY, required=True, data_key="playlistId")


class CASpotifyTrackInPlaylistSummaryV2ViewParams(
    RequestSchema, get_isrc_list_mixin(), CADateRangeMixin, CAMarketMixin
):
    """Schema for input validation of track_in_playlist_summary_v2_view."""

    playlist_id = PlaylistIdField(constants.SPOTIFY, required=True, data_key="playlistId")


class StreamsLatestDateViewParams(RequestSchema):
    """Schema for input validation of streams_latest_date_view."""

    vendors = SplitUniqueListField(
        fields.Str(
            validate=validate.OneOf(
                (
                    constants.SPOTIFY,
                    constants.APPLE,
                    constants.AMAZON,
                    constants.YOUTUBE,
                    constants.TIKTOK,
                    constants.ALL,
                )
            ),
            required=True,
        ),
        missing=[constants.SPOTIFY],
    )