import pytest
from datetime import date, timedelta
from flask import url_for
from http import HTTPStatus

from tests.legacy.spotify import factories


@pytest.mark.parametrize(
    "params,status,expected_result",
    (
        ({}, HTTPStatus.BAD_REQUEST, {}),
        (
            {"id": "pl_2,pl_3"},
            HTTPStatus.OK,
            {
                "playlists": [
                    {
                        "country_code": "worldwide",
                        "image_url": "https://dhfsk7jl2g0km.cloudfront.net/playlist-pl_2.jpeg",
                        "is_personalized": False,
                        "link": "url_2",
                        "name": "Pl2",
                        "owner": {
                            "account_id": "user3",
                            "account_name": "User3",
                            "category_id": 3,
                            "category_name": "Cat3",
                            "country_code": "worldwide",
                        },
                        "playlist_id": "pl_2",
                    },
                    {
                        "country_code": "us",
                        "image_url": "https://dhfsk7jl2g0km.cloudfront.net/playlist-pl_3.jpeg",
                        "is_personalized": True,
                        "link": "url_3",
                        "name": "Pl3",
                        "owner": {
                            "account_id": "user4",
                            "account_name": "User4",
                            "category_id": 4,
                            "category_name": "Cat4",
                            "country_code": "us",
                        },
                        "playlist_id": "pl_3",
                    },
                ],
            },
        ),
        (
            {"id": "pl_1,pl_unknown"},
            HTTPStatus.OK,
            {
                "playlists": [
                    {
                        "country_code": "worldwide",
                        "image_url": "https://dhfsk7jl2g0km.cloudfront.net/playlist-pl_1.jpeg",
                        "is_personalized": True,
                        "link": "url_1",
                        "name": "Pl1",
                        "owner": {
                            "account_id": "user2",
                            "account_name": "User2",
                            "category_id": 2,
                            "category_name": "Cat2",
                            "country_code": "us",
                        },
                        "playlist_id": "pl_1",
                    },
                ],
            },
        ),
    ),
)
def test_playlists(params, status, expected_result, db_session, user_id, client, patch_auth_user):
    patch_auth_user(user_id)

    factories.BuzzUserFactory.create(
        id=1, user_name="spotify", display_name="Spotify", category_id=5, country_code="_gl"
    )
    factories.BuzzCategoryFactory.create(id=5, name="SpotifyC")
    factories.BuzzUserFactory.create(id=2, user_name="sony", display_name="Sony", category_id=1, country_code="global")
    factories.BuzzCategoryFactory.create(id=1, name="SonyC")
    for index in range(3, 8):
        factories.BuzzUserFactory.create(
            id=index,
            user_name=f"user{index - 1}",
            display_name=f"User{index - 1}",
            category_id=index - 1 if index < 6 else None,
            country_code="us" if index % 2 else None,
        )
    for index in range(2, 5):
        factories.BuzzCategoryFactory.create(id=index, name=f"Cat{index}")
    for index in range(1, 16, 2):
        factories.SpotifyPersonalizedPlaylistFactory.create(playlist_id=f"pl_{index}")
    playlist_country_code_list = (None, "", "_gl", "us", "gb")
    playlist_owner_list = ("sony", "user2", "user3", "user4", "spotify")
    for index in range(1, 20):
        category_id = index % 5 + 1
        owner = playlist_owner_list[index % 5]
        playlist_id = f"pl_{index}"
        factories.SpotifyPlaylistFactory.create(
            id=playlist_id,
            name=f"Pl{index}",
            country_code=playlist_country_code_list[index % 5],
            uri=f"url_{index}",
            user_name=owner,
            buzz_category_id=category_id,
        )

    response = client.get(url_for("playlists_spotify.get_playlists", **params))

    assert response.status_code == status
    if status == HTTPStatus.OK:
        assert response.json == expected_result


@pytest.mark.parametrize(
    "params,status,expected_result",
    (
        ({"market": "us"}, HTTPStatus.OK, [{"id": "pl_0", "name": "pl_name_0"}]),
        (
            {"market": "global"},
            HTTPStatus.OK,
            [
                {"id": "pl_0", "name": "pl_name_0"},
                {"id": "pl_1", "name": "pl_name_1"},
                {"id": "pl_2", "name": "pl_name_2"},
                {"id": "pl_3", "name": "pl_name_3"},
                {"id": "pl_4", "name": "pl_name_4"},
            ],
        ),
    ),
)
def test_playlists_top_weekly(params, status, expected_result, db_session, user_id, client, patch_auth_user):
    patch_auth_user(user_id)

    today = date.today().isoformat()

    for i, data in enumerate(((today, "us"), (today, "gb"), (today, "au"), (today, "ca"), (today, "global"))):
        factories.SpotifyWeeklyTopPlaylistLatestFactory.create(
            playlist_id=f"pl_{i}", date=data[0], country_code=data[1]
        )
        factories.SpotifyPlaylistFactory.create(id=f"pl_{i}", name=f"pl_name_{i}")

    response = client.get(url_for("playlists_spotify.get_playlists_top_weekly", **params))

    assert response.status_code == status
    if status == HTTPStatus.OK:
        assert list(sorted(response.json, key=lambda i: i["id"])) == expected_result


