from apollo_utils.core.constants.dsp import DSP_SPOTIFY_APPLE_AMAZON
from apollo_utils.service.schemas.base import RequestSchema
from apollo_utils.service.schemas.fields.enum import EnumListField
from apollo_utils.service.schemas.fields.list import SplitUniqueListField
from apollo_utils.service.schemas.mixins.pagination import PaginationResponseMixin
from marshmallow import Schema, ValidationError, fields, validate, validates, validates_schema

from server.constants.core import OS, ApolloEntityType
from server.constants.favorites import Include as FavoritesInclude
from server.schemas.pagination import HighLimitPaginationMixin
from server.schemas.settings import AppVersion, Versions


class FavoritesGetByParams:
    class RequestParams(HighLimitPaginationMixin, RequestSchema):
        pass

    class RequestData(RequestSchema):
        user_list = SplitUniqueListField(fields.String(required=True), required=False)
        entity_type_list = EnumListField(ApolloEntityType, required=True, validate=validate.Length(min=1))
        vendor_list = EnumListField(
            DSP_SPOTIFY_APPLE_AMAZON,
            required=False,
            missing=[DSP_SPOTIFY_APPLE_AMAZON.SPOTIFY.value, DSP_SPOTIFY_APPLE_AMAZON.APPLE.value],
        )

        @validates("entity_type_list")
        def validate_entity_type_list(self, value):
            if value and len(value) > 1:
                raise ValidationError("For now only one entity_type per request is allowed.")

    class Response(PaginationResponseMixin, Schema):
        class Item(Schema):
            entity_type = fields.String()
            entity_id = fields.String()
            account_id = fields.Int()
            user_id = fields.Function(lambda obj: obj.account.user_id)
            data = fields.Dict(default=None)

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


class FavoritesPostList:
    class Request(RequestSchema):
        class User(RequestSchema):
            id = fields.List(fields.String(), missing=None)

        class Account(RequestSchema):
            id = fields.List(fields.Integer(), missing=None)

        class Entity(RequestSchema):
            type = fields.String(missing=None)
            id = fields.List(fields.String(), missing=None)

        class Device(RequestSchema):
            is_active = fields.Boolean(missing=None)
            os = EnumListField(OS, missing=None)
            app_version = fields.Nested(AppVersion, missing=None)

        class Settings(RequestSchema):
            type = fields.String(missing=None)
            version = fields.Integer(missing=None)
            versions = fields.Nested(Versions, missing=None)

        user = fields.Nested(User, missing=None)
        account = fields.Nested(Account, missing=None)
        entity = fields.Nested(Entity, missing=None)
        device = fields.Nested(Device, missing=None)
        settings = fields.Nested(Settings, missing=None)
        include = EnumListField(FavoritesInclude, allow_all=True, missing=None)

        @validates_schema
        def validate_user_account(self, data, **kwargs):
            if data["user"] and data["account"]:
                raise ValidationError("Only one of 'user', 'account' should be filled.")

    class Response(Schema):
        class Item(Schema):
            class Account(Schema):
                class Device(Schema):
                    id = fields.Integer()
                    is_active = fields.Boolean(attribute="status")
                    os = fields.String()
                    expo_token = fields.String(attribute="token")

                class Settings(Schema):
                    id = fields.Integer()
                    type = fields.String()
                    version = fields.String()
                    data = fields.Dict()

                account_id = fields.Integer(attribute="id")
                user_id = fields.String()
                devices = fields.List(fields.Nested(Device))
                settings = fields.Nested(Settings, attribute="settings_item")

            entity_type = fields.String()
            entity_id = fields.String()
            accounts = fields.List(fields.Nested(Account))

        data = fields.List(fields.Nested(Item))