"""Job unit tests."""

import math
from datetime import datetime, timedelta
from typing import Dict

import pytest
import pytz
import requests_mock
from apollo_main_db.apollo.models import ApolloGlobalTrackPrioritiesHistory
from apollo_main_db.spotify.models import ViewPlaylistTypeEnum
from sqlalchemy.orm import joinedload

import config
from dsp_api import get_playlist_tracks
from index import main
from tests.factories import (ApolloGlobalTrackPrioritiesHistoryFactory, ApolloGlobalTrackPrioritiesHistoryTrackFactory,
                             SpotifyViewPlaylistFactory)


def db_tracks(prefix: int, count: int) -> Dict[str, str]:
    return {f"track_0000000000000{prefix}_{i}": f"isrc_00{prefix}_{i}" for i in range(count)}


def db_paged_tracks(page_count: int, page_size: int, total_count: int) -> Dict[str, str]:
    result = {}
    for i in range(page_count):
        result.update(db_tracks(i, page_size if i < page_count - 1 else total_count - page_size * i))
    return result


def delphi_tracks(prefix: int, count: int, has_next: bool = False) -> dict:
    return {
        "items": [{"track_id": track_id, "isrc": isrc} for track_id, isrc in db_tracks(prefix, count).items()],
        "next": has_next,
    }


@pytest.mark.parametrize("page_size,total_count", ((4, 10), (4, 12), (8, 31)))
@requests_mock.Mocker(kw="requests_mocker")
def test_delphi_pagination(page_size, total_count, **kwargs):
    """Test for main.

    """
    playlist_id = "pl_id_1"

    config.DSPAPI.PAGE_SIZE = page_size
    requests_mocker = kwargs["requests_mocker"]
    page_count = math.ceil(total_count / page_size)
    for i in range(page_count):
        not_last_page = i < page_count - 1
        requests_mocker.register_uri(
            "GET",
            f"{config.DSPAPI.HOST}/api/delphi/public/track-positions/playlists/current-tracklist?"
            + f"offset={page_size * i}&limit={page_size}&playlist_id=spotify_{playlist_id}",
            json=delphi_tracks(i, page_size if not_last_page else total_count - page_size * i, not_last_page),
        )

    result = get_playlist_tracks(playlist_id)

    assert result == db_paged_tracks(page_count, page_size, total_count)


@pytest.mark.parametrize(
    "type_count,today_history_count,yesterday_history_count,api_track_count,db_track_count,correct_playlists",
    (
        (4, 0, 4, 6, 0, True),
        (4, 2, 4, 6, 3, True),
        (4, 0, 4, 6, 0, False),
        (4, 2, 4, 6, 3, False),
        (4, 2, 4, 6, 6, True),
    )
)
@requests_mock.Mocker(kw="requests_mocker")
def test_main(
    type_count,
    today_history_count,
    yesterday_history_count,
    api_track_count,
    db_track_count,
    correct_playlists,
    db_session,
    **kwargs,
):
    """Test for main.

    """
    requests_mocker = kwargs["requests_mocker"]
    date_today = datetime.now(pytz.timezone("EST")).date()
    date_yesterday = date_today - timedelta(days=1)
    type_id_list = list(range(1, type_count + 1))
    playlist_id_list = [str(i) * 22 for i in type_id_list]

    for i in range(type_count):
        SpotifyViewPlaylistFactory.create(category_id=10 + i, playlist_id=f"pl_id_{i}", type=("hh" if i % 2 else "nmf"))
        playlist_id = playlist_id_list[i]
        type_id = type_id_list[i]
        SpotifyViewPlaylistFactory.create(category_id=type_id, playlist_id=playlist_id, type=ViewPlaylistTypeEnum.GTP)
        requests_mocker.register_uri(
            "GET",
            f"{config.DSPAPI.HOST}/api/delphi/public/track-positions/playlists/current-tracklist?"
            + f"offset=0&limit={config.DSPAPI.PAGE_SIZE}&playlist_id=spotify_{playlist_id}",
            json=delphi_tracks(type_id, api_track_count),
        )

    for i in range(yesterday_history_count):
        history_id = 10 + i
        type_id = type_id_list[i]
        ApolloGlobalTrackPrioritiesHistoryFactory.create(
            id=history_id, date=date_yesterday, type_id=type_id, playlist_id=playlist_id_list[i]
        )
        tracks = db_tracks(type_id, api_track_count)
        for j in range(api_track_count):
            ApolloGlobalTrackPrioritiesHistoryTrackFactory.create(
                id=(1000 + i * 10 + j),
                history_id=history_id,
                track_id=list(tracks.keys())[j],
                isrc=list(tracks.values())[j],
            )

    for i in range(today_history_count):
        history_id = 20 + i
        type_id = type_id_list[i]
        playlist_id = playlist_id_list[i] if correct_playlists else chr(96 + i) * 22
        ApolloGlobalTrackPrioritiesHistoryFactory.create(
            id=history_id, date=date_today, type_id=type_id, playlist_id=playlist_id
        )
        tracks = db_tracks(type_id, db_track_count)
        for j in range(db_track_count):
            ApolloGlobalTrackPrioritiesHistoryTrackFactory.create(
                id=(2000 + i * 10 + j),
                history_id=history_id,
                track_id=list(tracks.keys())[j],
                isrc=list(tracks.values())[j],
            )

    main()

    for history_date in (date_yesterday, date_today):
        history_records = (
            db_session.query(ApolloGlobalTrackPrioritiesHistory)
            .options(joinedload(ApolloGlobalTrackPrioritiesHistory.tracks))
            .filter(ApolloGlobalTrackPrioritiesHistory.date == history_date)
            .all()
        )
        assert len(history_records) == type_count
        assert list(zip(type_id_list, playlist_id_list)) == list((r.type_id, r.playlist_id) for r in history_records)

        for history in history_records:
            assert len(history.tracks) == api_track_count
            expected_track_data = db_tracks(history.type_id, api_track_count)
            assert expected_track_data == {t.track_id: t.isrc for t in history.tracks}