"""Tests for counter endpoints.

Note: Registration now requires an invite code.
"""

import pytest

from auth import COOKIE_NAME
from models import ROLE_REGULAR
from tests.conftest import create_user_with_roles
from tests.helpers import create_invite_for_godfather, unique_email


@pytest.mark.asyncio
async def test_increment_enqueues_job_with_user_id(client_factory, mock_enqueue_job):
    """Verify that incrementing the counter enqueues a job with the user's ID."""
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(
            db, unique_email("gf"), "pass123", [ROLE_REGULAR]
        )
        invite_code = await create_invite_for_godfather(db, godfather.id)

    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)

    # Get user ID from the me endpoint
    async with client_factory.create(cookies=cookies) as authed:
        me_response = await authed.get("/api/auth/me")
        user_id = me_response.json()["id"]

        # Increment counter
        response = await authed.post("/api/counter/increment")
        assert response.status_code == 200

    # Verify enqueue was called with the correct user_id
    mock_enqueue_job.assert_called_once_with(user_id)


# Protected endpoint tests - without auth
@pytest.mark.asyncio
async def test_get_counter_requires_auth(client):
    response = await client.get("/api/counter")
    assert response.status_code == 401


@pytest.mark.asyncio
async def test_increment_counter_requires_auth(client):
    response = await client.post("/api/counter/increment")
    assert response.status_code == 401


@pytest.mark.asyncio
async def test_get_counter_invalid_cookie(client_factory):
    async with client_factory.create(cookies={COOKIE_NAME: "invalidtoken"}) as authed:
        response = await authed.get("/api/counter")
    assert response.status_code == 401


@pytest.mark.asyncio
async def test_increment_counter_invalid_cookie(client_factory):
    async with client_factory.create(cookies={COOKIE_NAME: "invalidtoken"}) as authed:
        response = await authed.post("/api/counter/increment")
    assert response.status_code == 401


# Authenticated counter tests
@pytest.mark.asyncio
async def test_get_counter_authenticated(client_factory):
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(
            db, unique_email("gf"), "pass123", [ROLE_REGULAR]
        )
        invite_code = await create_invite_for_godfather(db, godfather.id)

    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)

    async with client_factory.create(cookies=cookies) as authed:
        response = await authed.get("/api/counter")

    assert response.status_code == 200
    assert "value" in response.json()


@pytest.mark.asyncio
async def test_increment_counter(client_factory):
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(
            db, unique_email("gf"), "pass123", [ROLE_REGULAR]
        )
        invite_code = await create_invite_for_godfather(db, godfather.id)

    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)

    async with client_factory.create(cookies=cookies) as authed:
        # Get current value
        before = await authed.get("/api/counter")
        before_value = before.json()["value"]

        # Increment
        response = await authed.post("/api/counter/increment")
        assert response.status_code == 200
        assert response.json()["value"] == before_value + 1


@pytest.mark.asyncio
async def test_increment_counter_multiple(client_factory):
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(
            db, unique_email("gf"), "pass123", [ROLE_REGULAR]
        )
        invite_code = await create_invite_for_godfather(db, godfather.id)

    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)

    async with client_factory.create(cookies=cookies) as authed:
        # Get starting value
        before = await authed.get("/api/counter")
        start = before.json()["value"]

        # Increment 3 times
        await authed.post("/api/counter/increment")
        await authed.post("/api/counter/increment")
        response = await authed.post("/api/counter/increment")

        assert response.json()["value"] == start + 3


@pytest.mark.asyncio
async def test_get_counter_after_increment(client_factory):
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(
            db, unique_email("gf"), "pass123", [ROLE_REGULAR]
        )
        invite_code = await create_invite_for_godfather(db, godfather.id)

    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)

    async with client_factory.create(cookies=cookies) as authed:
        before = await authed.get("/api/counter")
        start = before.json()["value"]

        await authed.post("/api/counter/increment")
        await authed.post("/api/counter/increment")

        response = await authed.get("/api/counter")
        assert response.json()["value"] == start + 2


# Counter is shared between users
@pytest.mark.asyncio
async def test_counter_shared_between_users(client_factory):
    # Create godfather and invites for two users
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(
            db, unique_email("gf"), "pass123", [ROLE_REGULAR]
        )
        invite1 = await create_invite_for_godfather(db, godfather.id)
        invite2 = await create_invite_for_godfather(db, godfather.id)

    # Create first user
    reg1 = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email("share1"),
            "password": "testpass123",
            "invite_identifier": invite1,
        },
    )
    cookies1 = dict(reg1.cookies)

    async with client_factory.create(cookies=cookies1) as user1:
        # Get starting value
        before = await user1.get("/api/counter")
        start = before.json()["value"]

        await user1.post("/api/counter/increment")
        await user1.post("/api/counter/increment")

    # Create second user - should see the increments
    reg2 = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email("share2"),
            "password": "testpass123",
            "invite_identifier": invite2,
        },
    )
    cookies2 = dict(reg2.cookies)

    async with client_factory.create(cookies=cookies2) as user2:
        response = await user2.get("/api/counter")
        assert response.json()["value"] == start + 2

        # Second user increments
        await user2.post("/api/counter/increment")

    # First user sees the increment
    async with client_factory.create(cookies=cookies1) as user1:
        response = await user1.get("/api/counter")
        assert response.json()["value"] == start + 3