from datetime import date, timedelta, datetime, time, timezone
from http import HTTPStatus as http_status
from typing import List

import pytest

from server.client.clients.dsp_api import DspApiClient


graph_response_template = {
    "items": [
        {
            "playlist_id": "",
            "coordinates": [],
            "country_code": ""
        },
    ],
    "dates": {
        "start": "",
        "end": ""
    }
}


def _get_api_delphi_track_positions_playlists_fake_response(playlist_id: str, *args, **kwargs):
    country_codes = ["us", "de", "gb", "fr", "it"]
    result_items = []
    for c in country_codes:
        single_item = {
                "playlist": {
                    "amazon_playlist_id": f"B08GNX63{c.upper()}",
                    "country_code": c
                }
            }
        result_items.append(single_item)
    return {"items": result_items}


def date_to_timestamp(date_obj: date or datetime, hours: int = 0) -> int:
    if isinstance(date_obj, date):
        date_obj = datetime.combine(date_obj, time(hours, 0), tzinfo=timezone.utc)
    return int(datetime.timestamp(date_obj))


def _get_api_analytics_v1_playlists_streams_graph_fake_response(
        playlist_id: List[str],
        markets: List[str],
        start_date: str,
        end_date: str,
        *args,
        **kwargs
):
    response_items = []
    pl_id = playlist_id[0]
    dates = {
        "start": start_date,
        "end": end_date
    }

    start_date, end_date = date.fromisoformat(start_date), date.fromisoformat(end_date)
    days = end_date - start_date

    for country in markets:
        item = {
                "playlist_id": pl_id,
                "coordinates": [
                    {
                        "x": date_to_timestamp(start_date + timedelta(days=i)),
                        "y": 1
                    } for i in range(days.days+1)
                ],
                "country_code": country
            }
        response_items.append(item)

    return {
        "items": response_items,
        "dates": dates
    }


@pytest.mark.parametrize(
    "params,status,call_count",
    (
        (
            {
                "vendor": "amazon",
                "playlist_id": ["B08GNX63NT:100_es"],
                "markets": ["es"],
                "start_date": "2023-04-13",
                "end_date": "2023-04-17"
            }, http_status.OK, 1
        ),
        (
            {
                "vendor": "amazon",
                "playlist_id": ["B08GNX63NT:200_es"],
                "markets": ["es", "worldwide"],
                "start_date": "2023-04-14",
                "end_date": "2023-04-18"
            }, http_status.OK, 3
        ),
        (
            {
                "vendor": "amazon",
                "playlist_id": ["B08GNX63NT:300_es"],
                "markets": ["worldwide"],
                "start_date": "2023-04-15",
                "end_date": "2023-04-19"
            }, http_status.OK, 2
        ),
        (
            {
                "vendor": "amazon",
                "playlist_id": ["B08GNX63NT:400_es", "VCFDNX63NT:500_us"],
                "markets": ["worldwide"],
                "start_date": "2023-04-12",
                "end_date": "2023-04-16"
            }, http_status.BAD_REQUEST, 0
        ),
    )
)
async def test_elasticsearch_v1_playlists_search(client, auth, mocker, params, status, call_count):

    async def dsp_mock(*args, **kwargs):
        url = args[0]
        if url == "api/delphi/track-positions/playlists":
            return _get_api_delphi_track_positions_playlists_fake_response(**kwargs["params"])
        return _get_api_analytics_v1_playlists_streams_graph_fake_response(**kwargs["params"])

    dsp_mocker = mocker.patch.object(DspApiClient, "_send_request", side_effect=dsp_mock)

    response = await client.get("/api/v1/playlists/streams/graph/", headers=auth, params=params)

    assert response.status == status
    assert dsp_mocker.call_count == call_count