from http import HTTPStatus
from typing import List
from unittest.mock import AsyncMock

from server.client.clients.apollo_api import ApolloApiClient
from server.client.clients.dsp_api import DspApiClient
from tests.api.playlists.v1.test_playlists import get_delphi_playlists


def get_hot_hits_playlists(market_count: int = 10, region_count: int = 5, with_name: bool = False) -> dict:
    return {
        "items": [
            {
                "code": f"mc{i}",
                "name": f"MaN{i}",
                "position": 5 + 2 * i,
                "playlist_id": f"pl{i}",
                "image_url": f"img{i}",
                "added_days": 40 + i,
                "is_new": i % 4 == 0,
                "position_change": 3 + i,
                "top_market": 30 + i,
                "isrc": f"isrc{i}",
                "previous_position": 2 + i,
                "latest_date": f"2022-11-1{i % 10}",
                "peak_position": 1 + i,
                "entry_date": f"2022-01-2{i % 10}",
                "market": f"Mar{i}",
                "region": f"Reg{i}",
                **({"playlist_name": f"PlN{i}"} if with_name else {}),
            }
            for i in range(1, market_count + 1)
        ],
        "total": 20,
        "positions_avg": 14,
        "positions_top_total": 12,
        "regions": [
            {"name": f"ReN{i}", "code": f"rc{i}", "placements": 10 + i, "total": 40 + i}
            for i in range(1, region_count + 1)
        ],
    }


async def test_get_v1_tracks_playlists_hot_hits_one(mocker, auth, client):
    playlist_count = 10

    async_dsp_mock = AsyncMock(return_value=get_delphi_playlists(count=playlist_count))
    dsp_send_mock = mocker.patch.object(DspApiClient, "_send_request", side_effect=async_dsp_mock)

    async_apollo_mock = AsyncMock(return_value=get_hot_hits_playlists(market_count=playlist_count, with_name=False))
    apollo_send_mock = mocker.patch.object(ApolloApiClient, "_send_request", side_effect=async_apollo_mock)

    response = await client.get("/api/v1/tracks/playlists/hot-hits/", params={"isrc": "AABB11"}, headers=auth)

    assert response.status == HTTPStatus.OK
    apollo_send_mock.assert_called_once()
    dsp_send_mock.assert_called_once()

    response = await response.json()
    assert response == get_hot_hits_playlists(market_count=playlist_count, with_name=True)


def get_playlist(offset: int, limit: int, playlist_type: str, with_name: bool = False) -> List[dict]:
    return [
        {
            "playlist_id": f"pl{i}",
            "market": f"m{i}",
            "rank": 7 + i,
            "region": f"r{i}",
            "playlist_image": f"img{i}",
            **({"playlist_name": f"PlN{i}"} if with_name else {}),
            **({"latest_date": f"2022-12-1{i % 6}"} if playlist_type == "list" else {}),
            **(
                {"entry_date": f"2022-02-2{i % 4 + 2}", "peak_position": 4 + i, "peak_date": f"2022-05-0{i % 7 + 1}"}
                if playlist_type in ("previous", "previous")
                else {}
            ),
            **({"exit_date": f"2022-11-2{i % 5}"} if playlist_type == "previous" else {}),
            **({"position": 8 + i, "trend": i, "is_entry": i % 4 == 0} if playlist_type == "current" else {}),
        }
        for i in range(offset, limit + offset)
    ]


def get_hot_hits_playlists_bulk(playlist_count: int = 10, region_count: int = 5, with_name: bool = False):
    return {
        "items": [
            {
                "isrc": f"AABB{i}",
                "non_featured": get_playlist(7 + i, 3 - i, "non_featured", with_name),
                "previous": get_playlist(4 + i, 4 - i, "previous", with_name),
                "current": get_playlist(1, min(4 + i, 9), "current", with_name),
                "avg_position": 9 + i,
                "current_count": 45 + i,
            }
            for i in range(1, 4)
        ],
        "hot_hits_date": "2022-11-05",
        "outdated": get_playlist(10, 1, "outdated", with_name),
        "playlists": get_playlist(1, 10, "list", with_name),
        "regions": [f"r{i}" for i in range(1, region_count + 1)],
        "playlists_by_markets": {f"m{i}": f"pl{i}" for i in range(1, playlist_count + 1)},
    }


async def test_get_v1_tracks_playlists_hot_hits_bulk(mocker, auth, client):
    playlist_count = 10

    async_dsp_mock = AsyncMock(return_value=get_delphi_playlists(count=playlist_count))
    dsp_send_mock = mocker.patch.object(DspApiClient, "_send_request", side_effect=async_dsp_mock)

    async_apollo_mock = AsyncMock(
        return_value=get_hot_hits_playlists_bulk(playlist_count=playlist_count, with_name=False)
    )
    apollo_send_mock = mocker.patch.object(ApolloApiClient, "_send_request", side_effect=async_apollo_mock)

    response = await client.get(
        "/api/v1/tracks/playlists/hot-hits/bulk/", headers=auth, params={"isrc": "AABB1,AABB2,AABB3"}
    )

    assert response.status == HTTPStatus.OK
    apollo_send_mock.assert_called_once()
    dsp_send_mock.assert_called_once()

    response = await response.json()
    assert response == get_hot_hits_playlists_bulk(playlist_count=playlist_count, with_name=True)