import datetime
from dataclasses import asdict
from typing import List

from apollo_utils.core.constants.dsp import DSP
from faker import Faker

from tests.api.playlists.v1.responses.base.common import get_track_in_playlist_nested_playlist
from tests.api.playlists.v1.responses.base.objects_structure import TrackInPlaylistBase
from tests.api.playlists.v1.responses.helpers import get_fake_isrc, get_playlist_id, get_tip_fake_dates, \
    get_num_days_on, add_dsp_prefix, get_fake_track_id, get_tip_fake_streaming_info


fake = Faker()


def get_track_in_playlist(
        dsp: DSP,
        isrc: str = None,
        playlist_id: str = None,
        date: str = None,
        country_code: str = None,
        playlist_is_personalised: bool = False,
        earliest_position_date_time: str = None,
        last_added_date_time: str = None,
        latest_position_date_time: str = None,
        streams_country_code: List[str] = None,
        with_playlist: bool = False,
        with_num_tracks: bool = False,
        with_streams_for_period: bool = False,
        amazon_playlist_id: str = None,
        *args,
        **kwargs
):
    """Get track in playlists with includes based on passed params partially filled with fake data """
    isrc = isrc or get_fake_isrc()
    playlist_id = playlist_id or get_playlist_id(dsp=dsp, playlist_id=playlist_id)
    current, previous, earliest_position = fake.random_int(max=99), fake.random_int(max=99), fake.random_int(max=99)
    trend = current-previous

    num_tracks = fake.random_int(min=99, max=199)
    country_code = country_code or fake.country_code("alpha-2").lower()
    is_personalised = playlist_is_personalised or fake.boolean(20)
    fake_date, fake_earliest_position_date_time, fake_last_added_date_time, fake_latest_position_date_time = \
        get_tip_fake_dates()
    num_days_on = get_num_days_on(
        datetime.date.fromisoformat(fake_last_added_date_time),
        datetime.date.fromisoformat(date or fake_date)
    )

    return TrackInPlaylistBase(
        dsp=dsp.value,
        isrc=isrc,
        playlist_id=add_dsp_prefix(dsp, playlist_id),
        date=date or fake_date,
        current=current,
        previous=previous + 1,
        previous_position_change_14_days=previous,
        trend=trend,
        num_tracks=num_tracks if with_num_tracks else None,
        is_top_track_for_isrc=fake.boolean(65),
        dsp_track_id=get_fake_track_id(dsp),
        num_days_on=num_days_on,
        earliest_position=earliest_position,
        earliest_position_date_time=earliest_position_date_time or fake_earliest_position_date_time,
        last_added_date_time=last_added_date_time or fake_last_added_date_time,
        latest_position_date_time=latest_position_date_time or fake_latest_position_date_time,
        playlist=get_track_in_playlist_nested_playlist(
            dsp=dsp,
            playlist_id=playlist_id,
            num_tracks=num_tracks,
            country_code=country_code,
            is_personalised=is_personalised,
            amazon_playlist_id=amazon_playlist_id
        ) if with_playlist else None,
        streaming_info=get_tip_fake_streaming_info(streams_country_code) if with_streams_for_period else None,
        trend_change_14_days=trend,
    )


def get_delphi_public_track_positions_playlists_response(
        dsp: DSP,
        items_count: int = 1,
        with_meta_owner_categories: bool = False,
        country_code=None,
        **kwargs,
):
    if country_code is None:
        country_code = ["us", "gb", "ca", "de", "fr"]

    result = []
    categories = {}
    for _ in range(items_count):
        for i in country_code:
            tip = asdict(get_track_in_playlist(dsp=dsp, country_code=i, **kwargs))

            if with_meta_owner_categories:
                cat_id = tip["playlist"]["owner"]["owner_category"]["owner_category_id"]
                cat_name = tip["playlist"]["owner"]["owner_category"]["name"]
                tip_category = {
                    "owner_category_id": cat_id,
                    "name": cat_name
                }
                categories[cat_id] = tip_category

            result.append(tip)

    return {
        "items": result,
        "meta": {
            "owner_categories": list(categories.values())
        }
    }


def get_delphi_track_positions_playlists_response(
        dsp: DSP,
        items_count: int = 1,
        country_code=None,
        amazon_playlist_id: str = None,
        **kwargs,
):
    def get_country_code(country_code):
        default_country_codes = ["us", "gb", "ca", "de", "fr"]
        pl_id = kwargs.get("playlist_id", "")
        if dsp.value != DSP.AMAZON.value and (country_code is None or not pl_id):
            return default_country_codes
        if dsp.value == DSP.AMAZON.value:
            group_id, int_country_code = amazon_playlist_id.split(":")
            if "_" in int_country_code:
                int_id, country_code = int_country_code.split("_")
                return [country_code]
        return default_country_codes

    country_code = get_country_code(country_code)

    result = []
    categories = {}
    for _ in range(items_count):
        for i in country_code:
            tip = asdict(
                get_track_in_playlist(
                    dsp=dsp,
                    country_code=i,
                    amazon_playlist_id=amazon_playlist_id,
                    **kwargs
                )
            )

            tip["earliest_position_date"] = tip.pop("earliest_position_date_time")
            tip["last_date_change_14_days"] = tip.pop("latest_position_date_time")
            result.append(tip)

    return {
        "items": result,
        "meta": {
            "owner_categories": list(categories.values())
        }
    }