import copy
from dataclasses import dataclass, asdict
from datetime import datetime, timedelta, date
from typing import List, Dict, Any, Tuple, Union

from constants.common import DSP, DELPHI_CHARTS_RESULT_FIELD, BREAKDOWN, CHART_TYPE


def get_chart_id(chart_prefix: str, i: int) -> str:
    return f"{chart_prefix}{i}"


def get_track_id(i):
    return f"track_id_{i}"


def get_isrc(i):
    return f"isrc_{i}"


def get_name(i):
    return f"name_{i}"


def get_image_url(i):
    return f"image_url_{i}"


def get_artist_id(i):
    return f"image_url_{i}"


def get_artist_name(i):
    return f"image_url_{i}"


def get_artists(i: int) -> List[Dict[str, str]]:
    return [{
        "artist_id": get_artist_id(i),
        "name": get_artist_name(i)
    }]


@dataclass
class ChartsMonitoring:
    dsp: str
    chart_id: str
    updated_at: str
    chart_datetime: str
    data: Union[str, None] = None


def get_datatclass_asdict(obj: dataclass) -> Dict[str, str]:
    return asdict(obj)


def create_delphi_data_health_response(
        data_to_process: str, breakdown: str, chart_type: str, data: Dict[str, Dict[str, Any]]
) -> Dict[str, Any]:
    response = {
        data_to_process: {
            breakdown: {
                chart_type: data
            }
        }
    }
    return response


def create_apollo_delphi_responses(
        dsp: DSP,
        start: int = 0,
        length: int = 10,
        updated_at: str = None,
        chart_datetime: str = None,
        max_date: date = date.today(),
        to_update: int = 0,
        data: Union[str, None] = None
) -> Tuple[List[Dict[str, str]], Dict[str, Any]]:

    data_to_process = DELPHI_CHARTS_RESULT_FIELD[dsp]
    breakdown = BREAKDOWN[dsp]
    chart_type = CHART_TYPE[dsp]

    chart_prefix = f"{chart_type}_{breakdown}_" if dsp == DSP.SPOTIFY else f"{chart_type}_"

    apollo = []
    delphi = dict()
    for i in range(start, length):
        monitoring = get_datatclass_asdict(
            ChartsMonitoring(
                dsp=dsp.value,
                chart_id=get_chart_id(chart_prefix, i),
                updated_at=updated_at,
                chart_datetime=chart_datetime if i >= to_update else (max_date - timedelta(days=10)).isoformat(),
                data=data if dsp == DSP.APPLE else None
            )
        )
        apollo.append(monitoring)

        delphi[str(i)] = {"max_date": max_date.isoformat()} if dsp == DSP.SPOTIFY \
            else {"max_date_time": datetime.combine(max_date, datetime.min.time()).isoformat()}

    delphi_response = create_delphi_data_health_response(
        data_to_process, breakdown, chart_type, delphi)

    return apollo, delphi_response


def get_chart_to_process(today: date, data: Union[str, None] = None) -> Tuple[Dict[str, Dict[str, str]], datetime]:
    previous = datetime.fromisoformat((today - timedelta(days=1)).isoformat())
    return {"chart_to_process": {
                "current_updated": today.isoformat(),
                "previous_updated": previous.isoformat(),
                "data": data
            }}, previous


def get_delphi_chart_track(i: int) -> Dict[str, Any]:
    result = {
        "track_id": get_track_id(i),
        "isrc": get_isrc(i),
        "name": get_name(i),
        "image_url": get_image_url(i),
        "artists": get_artists(i)
    }
    return result


def get_delphi_track_position(i: int) -> Dict[str, Any]:
    return {
        "position": i
    }


def get_test_charts_current_previous_tracks_data(length: int = 10, split: int = 2):
    result = []
    for i in range(length):
        metrics = get_delphi_track_position(i)
        track = get_delphi_chart_track(i)

        data = {
            "metrics": metrics,
            "public_meta": track
        }

        result.append(data)

    previous = copy.deepcopy(result[split:])

    return result[:length-split], previous


def get_test_track_items(tracks):
    return {
        "items": tracks
    }


def get_test_moves(data, position_change: int):
    for item in data:
        position = item["metrics"]["position"]
        item["metrics"]["position"] = position + position_change
    return data