import datetime
from typing import List

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

from tests.api.playlists.v1.responses.base.objects_structure import TrackInPlaylistBasePlaylistImage
from tests.api.playlists.v1.responses.constants import DSP_PLAYLISTS_ID_PREFIX, PlaylistUriPrefix

fake = Faker()


def add_dsp_prefix(dsp: DSP, value, delimiter: str = "_") -> str:
    return f"{dsp.value}{delimiter}{value}"


def remove_dsp_prefix(dsp: DSP, value: str):
    if value.startswith(dsp.value):
        return value[len(dsp.value)+1:]


def get_fake_playlist_id(range_length: int = 4) -> str:
    """Get fake playlist_id
    fake.hexify() returns a str value with length of 4 random values (numbers and letters)

    Args:
        range_length: range to add values of fake.hexify() together to get fake playlist_id

    Returns:
        str of range_length * 4
    """

    return "".join([fake.hexify() for _ in range(range_length+1)])


def get_fake_isrc() -> str:
    """Get fake ISRC"""
    return "".join([fake.hexify() for _ in range(3)]).upper()


def get_fake_word() -> str:
    """Get first fake word from random text"""
    return fake.text().split()[0]


def get_fake_track_id(dsp: DSP) -> str:
    return str(fake.random_int(min=1000000000, max=9999999999) if dsp.value == DSP.APPLE.value
               else f"{fake.hexify()}{fake.hexify()}{fake.hexify()}")


def get_fake_image():
    return TrackInPlaylistBasePlaylistImage(
        uri=fake.image_url()
    )


def get_playlist_id(dsp: DSP, playlist_id: str, with_dsp_prefix: bool = False) -> str:
    """Extend existing playlist_id or create fake one

    Args:
        dsp: DSP
        playlist_id: string representation of a playlist_id
        with_dsp_prefix
    """

    playlist_id_prefix_by_dsp = DSP_PLAYLISTS_ID_PREFIX[dsp.value]

    def return_value(value: str, with_dsp_prefix: bool, playlist_prefix: str = ""):
        if with_dsp_prefix:
            return f"{dsp.value if dsp.value not in value else ''}" \
                   f"{playlist_prefix if playlist_prefix not in value else ''}" \
                   f"{value}"
        return value

    if playlist_id:
        return return_value(playlist_id, with_dsp_prefix, playlist_id_prefix_by_dsp)

    fake_playlist_id = "".join([fake.hexify() for _ in range(5)])
    return return_value(fake_playlist_id, with_dsp_prefix, playlist_id_prefix_by_dsp)


def get_playlist_uri(dsp: DSP, playlist_id: str, country_code: str = None):
    return PlaylistUriPrefix[dsp].format(country_code) + playlist_id


def get_tip_fake_dates():
    date = datetime.date.today()
    earliest_position_date_time = date - datetime.timedelta(days=fake.random_int(min=50, max=100))
    last_added_date_time = fake.date_between_dates(earliest_position_date_time, date)
    latest_position_date_time = fake.date_between_dates(last_added_date_time, date)

    fake_dates = [date, earliest_position_date_time, last_added_date_time, latest_position_date_time]
    return [i.isoformat() for i in fake_dates]


def get_single_fake_date():
    return (datetime.date.today() - datetime.timedelta(days=fake.random_int(min=50, max=100))).isoformat()


def get_num_days_on(added_date: datetime, current_date: datetime) -> int:
    """Calculate num_days between two passed dates"""
    return (current_date - added_date).days


def get_tip_fake_streaming_info(streams_market: List[str] = None):
    """Get track in playlist fake streaming info"""
    streams_market_list = streams_market or ["worldwide"]

    def get_streams_value(min_v: int =1, step=100):
        if fake.boolean(95) and min_v:
            return fake.random_int(min_v, min_v+step)
        return

    result = dict()
    for market_name in streams_market_list:
        market_1_isrc_in_playlist = get_streams_value()
        market_7_isrc_in_playlist = get_streams_value(market_1_isrc_in_playlist)
        market_14_isrc_in_playlist = get_streams_value(market_7_isrc_in_playlist)
        market_1_playlist = get_streams_value(market_14_isrc_in_playlist)
        market_7_playlist = get_streams_value(market_1_playlist)
        market_14_playlist = get_streams_value(market_7_playlist)
        streams_by_market = {
            market_name: {
                "1": {
                    "isrc_in_playlist": market_1_isrc_in_playlist,
                    "playlist": market_1_playlist
                },
                "7": {
                    "isrc_in_playlist": market_7_isrc_in_playlist,
                    "playlist": market_14_playlist
                },
                "14": {
                    "isrc_in_playlist": market_14_isrc_in_playlist,
                    "playlist": fake.random_int()
                }
            }
        }

        result.update(streams_by_market)
    return result


def get_expected_trend(item, is_top, is_personalised):
    result = None
    if is_top and not is_personalised:
        result = item["trend"]
    return result