import pytest
from aiohttp.web import HTTPCreated, HTTPNoContent
from unittest.mock import patch
from server.user_service.exceptions import UserServiceError

from server.core.helpers import authorization
from tests.constants import (
    GENRES_EXPECTED_DATA,
    COUNTRIES_EXPECTED_DATA,
    GENRES_LIST,
    GENRES_EXPECTED_LIST,
    COUNTRIES_LIST,
    COUNTRIES_EXPECTED_LIST,
    ACCOUNT_RESPONSE,
    EMPTY_DATA_RESPONSE,
    GENRES_RESPONSE_1,
    GENRES_RESPONSE_2,
    GENRES_RESPONSE_3,
    GENRES_USER_SERVICE_RESPONSE_DATA,
    COUNTRIES_RESPONSE_1,
    COUNTRIES_RESPONSE_2,
    COUNTRIES_RESPONSE_3,
    COUNTRIES_USER_SERVICE_RESPONSE_DATA,
    IRRELEVENT_ENTITY_ID,
    IRRELEVANT_ENTITYT_ID_EXPECTED_RESPONSE,
    COUNTRIES_USER_SERVICE_US_RESPONSE_DATA,
    GENRES_USER_SERVICE_ROCK_RESPONSE_DATA,
    USER_SERVICE_ERROR,
    US_EXPECTED_RESPONSE,
    ROCK_EXPECTED_RESPONSE,
)


