import uuid

import pytest

from huesoporro.infra.repos import QuoteRepo, UserRepo
from huesoporro.models import TwitchAuth, User


async def test_create_user_raises_value_error_for_existing_user(
    user_repo: UserRepo, persisted_user: User
):
    with pytest.raises(
        ValueError, match=f"User {persisted_user.username} already exists"
    ):
        await user_repo.create(persisted_user)


async def test_get_user_by_username(user_repo: UserRepo, persisted_user: User):
    db_user = await user_repo.get_by_username(persisted_user.username)
    assert db_user == persisted_user


async def test_get_user_returns_none(user_repo: UserRepo):
    assert await user_repo.get_by_username("unknown_user") is None


async def test_get_user_by_id(user_repo: UserRepo, persisted_user: User):
    db_user = await user_repo.get_by_id(persisted_user.id)
    assert db_user == persisted_user


async def test_get_user_by_id_returns_none(user_repo: UserRepo):
    assert await user_repo.get_by_id(uuid.uuid4()) is None


async def test_update_users_tokens(
    user_repo: UserRepo, twitch_auth: TwitchAuth, persisted_user: User
):
    twitch_auth.access_token = uuid.uuid4().hex
    twitch_auth.refresh_token = uuid.uuid4().hex
    new_tokens = {"twitch": twitch_auth}
    persisted_user.external_auth = new_tokens  # type: ignore[assignment]
    assert await user_repo.update(persisted_user) == persisted_user


async def test_update_username(user_repo: UserRepo, persisted_user: User):
    persisted_user.username = "new_username"
    assert await user_repo.update(persisted_user) == persisted_user


async def test_update_non_existing_user_raises_value_error(
    user_repo: UserRepo, user: User
):
    with pytest.raises(ValueError, match=f"User {user.username} does not exist"):
        await user_repo.update(user)


async def test_delete_user(user_repo: UserRepo, persisted_user: User):
    assert await user_repo.delete(persisted_user) is None
    assert await user_repo.get_by_id(persisted_user.id) is None


async def test_create_chatbot_raises_value_error_for_existing_chatbot(
    chatbot_repo, chatbot_factory, persisted_chatbot
):
    with pytest.raises(
        ValueError, match=f"Chatbot {persisted_chatbot.user_id} already exists"
    ):
        await chatbot_repo.create(
            chatbot_factory.build(user_id=persisted_chatbot.user_id)
        )


async def test_update_chatbot(persisted_chatbot, faker, chatbot_repo):
    persisted_chatbot.automatic_generation_timer = faker.pyint()
    persisted_chatbot.automatic_quote_timer = faker.pyint()
    persisted_chatbot.mods = ["mod1", "mod2"]

    updated_chatbot = await chatbot_repo.update(persisted_chatbot)
    persisted_chatbot.last_updated_at = updated_chatbot.last_updated_at
    assert updated_chatbot == persisted_chatbot


async def test_update_chatbot_raises_value_error_on_non_existing_chatbot(
    chatbot_repo, chatbot
):
    with pytest.raises(ValueError, match=f"Chatbot {chatbot.user_id} does not exist"):
        await chatbot_repo.update(chatbot)


async def test_get_random_quote(quote_repo: QuoteRepo, persisted_quote):
    quote = await quote_repo.get_random(persisted_quote.channel_name)
    assert quote
    assert quote.author == persisted_quote.author
    assert quote.channel_name == persisted_quote.channel_name