from collections import defaultdict

import pytest

from http import HTTPStatus as http_status

from server.db.models import Device
from server.db.session import db_session as session_scope
from tests.utils import get_device_record_data, create_devices


@pytest.mark.parametrize(
    "headers,body,status",
    (
        ({}, {}, http_status.BAD_REQUEST),
        (
            {"X-App-Slug": "app1", "X-User-Id": "user2"},
            get_device_record_data(1),
            http_status.CREATED,
        ),
        (
            {"X-App-Slug": "app1", "X-User-Id": "user1"},
            get_device_record_data(1),
            http_status.OK,
        ),
        (
            {"X-App-Slug": "app1", "X-User-Id": "user1"},
            get_device_record_data(1, expo_token="new"),
            http_status.OK,
        ),
        (
            {"X-App-Slug": "app1", "X-User-Id": "user1"},
            get_device_record_data(1, os="android", expo_token="some new token"),
            http_status.CREATED,
        ),
        (
            {"X-App-Slug": "app1", "X-User-Id": "user1"},
            get_device_record_data(1, device_inner_id="just some new device inner id", expo_token="new"),
            http_status.CREATED,
        ),
        (
            {"X-App-Slug": "app1", "X-User-Id": "user1", "version": "1.1.1"},
            get_device_record_data(1, expo_token="new"),
            http_status.OK,
        ),
        (
            {"X-App-Slug": "app1", "X-User-Id": "user1", "version": "2.2.2"},
            get_device_record_data(1, os="android", expo_token="some new token"),
            http_status.CREATED,
        ),
    ),
)
async def test_get_user_device(headers, body, status, db_session, client, auth):
    async with session_scope() as session:
        await create_devices(session, count=1, apps_count=1)
    headers.update(auth)
    response = await client.post("/api/users/devices/register/", headers=headers, json=body)
    assert response.status == status
    if status in [http_status.OK, http_status.CREATED]:
        async with session_scope() as session:
            device = await Device.get(
                token=body["expo_token"],
                inner_id=body["device_inner_id"],
                os=body["os"],
                account_id=1,
                session=session
            )
            if "version" not in headers:
                assert device.app_version == headers.get("version")


@pytest.mark.parametrize(
    "headers,body,status",
    (
        ({}, {}, http_status.BAD_REQUEST),
        (
            {"X-App-Slug": "app1", "X-User-Id": "user1"},
            get_device_record_data(1),
            http_status.OK,
        ),
        (
            {"X-App-Slug": "app1", "X-User-Id": "asdasdf1"},
            get_device_record_data(1),
            http_status.BAD_REQUEST,
        ),
    ),
)
async def test_update_user_device(headers, body, status, db_session, client, auth):
    async with session_scope() as session:
        await create_devices(session, count=1, apps_count=1)
    headers.update(auth)
    response = await client.post("/api/users/devices/unregister/", headers=headers, json=body)
    assert response.status == status
    if response.status == http_status.OK:
        async with session_scope() as session:
            device = await Device.get(
                token="expo_token_1",
                inner_id="device_inner_id_1",
                os="ios",
                account_id=1,
                session=session
            )
            assert device.status == False


@pytest.mark.parametrize(
    "headers,status",
    (
        (
            {"X-App-Slug": "app1"},
            http_status.ACCEPTED,
        ),
    ),
)
async def test_deactivate_user_device(headers, status, db_session, client, auth):
    device_ids_to_deactivate = dict()
    device_id_with_active_token = None

    async with session_scope() as session:
        await create_devices(session, count=7, apps_count=5)

        devices = await Device.list(session=session)
        for index, device in enumerate(devices[0]):
            assert device.status == True
            if index == 0:
                device_ids_to_deactivate[(device.id, device.token)] = True
                continue
            if index == 1:
                device_id_with_active_token = device.id
                device_ids_to_deactivate[(device.id, "some_existing_token")] = True
                continue
            device_ids_to_deactivate[(device.id, device.token)] = False
    # Add random probably non-existing device id
    if 1 not in device_ids_to_deactivate.keys():
        device_ids_to_deactivate[1, "expo_token_000"] = False
    headers.update(auth)
    request_data = [
        {"device_id": k[0], "expo_token": k[1]}
        for k, v in list(device_ids_to_deactivate.items()) if v is False or k[1] == "some_existing_token"
    ]
    response = await client.put(
        "/api/users/devices/unregister/", headers=headers, json={"data": list(request_data)}
    )
    assert response.status == status

    async with session_scope() as session:

        devices = await Device.list(session=session)
        for device in devices[0]:
            if device.id == device_id_with_active_token:
                assert device.status == device_ids_to_deactivate[(device.id, "some_existing_token")]
                continue
            assert device.status == device_ids_to_deactivate[(device.id, device.token)]