import asyncio
from http import HTTPStatus
from typing import List

import pytest

from server.db.models import Account, Base, Device, Event, Favorites, FeedMessage, Message, PushMessage, Settings
from server.db.session import db_session as session_scope
from tests.utils import create_accounts, create_events, create_test_accounts, create_test_messages, set_test_db


@pytest.mark.parametrize(
    "params,headers,expected_status,expected_result",
    (
        ({"user_id": "user2,user3"}, {"X-App-Slug": "app1"}, HTTPStatus.OK, {"items": [2]}),
        ({"user_id": "user3,user4"}, {"X-App-Slug": "app2"}, HTTPStatus.OK, {"items": [3, 4]}),
        (
            {"user_id": "user3,user4", "include": "user_id"},
            {"X-App-Slug": "app2"},
            HTTPStatus.OK,
            {"items": ["user3", "user4"]},
        ),
        ({"id": "2,3"}, {"X-App-Slug": "app1"}, HTTPStatus.OK, {"items": [2]}),
        ({"id": "2", "user_id": "user1"}, {"X-App-Slug": "app1"}, HTTPStatus.OK, {"items": [1, 2]}),
        ({"id": "2,3", "is_active": "true"}, {"X-App-Slug": "app1"}, HTTPStatus.OK, {"items": [2]}),
        ({"id": "2,3", "is_active": "false"}, {"X-App-Slug": "app1"}, HTTPStatus.OK, {"items": []}),
        ({"id": "2,3", "days": "1"}, {"X-App-Slug": "app1"}, HTTPStatus.OK, {"items": [2]}),
        ({"id": "2,3", "days": "3"}, {"X-App-Slug": "app1"}, HTTPStatus.OK, {"items": []}),
    )
)
async def test_get_private_accounts(params, headers, expected_status, expected_result, db_session, client, auth):
    async with session_scope() as session:
        await create_accounts(session)

    headers.update(auth)
    response = await client.get("/private/accounts/", headers=headers, params=params)

    assert response.status == expected_status
    if expected_status != HTTPStatus.OK:
        return
    result = await response.json()
    assert result == expected_result


async def count_records(table_list: List[Base], params_list: List[dict] = None) -> tuple:
    async with session_scope() as session:
        task_list = [
            table.count(session=session, **(params_list[index] if params_list and index < len(params_list) else {}))
            for index, table in enumerate(table_list)
        ]
        return await asyncio.gather(*task_list)


