from typing import List

from apollo_main_db.apollo.models import MarketRegionTypeEnum
from apollo_main_db.spotify.models import MarketRankTypeEnum, ViewPlaylistTypeEnum
from tests.legacy.apollo_api.factories import ApolloMarketFactory, ApolloMarketRegionFactory, \
    ApolloRegionDetailFactory, ApolloRegionFactory
from tests.legacy.spotify.factories import SpotifyMarketRankFactory, SpotifyPlaylistFactory, SpotifyViewPlaylistFactory


def generate_view_playlists(
    playlist_data: List[dict],
    record_type: ViewPlaylistTypeEnum.HH,
    market_code_field: str = "market",
    playlist_id_field: str = "playlist_id",
    playlist_name_field: str = "name",
    region_name_field: str = "region",
    rank_field: str = "rank",
    last_date_field: str = "last_date",
    last_added_ts_field: str = "last_added",
    add_extra: bool = True,
    region_code_template: str = None,
):
    created_market_list = []
    created_region_list = []
    for index, item in enumerate(playlist_data, 1):
        market_code = item[market_code_field]
        new_market = market_code not in created_market_list
        if new_market:
            ApolloMarketFactory.create(id=index, code=market_code, name=market_code.upper())
            if rank_field in item:
                SpotifyMarketRankFactory.create(
                    type=MarketRankTypeEnum.NMF if record_type == ViewPlaylistTypeEnum.NMF else MarketRankTypeEnum.HH,
                    market_code=item[market_code_field],
                    rank=item[rank_field],
                )
            created_market_list.append(market_code)
        ApolloMarketFactory.create(id=(index + 200), code=f"mm_{index}")
        if add_extra:
            ApolloMarketFactory.create(id=(index + 400), code=f"mmm_{index}")
            SpotifyMarketRankFactory.create(
                type=MarketRankTypeEnum.NMF if record_type == ViewPlaylistTypeEnum.NMF else MarketRankTypeEnum.HH,
                market_code=f"mm_{index}",
                rank=(20 + index),
            )
            SpotifyMarketRankFactory.create(
                type=MarketRankTypeEnum.NMF if record_type == ViewPlaylistTypeEnum.NMF else MarketRankTypeEnum.HH,
                market_code=f"mmm_{index}",
                rank=(40 + index),
            )
        SpotifyMarketRankFactory.create(type=MarketRankTypeEnum.GENERAL, market_code=f"mm_{index}", rank=(20 + index))
        SpotifyViewPlaylistFactory.create(
            type=record_type,
            playlist_id=item[playlist_id_field],
            market_code=item[market_code_field],
            **({"last_date": item[last_date_field]} if last_date_field in item else {}),
            **({"last_added_ts": item[last_added_ts_field]} if last_added_ts_field in item else {}),
        )
        if add_extra:
            SpotifyViewPlaylistFactory.create(
                type=record_type,
                playlist_id=f"pl__{index}",
                market_code=f"mm_{index}",
                **({"last_date": item[last_date_field]} if last_date_field in item else {}),
                **({"last_added_ts": item[last_added_ts_field]} if last_added_ts_field in item else {}),
            )
            SpotifyViewPlaylistFactory.create(
                type=record_type,
                playlist_id=f"pl___{index}",
                market_code=f"mmm_{index}",
                **({"last_date": item[last_date_field]} if last_date_field in item else {}),
                **({"last_added_ts": item[last_added_ts_field]} if last_added_ts_field in item else {}),
            )
        SpotifyViewPlaylistFactory.create(
            type=ViewPlaylistTypeEnum.GTP,
            playlist_id=f"pl__{index}",
            market_code=f"mm_{index}",
            **({"last_date": item[last_date_field]} if last_date_field in item else {}),
            **({"last_added_ts": item[last_added_ts_field]} if last_added_ts_field in item else {}),
        )
        if playlist_name_field in item:
            SpotifyPlaylistFactory.create(id=item[playlist_id_field], name=item[playlist_name_field])
            SpotifyPlaylistFactory.create(id=f"pl__{index}", name=f"PL__{index}")
            if add_extra:
                SpotifyPlaylistFactory.create(id=f"pl___{index}", name=f"PL___{index}")
        if region_name_field in item:
            region_code = (
                region_code_template.format(index) if region_code_template else item[region_name_field][:2].lower()
            )
            new_region = region_code not in created_region_list
            if new_region:
                ApolloRegionFactory.create(code=region_code, name=item[region_name_field])
                ApolloRegionDetailFactory.create(
                    type=MarketRegionTypeEnum.NMF
                    if record_type == ViewPlaylistTypeEnum.NMF
                    else MarketRegionTypeEnum.HH,
                    code=region_code,
                    rank=index,
                )
                created_region_list.append(region_code)
            if new_market or new_region:
                ApolloMarketRegionFactory.create(
                    type=(
                        MarketRegionTypeEnum.NMF if record_type == ViewPlaylistTypeEnum.NMF else MarketRegionTypeEnum.HH
                    ),
                    market_code=item[market_code_field],
                    region_code=region_code,
                )
            ApolloRegionFactory.create(code=f"r_{index}", name=f"reg_n_{index}")
            if add_extra:
                ApolloMarketRegionFactory.create(
                    type=(
                        MarketRegionTypeEnum.NMF if record_type == ViewPlaylistTypeEnum.NMF else MarketRegionTypeEnum.HH
                    ),
                    market_code=f"mm_{index}",
                    region_code=region_code,
                )
                ApolloMarketRegionFactory.create(
                    type=(
                        MarketRegionTypeEnum.NMF if record_type == ViewPlaylistTypeEnum.NMF else MarketRegionTypeEnum.HH
                    ),
                    market_code=f"mmm_{index}",
                    region_code=f"r_{index}",
                )
            ApolloMarketRegionFactory.create(
                type=MarketRegionTypeEnum.GENERAL, market_code=f"mm_{index}", region_code=f"r_{index}"
            )