@pytest.mark.parametrize(
    "body,status,expected_result",
    (
        ({}, HTTPStatus.BAD_REQUEST, {}),
        (
            {
                "tracks_isrc": {"isrc_2": (date.today() - timedelta(days=10)).isoformat()},
                "playlist_ids": ["pl_1", "pl_2"],
            },
            HTTPStatus.OK,
            [
                {
                    "entry_date": (date.today() - timedelta(days=10)).isoformat(),
                    "exit_date": date.today().isoformat(),
                    "isrc": "isrc_2",
                    "playlist_id": "pl_1",
                },
                {
                    "entry_date": (date.today() - timedelta(days=5)).isoformat(),
                    "exit_date": (date.today() - timedelta(days=2)).isoformat(),
                    "isrc": "isrc_2",
                    "playlist_id": "pl_2",
                },
            ],
        ),
        (
            {
                "tracks_isrc": {"isrc_2": (date.today() - timedelta(days=10)).isoformat()},
                "market": "global",
            },
            HTTPStatus.OK,
            [
                {
                    "entry_date": (date.today() - timedelta(days=10)).isoformat(),
                    "exit_date": date.today().isoformat(),
                    "isrc": "isrc_2",
                    "playlist_id": "pl_1",
                },
                {
                    "entry_date": (date.today() - timedelta(days=5)).isoformat(),
                    "exit_date": (date.today() - timedelta(days=2)).isoformat(),
                    "isrc": "isrc_2",
                    "playlist_id": "pl_2",
                },
            ],
        ),
        (
            {
                "tracks_isrc": {"isrc_1": (date.today() - timedelta(days=7)).isoformat()},
                "market": "de",
            },
            HTTPStatus.OK,
            [
                {
                    "entry_date": (date.today() - timedelta(days=10)).isoformat(),
                    "exit_date": date.today().isoformat(),
                    "isrc": "isrc_1",
                    "playlist_id": "pl_1",
                },
                {
                    "entry_date": (date.today() - timedelta(days=5)).isoformat(),
                    "exit_date": (date.today() - timedelta(days=3)).isoformat(),
                    "isrc": "isrc_1",
                    "playlist_id": "pl_2",
                },
            ],
        ),
    ),
)
def test_playlists_previous_top_dates(body, status, expected_result, db_session, user_id, client, patch_auth_user):
    patch_auth_user(user_id)

    today = date.today()

    for index, (playlist, isrc, market, entry_date, exit_date) in enumerate(
        (
            (1, 1, "us", (today - timedelta(days=10)), today),
            (1, 2, "uk", (today - timedelta(days=10)), today),
            (1, 3, "de", (today - timedelta(days=20)), (today - timedelta(days=5))),
            (2, 1, "de", (today - timedelta(days=5)), (today - timedelta(days=3))),
            (2, 2, "us", (today - timedelta(days=5)), (today - timedelta(days=2))),
            (2, 3, "uk", (today - timedelta(days=10)), (today - timedelta(days=1))),
        ),
        1,
    ):
        factories.SpotifyWeeklyTopPlaylistTrackSummaryFactory.create(
            playlist_id=f"pl_{playlist}",
            isrc=f"isrc_{isrc}",
            entry_date=entry_date.isoformat(),
            exit_date=exit_date.isoformat(),
        )
        factories.SpotifyWeeklyTopPlaylistLatestFactory.create(
            id=index, playlist_id=f"pl_{playlist}", country_code=market
        )

    response = client.post(url_for("playlists_spotify.get_playlists_previous_top_dates"), json=body)

    assert response.status_code == status
    if status == HTTPStatus.OK:
        assert response.json == expected_result


@pytest.mark.parametrize(
    "params,status,expected_result",
    (
        ({}, HTTPStatus.BAD_REQUEST, {}),
        ({"playlist_ids": ["pl_not_existed"], "market": "fake"}, HTTPStatus.OK, []),
        (
            {"playlist_ids": ["pl_1", "pl_3"], "market": "us"},
            HTTPStatus.OK,
            [{"playlist_id": "pl_3", "streams_latest": 4566}],
        ),
        (
            {"playlist_ids": ["pl_0", "pl_1", "pl_2", "pl_3", "pl_4", "pl_5", "pl_6"], "market": "us"},
            HTTPStatus.OK,
            [{"playlist_id": "pl_0", "streams_latest": 10200}, {"playlist_id": "pl_3", "streams_latest": 4566}],
        ),
        (
            {"playlist_ids": ["pl_0", "pl_1", "pl_2", "pl_3", "pl_4", "pl_5", "pl_6"], "market": "global"},
            HTTPStatus.OK,
            [
                {"playlist_id": "pl_0", "streams_latest": 10200},
                {"playlist_id": "pl_1", "streams_latest": 2401},
                {"playlist_id": "pl_2", "streams_latest": 353},
                {"playlist_id": "pl_3", "streams_latest": 4566},
                {"playlist_id": "pl_4", "streams_latest": 53412},
                {"playlist_id": "pl_5", "streams_latest": 5644},
                {"playlist_id": "pl_6", "streams_latest": 15000},
            ],
        ),
    ),
)
def test_playlists_streams_weekly(params, status, expected_result, db_session, user_id, client, patch_auth_user):
    patch_auth_user(user_id)

    [
        factories.SpotifyPlaylistStreamSummaryFactory.create(
            playlist_id=f"pl_{number}", market=data[0], streams_7_days=data[1]
        )
        for number, data in enumerate(
            (("us", 10200), ("gb", 2401), ("au", 353), ("us", 4566), ("ca", 53412), ("au", 5644), ("global", 15000))
        )
    ]

    response = client.get(url_for("playlists_spotify.get_playlists_streams_weekly", **params))

    assert response.status_code == status
    if status == HTTPStatus.OK:
        assert response.json == expected_result