from apollo_utils.service.schemas.fields.datetime import DateStringField
from apollo_utils.service.schemas.fields.enum import EnumField, EnumListField
from apollo_utils.service.schemas.mixins.date import DateRangeOptionalMixin
from apollo_utils.service.schemas.mixins.market import MarketNoneMixin, get_market_mixin
from apollo_utils.service.schemas.mixins.misc import get_dependant_mixin
from marshmallow import fields

from server.constants.charts import YoutubeDatesInclude, YoutubeFullTrendInclude, YoutubeVideoImageSize, \
    YoutubeVideoPositionsInclude, YoutubeVideoTrendField, YoutubeVideoTrendSortBy
from server.constants.common import SortOrder
from server.schemas.base.schemas import RequestSchema, Schema


class DatesRange(Schema):
    """Dates range output schema."""

    min = DateStringField()
    max = DateStringField()


class YoutubeDates:
    class Request(RequestSchema, MarketNoneMixin):
        """Request schema to get youtube dates and markets."""

        video_id = fields.String(missing=None)
        include_list = EnumListField(YoutubeDatesInclude, missing=[], data_key="include")

    class Response(Schema):
        """Response schema for the charts youtube dates endpoint."""

        charts = fields.Nested(DatesRange)
        video = fields.Nested(DatesRange)
        markets = fields.List(fields.String())


class YoutubeVideoTrend:
    class Request(
        RequestSchema,
        get_dependant_mixin(
            "sort_by",
            "field_list",
            always_allowed=[YoutubeVideoTrendSortBy.COUNTRY_CODE],
            depends_on_enum=YoutubeVideoTrendField,
        ),
    ):
        """Request schema to get youtube charts data for a single video."""

        video_id = fields.String(required=True)
        chart_date = fields.Date(data_key="date", missing=None)
        field_list = EnumListField(
            YoutubeVideoTrendField,
            allow_all=True,
            as_enum=True,
            missing_all=True,
            data_key="fields",
        )
        sort_by = EnumField(YoutubeVideoTrendSortBy, missing=YoutubeVideoTrendSortBy.COUNTRY_CODE)
        sort_order = EnumField(SortOrder, missing=SortOrder.ASC)
        all_markets = fields.Boolean(missing=True)

    class Response(Schema):
        """Response single youtube charts video data schema."""

        class YoutubeVideoTrendData(Schema):
            """Youtube charts video inner data schema."""

            current_position = fields.Integer()
            trend = fields.Integer()
            in_chart_days = fields.Integer()
            peak_position = fields.Integer()
            peak_position_date = DateStringField()
            added_date = DateStringField()
            is_new = fields.Boolean()
            is_re_entry = fields.Boolean()
            date = DateStringField()

        country_code = fields.String()
        data = fields.Nested(YoutubeVideoTrendData)


class YoutubeVideoPositions:
    class Request(RequestSchema, get_market_mixin(max_len=18), DateRangeOptionalMixin):
        """Request schema to get youtube video positions for a market within a date range."""

        video_id = fields.String(required=True)
        include_list = EnumListField(YoutubeVideoPositionsInclude, missing=[], data_key="include")

    class Response(Schema):
        """Response schema for the charts youtube video positions endpoint."""

        class YoutubeVideoPositionsChart(Schema):
            """Youtube video positions chart output schema."""

            chart_id = fields.String()
            name = fields.String()
            chart_group = fields.String()
            country_code = fields.String()
            dsp = fields.String()
            total_positions = fields.Integer()

        class YoutubeVideoPositionsItem(Schema):
            """Youtube video positions item output schema."""

            date = DateStringField()
            position = fields.Integer()

        chart = fields.Nested(YoutubeVideoPositionsChart)
        items = fields.List(fields.Nested(YoutubeVideoPositionsItem))
        count = fields.Integer()


class YoutubeFullTrend:
    class Request(RequestSchema, get_market_mixin(max_len=18)):
        """Request schema to get youtube full chart for some date and market."""

        chart_date = fields.Date(required=True, data_key="date")
        image_size = EnumField(YoutubeVideoImageSize, missing=YoutubeVideoImageSize.DEFAULT)
        include_list = EnumListField(
            YoutubeFullTrendInclude,
            allow_all=True,
            as_enum=True,
            missing_all=True,
            data_key="include",
        )

    class Response(Schema):
        """Response full youtube chart schema."""

        class YoutubeFullTrendVideo(Schema):
            """Youtube charts video data schema."""

            title = fields.String()
            channel_id = fields.String()
            channel_title = fields.String()
            content_type = fields.String()
            date_uploaded = DateStringField()
            image_url = fields.String()

        class YoutubeFullTrendPosition(Schema):
            """Youtube charts position data schema."""

            current = fields.Integer()
            is_new = fields.Boolean()
            is_re_entry = fields.Boolean()
            trend = fields.Integer()

        class YoutubeFullTrendSummary(Schema):
            """Youtube charts summary data schema."""

            peak_position = fields.Integer()
            peak_position_date = DateStringField()
            added_date = DateStringField()
            in_chart_days = fields.Integer()

        video_id = fields.String()
        position = fields.Nested(YoutubeFullTrendPosition)
        summary = fields.Nested(YoutubeFullTrendSummary)
        video = fields.Nested(YoutubeFullTrendVideo)