@pytest.mark.parametrize(
    "params,headers,expected_status,expected_result,expected_count",
    (
        (
            {"user_id": "u_1,u_2"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {"items": {"account": [2]}},
            [4, 3, 7, 2, 9, 8, 10, 8, 9],
        ),
        (
            {"user_id": "u_5,u_2", "include": "devices"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {"items": {"account": [2], "devices": [4]}},
            [4, 3, 6, 3, 9, 8, 10, 8, 9],
        ),
        (
            {"id": "2,3,5", "include": "devices"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {"items": {"account": [2, 3], "devices": [4, 6, 7, 8]}},
            [3, 4, 3, 6, 9, 8, 10, 8, 9],
        ),
        (
            {"id": "2,3,5", "include": "devices", "limit": "1"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {"items": {"account": [2], "devices": [4]}},
            [4, 3, 6, 3, 9, 8, 10, 8, 9],
        ),
        ({}, {"X-App-Slug": "app_2"}, HTTPStatus.BAD_REQUEST, {}, []),
    )
)
async def test_delete_private_accounts_active(
    params, headers, expected_status, expected_result, expected_count, db_session, client, auth
):
    async with session_scope() as session:
        await set_test_db(session, with_favorites=True, with_messages=True, inactive_users=[4, 5])

    headers.update(auth)
    response = await client.delete("/private/accounts/", headers=headers, params=params)

    assert response.status == expected_status
    if expected_status != HTTPStatus.OK:
        return

    result = await response.json()
    assert result == expected_result

    record_count = await count_records(
        [Account, Account, Device, Device, Favorites, Settings, Message, FeedMessage, PushMessage],
        [dict(_active_only=True), dict(_active_only=False, is_active=False), dict(status=True), dict(status=False)],
    )
    assert record_count == expected_count


@pytest.mark.parametrize(
    "params,headers,expected_status,expected_result,expected_count",
    (
        ({"id": "2,3,5", "days": "2"}, {"X-App-Slug": "app_2"}, HTTPStatus.BAD_REQUEST, {}, []),
        (
            {"days": "31"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {"items": {"account": [4, 5], "devices": [9], "favorites": [7, 8], "setting": [4, 5, 6, 7]}},
            [5, 0, 7, 1, 7, 4, 10, 8, 9],
        ),
        (
            {"days": "31", "include": "feed_messages"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {
                "items": {
                    "account": [4, 5],
                    "devices": [9],
                    "favorites": [7, 8],
                    "feed_messages": [7, 8],
                    "setting": [4, 5, 6, 7],
                },
            },
            [5, 0, 7, 1, 7, 4, 10, 6, 9],
        ),
        (
            {"days": "31", "include": "push_messages"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {
                "items": {
                    "account": [4, 5],
                    "devices": [9],
                    "favorites": [7, 8],
                    "push_messages": [7, 8],
                    "setting": [4, 5, 6, 7],
                },
            },
            [5, 0, 7, 1, 7, 4, 10, 8, 7],
        ),
        (
            {"days": "31", "include": "all"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {
                "items": {
                    "account": [4, 5],
                    "devices": [9],
                    "favorites": [7, 8],
                    "feed_messages": [7, 8],
                    "messages": [7, 8],
                    "push_messages": [7, 8],
                    "setting": [4, 5, 6, 7],
                },
            },
            [5, 0, 7, 1, 7, 4, 8, 6, 7],
        ),
        (
            {"days": "31", "include": "all", "limit": "1"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {
                "items": {
                    "account": [4],
                    "devices": [9],
                    "favorites": [7],
                    "feed_messages": [7],
                    "messages": [7],
                    "push_messages": [7],
                    "setting": [4, 5, 6],
                },
            },
            [5, 1, 7, 1, 8, 5, 9, 7, 8],
        ),
        (
            {"id": "2,4", "include": "all"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {
                "items": {
                    "account": [4],
                    "devices": [9],
                    "favorites": [7],
                    "feed_messages": [7],
                    "messages": [7],
                    "push_messages": [7],
                    "setting": [4, 5, 6],
                },
            },
            [5, 1, 7, 1, 8, 5, 9, 7, 8],
        ),
        (
            {"user_id": "u_5,u_6", "days": "31", "include": "all"},
            {"X-App-Slug": "app_2"},
            HTTPStatus.OK,
            {
                "items": {
                    "account": [5],
                    "devices": [],
                    "favorites": [8],
                    "feed_messages": [8],
                    "messages": [8],
                    "push_messages": [8],
                    "setting": [7],
                },
            },
            [5, 1, 7, 2, 8, 7, 9, 7, 8],
        ),
    )
)
async def test_delete_private_accounts_inactive(
    params, headers, expected_status, expected_result, expected_count, db_session, client, auth
):
    async with session_scope() as session:
        await set_test_db(session, with_favorites=True, with_messages=True, inactive_users=[4, 5])

    headers.update(auth)
    response = await client.delete("/private/accounts/inactive/", headers=headers, params=params)

    assert response.status == expected_status
    if expected_status != HTTPStatus.OK:
        return

    result = await response.json()
    assert result == expected_result

    record_count = await count_records(
        [Account, Account, Device, Device, Favorites, Settings, Message, FeedMessage, PushMessage],
        [dict(_active_only=True), dict(_active_only=False, is_active=False), dict(status=True), dict(status=False)],
    )
    assert record_count == expected_count


@pytest.mark.parametrize(
    "params,headers,expected_status,expected_result,expected_count",
    (
        ({"id": "1,3,4"}, {"X-App-Slug": "app2"}, HTTPStatus.OK, {"items": {"events": [1, 4]}}, 6),
        ({"event_id": "1,2,4,5"}, {"X-App-Slug": "app2"}, HTTPStatus.OK, {"items": {"events": [1, 4, 7]}}, 5),
        ({"external_id": "ex1,ex3,ex5"}, {"X-App-Slug": "app2"}, HTTPStatus.OK, {"items": {"events": [4, 7]}}, 6),
        ({"code": "co1,co3"}, {"X-App-Slug": "app1"}, HTTPStatus.OK, {"items": {"events": [3, 6]}}, 6),
        ({"days": "33"}, {"X-App-Slug": "app2"}, HTTPStatus.OK, {"items": {"events": [4, 7]}}, 6),
        ({"id": "1,4", "event_id": "4"}, {"X-App-Slug": "app2"}, HTTPStatus.OK, {"items": {"events": [1, 4, 7]}}, 5),
        ({"days": "31", "limit": "2"}, {"X-App-Slug": "app2"}, HTTPStatus.OK, {"items": {"events": [1, 4]}}, 6),
    )
)
async def test_delete_private_events(
    params, headers, expected_status, expected_result, expected_count, db_session, client, auth
):
    async with session_scope() as session:
        await create_events(session)

    headers.update(auth)
    response = await client.delete("/private/events/", headers=headers, params=params)

    assert response.status == expected_status
    if expected_status != HTTPStatus.OK:
        return

    result = await response.json()
    assert result == expected_result

    async with session_scope() as session:
        record_count = await Event.count(session=session)
    assert record_count == expected_count


@pytest.mark.parametrize(
    "params,headers,expected_status,expected_result,expected_count",
    (
        (
            {"type": "messages", "id": "2,3,7"},
            {"X-App-Slug": "app_1"},
            HTTPStatus.OK,
            {"items": {"messages": [2, 3]}},
            [8, 8, 9],
        ),
        (
            {"type": "push_messages", "id": "2,4,7"},
            {"X-App-Slug": "app_1"},
            HTTPStatus.OK,
            {"items": {"push_messages": [2, 4]}},
            [10, 8, 7],
        ),
        (
            {"type": "all", "event_id": "2,4", "external_id": "ex_2,ex_5"},
            {"X-App-Slug": "app_1"},
            HTTPStatus.OK,
            {"items": {"feed_messages": [3, 5], "messages": [3, 5], "push_messages": [3, 5]}},
            [8, 6, 7],
        ),
        (
            {"type": "all", "message_id": "10,11,15", "account_id": "2,4"},
            {"X-App-Slug": "app_1"},
            HTTPStatus.OK,
            {"items": {"feed_messages": [1, 3, 4, 5], "messages": [1, 3, 4, 5], "push_messages": [1, 3, 4, 5]}},
            [6, 4, 5],
        ),
        (
            {"type": "all", "days": "32"},
            {"X-App-Slug": "app_1"},
            HTTPStatus.OK,
            {"items": {"feed_messages": [4, 5], "messages": [4, 5], "push_messages": [4, 5]}},
            [8, 6, 7],
        ),
        (
            {"type": "all", "days": "30", "limit": 2},
            {"X-App-Slug": "app_1"},
            HTTPStatus.OK,
            {"items": {"feed_messages": [2, 3], "messages": [2, 3], "push_messages": [2, 3]}},
            [8, 6, 7],
        ),
    )
)
async def test_delete_private_messages(
    params, headers, expected_status, expected_result, expected_count, db_session, client, auth
):
    async with session_scope() as session:
        await create_test_accounts(session)
        await create_test_messages(session)

    headers.update(auth)
    response = await client.delete("/private/messages/", headers=headers, params=params)

    assert response.status == expected_status
    if expected_status != HTTPStatus.OK:
        return

    result = await response.json()
    assert result == expected_result

    record_count = await count_records([Message, FeedMessage, PushMessage])
    assert record_count == expected_count