from collections import OrderedDict

from marshmallow import fields, validate, validates_schema, post_load

from apollo_utils.core.constants import TOP_MARKETS
from apollo_utils.core.constants.market import Market, DELPHI_GLOBAL_MARKET
from apollo_utils.core.legacy.constants.core import APPLE_MARKET_US
from apollo_utils.service.schemas.fields.list import SplitUniqueListField
from apollo_utils.service.schemas.fields.market import MarketField, DelphiMarketField
from apollo_utils.service.utils.market import fix_country_code_worldwide


class MarketNoneMixin:
    market = fields.String(validate=validate.Length(max=10, min=2), load_default=None)


class MarketUsMixin:
    market = fields.String(validate=validate.Length(max=10, min=2), load_default=APPLE_MARKET_US)


class MarketRequiredMixin:
    market = fields.String(validate=validate.Length(max=10, min=2), required=True)


class MarketListTopMixin:
    markets_list = SplitUniqueListField(
        fields.String(validate=validate.Length(max=10, min=2)), data_key="market", load_default=TOP_MARKETS
    )


class MarketListRequiredMixin:
    market_list = SplitUniqueListField(
        fields.String(validate=validate.Length(max=10, min=2)), data_key="market", required=True
    )


class MarketsListNoneMixin:
    markets_list = SplitUniqueListField(
        fields.String(validate=validate.Length(max=10, min=2)), data_key="market", load_default=None,
    )


class MarketRequiredGlobalWWMixin:
    """Market without default value with global/_gl to worldwide transformation."""

    market = MarketField(validate=validate.Length(max=10, min=2), gl=Market.WORLDWIDE, required=True)


class MarketDefaultWWGlobalWWMixin:
    """Market with default worldwide value with global/_gl to worldwide transformation."""

    market = MarketField(validate=validate.Length(max=10, min=2), gl=Market.WORLDWIDE, missing=Market.WORLDWIDE)


class MarketDefaultGlobalMixin:
    """Market with 'global' value as default."""

    market = fields.String(validate=validate.Length(max=10, min=2), missing=Market.GLOBAL)


class MarketListOptionalMixin:
    markets_list = SplitUniqueListField(
        MarketField(validate=validate.Length(max=10, min=2), gl=Market.GL), data_key="market", missing=[]
    )


class MarketListAllMixin:
    markets_list = SplitUniqueListField(
        MarketField(validate=validate.Length(max=10, min=2)), data_key="market", missing=[Market.ALL]
    )

    @validates_schema
    def check_markets_list(self, data, **kwargs):
        markets_list = data.get("markets_list")
        if Market.ALL in markets_list:
            data["markets_list"] = None
            return data


class DelphiMarketMixin:
    """Market value mixin."""

    market = DelphiMarketField(missing="", description="Market code value, leave empty for all.")


class DelphiDefaultMarketMixin:
    """Market value mixin."""

    market = DelphiMarketField(missing=DELPHI_GLOBAL_MARKET, description="Market code value, leave empty for all.")


class DelphiMarketNoneMixin:
    """Market value mixin."""

    market = DelphiMarketField(missing=None, description="Market code value, leave empty for all.")


class DelphiRequiredMarketMixin:
    """Market value mixin."""

    market = DelphiMarketField(required=True, description="Market code value.")


class DelphiMarketsListMixin:
    """Markets list value mixin."""

    markets = SplitUniqueListField(DelphiMarketField, validate=validate.Length(min=1), required=True)

    @post_load
    def check_market_order(self, data, **kwargs):
        ordered_dict = OrderedDict.fromkeys(data["markets"])
        data["markets"] = list(ordered_dict.keys())
        return data


class MarketListAllAndGlobalReplaceMixin:
    markets_list = SplitUniqueListField(
        MarketField(validate=validate.Length(max=10, min=2)), data_key="market", missing=[]
    )

    @validates_schema
    def check_markets_list(self, data, **kwargs):
        markets_list = data.get("markets_list")
        if Market.ALL in markets_list:
            data["markets_list"] = None
        elif any([gl in markets_list for gl in Market.ALL_GLOBAL]):
            data["markets_list"] = fix_country_code_worldwide(data["markets_list"], Market.GLOBAL)
        return data


def get_market_mixin(min_len: int = 2, max_len: int = 10, required: bool = True, **kwargs):

    class MarketMixin:
        market = fields.String(validate=validate.Length(max=max_len, min=min_len), required=required, **kwargs)
    return MarketMixin


def convert_any_global_mixin(value_key: str, value_to_set):
    """Convert any [_gl, global, worldwide] value that represents Apollo global market to 'worldwide'

    Args:
        value_key: field name that needs to be checked for global value(s)
        value_to_set: Value to set
    """
    class MarketGlobalToWorldwideConvertMixin:

        @post_load
        def convert_market(self, data, *args, **kwargs):
            data[value_key] = fix_country_code_worldwide(data[value_key], value_to_set)
            return data

    return MarketGlobalToWorldwideConvertMixin