class TestFavorites:
    @pytest.mark.parametrize(
        "expected_return_data, url",
        [
            (GENRES_EXPECTED_DATA, "/api/dna/genres"),
            (COUNTRIES_EXPECTED_DATA, "/api/dna/countries"),
        ],
    )
    async def test_genres_countries(self, expected_return_data, url, app_client, auth_header):
        response = await app_client.get(url, headers=auth_header)
        assert expected_return_data == await response.json()

    @pytest.mark.parametrize(
        "exppected_empty_list, genres_list, genres_expected_response, url, create_status_code, remove_status_code",
        [
            (
                [],
                GENRES_LIST,
                GENRES_EXPECTED_LIST,
                "/api/dna/favorites/genres",
                HTTPCreated.status_code,
                HTTPNoContent.status_code,
            ),
        ],
    )
    @patch.object(
        authorization,
        "make_request",
        side_effect=[
            ACCOUNT_RESPONSE,
            EMPTY_DATA_RESPONSE,
            ACCOUNT_RESPONSE,
            GENRES_RESPONSE_1,
            ACCOUNT_RESPONSE,
            GENRES_RESPONSE_2,
            ACCOUNT_RESPONSE,
            GENRES_RESPONSE_3,
            ACCOUNT_RESPONSE,
            GENRES_USER_SERVICE_RESPONSE_DATA,
            ACCOUNT_RESPONSE,
            None,
            ACCOUNT_RESPONSE,
            None,
            ACCOUNT_RESPONSE,
            None,
            ACCOUNT_RESPONSE,
            EMPTY_DATA_RESPONSE,
        ],
    )
    async def test_favorites_genres_flow(
        self,
        make_request_mock,
        exppected_empty_list,
        genres_list,
        genres_expected_response,
        url,
        create_status_code,
        remove_status_code,
        app_client,
        auth_header_authorized,
    ):
        response = await app_client.get(url, headers=auth_header_authorized)
        assert exppected_empty_list == await response.json()

        for entity in genres_list:
            put_url = url + "/" + entity
            response = await app_client.put(put_url, headers=auth_header_authorized)
            assert create_status_code == response.status

        response = await app_client.get(url, headers=auth_header_authorized)
        assert genres_expected_response == await response.json()

        for entity in genres_list:
            remove_url = url + "/" + entity
            response = await app_client.delete(remove_url, headers=auth_header_authorized)
            assert remove_status_code == response.status

        response = await app_client.get(url, headers=auth_header_authorized)
        assert exppected_empty_list == await response.json()

    @pytest.mark.parametrize(
        "exppected_empty_list, countries_list, countries_expected_response, url, create_status_code, remove_status_code",
        [
            (
                [],
                COUNTRIES_LIST,
                COUNTRIES_EXPECTED_LIST,
                "/api/dna/favorites/countries",
                HTTPCreated.status_code,
                HTTPNoContent.status_code,
            ),
        ],
    )
    @patch.object(
        authorization,
        "make_request",
        side_effect=[
            ACCOUNT_RESPONSE,
            EMPTY_DATA_RESPONSE,
            ACCOUNT_RESPONSE,
            COUNTRIES_RESPONSE_1,
            ACCOUNT_RESPONSE,
            COUNTRIES_RESPONSE_2,
            ACCOUNT_RESPONSE,
            COUNTRIES_RESPONSE_3,
            ACCOUNT_RESPONSE,
            COUNTRIES_USER_SERVICE_RESPONSE_DATA,
            ACCOUNT_RESPONSE,
            None,
            ACCOUNT_RESPONSE,
            None,
            ACCOUNT_RESPONSE,
            None,
            ACCOUNT_RESPONSE,
            EMPTY_DATA_RESPONSE,
        ],
    )
    async def test_favorites_countries_flow(
        self,
        make_request_mock,
        exppected_empty_list,
        countries_list,
        countries_expected_response,
        url,
        create_status_code,
        remove_status_code,
        app_client,
        auth_header_authorized,
    ):
        response = await app_client.get(url, headers=auth_header_authorized)
        assert exppected_empty_list == await response.json()

        for entity in countries_list:
            put_url = url + "/" + entity
            response = await app_client.put(put_url, headers=auth_header_authorized)
            assert create_status_code == response.status

        response = await app_client.get(url, headers=auth_header_authorized)
        assert countries_expected_response == await response.json()

        for entity in countries_list:
            remove_url = url + "/" + entity
            response = await app_client.delete(remove_url, headers=auth_header_authorized)
            assert remove_status_code == response.status

        response = await app_client.get(url, headers=auth_header_authorized)
        assert exppected_empty_list == await response.json()

    @pytest.mark.parametrize(
        "url, irrelevant_entity_id, method, expected_return_data, entity_type",
        [
            (
                "/api/dna/favorites/genres",
                f"/{IRRELEVENT_ENTITY_ID}",
                "put",
                IRRELEVANT_ENTITYT_ID_EXPECTED_RESPONSE,
                "genres",
            ),
            (
                "/api/dna/favorites/countries",
                f"/{IRRELEVENT_ENTITY_ID}",
                "put",
                IRRELEVANT_ENTITYT_ID_EXPECTED_RESPONSE,
                "countries",
            ),
            (
                "/api/dna/favorites/genres",
                f"/{IRRELEVENT_ENTITY_ID}",
                "delete",
                IRRELEVANT_ENTITYT_ID_EXPECTED_RESPONSE,
                "genres",
            ),
            (
                "/api/dna/favorites/countries",
                f"/{IRRELEVENT_ENTITY_ID}",
                "delete",
                IRRELEVANT_ENTITYT_ID_EXPECTED_RESPONSE,
                "countries",
            ),
        ],
    )
    async def test_favorites_irrelevant_entity_id(
        self, url, irrelevant_entity_id, method, expected_return_data, entity_type, app_client, auth_header_authorized
    ):
        end_url = url + irrelevant_entity_id
        method_ = getattr(app_client, method)
        response = await method_(end_url, headers=auth_header_authorized)
        assert expected_return_data + entity_type == await response.json()

    @pytest.mark.parametrize(
        "exppected_empty_list, countries_list, us_expeceted_response, url, create_status_code, user_service_error",
        [
            (
                [],
                ["us"],
                US_EXPECTED_RESPONSE,
                "/api/dna/favorites/countries",
                HTTPCreated.status_code,
                USER_SERVICE_ERROR,
            ),
        ],
    )
    @patch.object(
        authorization,
        "make_request",
        side_effect=[
            ACCOUNT_RESPONSE,
            EMPTY_DATA_RESPONSE,
            ACCOUNT_RESPONSE,
            COUNTRIES_RESPONSE_1,
            ACCOUNT_RESPONSE,
            COUNTRIES_USER_SERVICE_US_RESPONSE_DATA,
            ACCOUNT_RESPONSE,
            UserServiceError,
            ACCOUNT_RESPONSE,
            COUNTRIES_USER_SERVICE_US_RESPONSE_DATA,
        ],
    )
    async def test_favorites_non_exist_entity_id_in_favorites_countries(
        self,
        make_request_mock,
        exppected_empty_list,
        us_expeceted_response,
        countries_list,
        url,
        create_status_code,
        user_service_error,
        app_client,
        auth_header_authorized,
    ):
        response = await app_client.get(url, headers=auth_header_authorized)
        assert exppected_empty_list == await response.json()

        for entity_id in countries_list:
            put_url = url + "/" + entity_id
            response = await app_client.put(put_url, headers=auth_header_authorized)
            assert create_status_code == response.status

        response = await app_client.get(url, headers=auth_header_authorized)
        assert us_expeceted_response == await response.json()

        # non-exist entity_id in current favorites list
        remove_url = url + "/" + "ua"
        response = await app_client.delete(remove_url, headers=auth_header_authorized)
        assert user_service_error == await response.json()

        response = await app_client.get(url, headers=auth_header_authorized)
        assert us_expeceted_response == await response.json()

    @pytest.mark.parametrize(
        "exppected_empty_list, genres_list, rock_expeceted_response, url, create_status_code, user_service_error",
        [
            (
                [],
                ["rock"],
                ROCK_EXPECTED_RESPONSE,
                "/api/dna/favorites/genres",
                HTTPCreated.status_code,
                USER_SERVICE_ERROR,
            ),
        ],
    )
    @patch.object(
        authorization,
        "make_request",
        side_effect=[
            ACCOUNT_RESPONSE,
            EMPTY_DATA_RESPONSE,
            ACCOUNT_RESPONSE,
            GENRES_RESPONSE_1,
            ACCOUNT_RESPONSE,
            GENRES_USER_SERVICE_ROCK_RESPONSE_DATA,
            ACCOUNT_RESPONSE,
            UserServiceError,
            ACCOUNT_RESPONSE,
            GENRES_USER_SERVICE_ROCK_RESPONSE_DATA,
        ],
    )
    async def test_favorites_non_exist_entity_id_in_favorites_genres(
        self,
        make_request_mock,
        exppected_empty_list,
        genres_list,
        rock_expeceted_response,
        url,
        create_status_code,
        user_service_error,
        app_client,
        auth_header_authorized,
    ):
        response = await app_client.get(url, headers=auth_header_authorized)
        assert exppected_empty_list == await response.json()

        for entity_id in genres_list:
            put_url = url + "/" + entity_id
            response = await app_client.put(put_url, headers=auth_header_authorized)
            assert create_status_code == response.status

        response = await app_client.get(url, headers=auth_header_authorized)
        assert rock_expeceted_response == await response.json()

        # non-exist entity_id in current favorites list
        remove_url = url + "/" + "rock"
        response = await app_client.delete(remove_url, headers=auth_header_authorized)
        assert user_service_error == await response.json()

        response = await app_client.get(url, headers=auth_header_authorized)
        assert rock_expeceted_response == await response.json()