import uuid
import pytest
from httpx import AsyncClient
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from infrastructure.telegram.service import TelegramApiService
from infrastructure.telegram.webhook import hash_webhook_secret
from modules.bots.models import BotWebhook, BotUser


@pytest.mark.asyncio
async def test_language_selection_in_actual_bot_responses(
    async_client: AsyncClient,
    db_session: AsyncSession,
):
    TelegramApiService.clear_mocks()

    # 1. Setup mock bot
    mock_token = f"token_i18n_{uuid.uuid4().hex[:8]}_test"
    bot_username = f"i18n_bot_{uuid.uuid4().hex[:6]}"
    TelegramApiService.register_mock_bot(mock_token, bot_username, "Multilingual Bot")

    # 2. Register Tenant & Bot
    user_email = f"i18n_owner_{uuid.uuid4().hex[:6]}@example.com"
    reg_resp = await async_client.post(
        "/api/v1/auth/register",
        json={"email": user_email, "password": "Password123!", "full_name": "I18n Org Lead"},
    )
    token = reg_resp.json()["data"]["access_token"]

    tenant_resp = await async_client.post(
        "/api/v1/tenants",
        headers={"Authorization": f"Bearer {token}"},
        json={"name": "Multilingual Global Org", "slug": f"i18n-org-{uuid.uuid4().hex[:6]}"},
    )
    tenant_id = tenant_resp.json()["data"]["id"]
    headers = {
        "Authorization": f"Bearer {token}",
        "X-Tenant-ID": str(tenant_id),
    }

    bot_reg_resp = await async_client.post(
        "/api/v1/bots",
        headers=headers,
        json={"token": mock_token, "name": "Global Bot"},
    )
    assert bot_reg_resp.status_code == 201
    bot_id = bot_reg_resp.json()["data"]["id"]

    # Retrieve webhook secret for testing simulated updates
    wh_stmt = select(BotWebhook).where(BotWebhook.bot_id == uuid.UUID(bot_id))
    wh_res = await db_session.execute(wh_stmt)
    webhook_row = wh_res.scalar_one()
    test_secret = "secret-token-i18n-54321"
    webhook_row.secret_hash = hash_webhook_secret(test_secret)
    await db_session.commit()

    webhook_headers = {
        "X-Telegram-Bot-Api-Secret-Token": test_secret,
    }

    # 3. User A (Hindi client language_code 'hi-IN') sends /start
    TelegramApiService.clear_sent_messages()
    update_hi = {
        "update_id": 2001,
        "message": {
            "message_id": 1,
            "from": {"id": 1001, "first_name": "Aarav", "username": "aarav_hi", "language_code": "hi-IN"},
            "chat": {"id": 1001, "type": "private"},
            "text": "/start",
        },
    }
    wh_resp_hi = await async_client.post(
        f"/webhooks/telegram/{bot_id}",
        headers=webhook_headers,
        json=update_hi,
    )
    assert wh_resp_hi.status_code == 200
    sent_hi = TelegramApiService.get_sent_messages()
    assert len(sent_hi) == 1
    # Must render native Hindi welcome message
    assert "नमस्ते" in sent_hi[0]["text"]
    assert "तैयार है" in sent_hi[0]["text"]

    # 4. User B (Spanish client language_code 'es-ES') sends /start
    TelegramApiService.clear_sent_messages()
    update_es = {
        "update_id": 2002,
        "message": {
            "message_id": 2,
            "from": {"id": 1002, "first_name": "Carlos", "username": "carlos_es", "language_code": "es-ES"},
            "chat": {"id": 1002, "type": "private"},
            "text": "/start",
        },
    }
    wh_resp_es = await async_client.post(
        f"/webhooks/telegram/{bot_id}",
        headers=webhook_headers,
        json=update_es,
    )
    assert wh_resp_es.status_code == 200
    sent_es = TelegramApiService.get_sent_messages()
    assert len(sent_es) == 1
    # Must render native Spanish welcome message
    assert "¡Bienvenido!" in sent_es[0]["text"]
    assert "listo" in sent_es[0]["text"]

    # 5. User C (starts with German 'de') sends /start
    TelegramApiService.clear_sent_messages()
    update_de = {
        "update_id": 2003,
        "message": {
            "message_id": 3,
            "from": {"id": 1003, "first_name": "Hans", "username": "hans_de", "language_code": "de"},
            "chat": {"id": 1003, "type": "private"},
            "text": "/start",
        },
    }
    wh_resp_de = await async_client.post(
        f"/webhooks/telegram/{bot_id}",
        headers=webhook_headers,
        json=update_de,
    )
    assert wh_resp_de.status_code == 200
    sent_de = TelegramApiService.get_sent_messages()
    assert len(sent_de) == 1
    # Must render native German welcome message
    assert "Willkommen!" in sent_de[0]["text"]
    assert "bereit" in sent_de[0]["text"]

    # 6. User C requests language menu via /lang
    TelegramApiService.clear_sent_messages()
    update_lang_menu = {
        "update_id": 2004,
        "message": {
            "message_id": 4,
            "from": {"id": 1003, "first_name": "Hans", "username": "hans_de", "language_code": "de"},
            "chat": {"id": 1003, "type": "private"},
            "text": "/lang",
        },
    }
    wh_resp_menu = await async_client.post(
        f"/webhooks/telegram/{bot_id}",
        headers=webhook_headers,
        json=update_lang_menu,
    )
    assert wh_resp_menu.status_code == 200
    sent_menu = TelegramApiService.get_sent_messages()
    assert len(sent_menu) == 1
    assert "Select Your Language" in sent_menu[0]["text"]
    kb_buttons = sent_menu[0]["reply_markup"]["inline_keyboard"]
    flat_callbacks = [b["callback_data"] for row in kb_buttons for b in row]
    assert "set_lang:ja" in flat_callbacks
    assert "set_lang:ar" in flat_callbacks
    assert "set_lang:ru" in flat_callbacks

    # 7. User C selects Japanese via callback set_lang:ja
    TelegramApiService.clear_sent_messages()
    update_set_ja = {
        "update_id": 2005,
        "callback_query": {
            "id": "cb_001",
            "from": {"id": 1003, "first_name": "Hans", "username": "hans_de"},
            "message": {
                "message_id": 4,
                "chat": {"id": 1003, "type": "private"},
            },
            "data": "set_lang:ja",
        },
    }
    wh_resp_set_ja = await async_client.post(
        f"/webhooks/telegram/{bot_id}",
        headers=webhook_headers,
        json=update_set_ja,
    )
    assert wh_resp_set_ja.status_code == 200
    sent_set_ja = TelegramApiService.get_sent_messages()
    assert len(sent_set_ja) == 1
    # Must receive native Japanese confirmation
    assert "日本語" in sent_set_ja[0]["text"]

    # 8. User C sends /start again -> Now responds in Japanese!
    TelegramApiService.clear_sent_messages()
    update_start_ja = {
        "update_id": 2006,
        "message": {
            "message_id": 5,
            "from": {"id": 1003, "first_name": "Hans", "username": "hans_de"},
            "chat": {"id": 1003, "type": "private"},
            "text": "/start",
        },
    }
    wh_resp_start_ja = await async_client.post(
        f"/webhooks/telegram/{bot_id}",
        headers=webhook_headers,
        json=update_start_ja,
    )
    assert wh_resp_start_ja.status_code == 200
    sent_start_ja = TelegramApiService.get_sent_messages()
    assert len(sent_start_ja) == 1
    # Must render native Japanese welcome message
    assert "ようこそ" in sent_start_ja[0]["text"]

    # 9. User C switches language to Arabic via callback set_lang:ar
    TelegramApiService.clear_sent_messages()
    update_set_ar = {
        "update_id": 2007,
        "callback_query": {
            "id": "cb_002",
            "from": {"id": 1003, "first_name": "Hans", "username": "hans_de"},
            "message": {
                "message_id": 5,
                "chat": {"id": 1003, "type": "private"},
            },
            "data": "set_lang:ar",
        },
    }
    wh_resp_set_ar = await async_client.post(
        f"/webhooks/telegram/{bot_id}",
        headers=webhook_headers,
        json=update_set_ar,
    )
    assert wh_resp_set_ar.status_code == 200
    sent_set_ar = TelegramApiService.get_sent_messages()
    assert len(sent_set_ar) == 1
    # Must receive native Arabic confirmation
    assert "العربية" in sent_set_ar[0]["text"]

    # 10. User C sends /start again -> Now responds in Arabic!
    TelegramApiService.clear_sent_messages()
    update_start_ar = {
        "update_id": 2008,
        "message": {
            "message_id": 6,
            "from": {"id": 1003, "first_name": "Hans", "username": "hans_de"},
            "chat": {"id": 1003, "type": "private"},
            "text": "/start",
        },
    }
    wh_resp_start_ar = await async_client.post(
        f"/webhooks/telegram/{bot_id}",
        headers=webhook_headers,
        json=update_start_ar,
    )
    assert wh_resp_start_ar.status_code == 200
    sent_start_ar = TelegramApiService.get_sent_messages()
    assert len(sent_start_ar) == 1
    # Must render native Arabic welcome message
    assert "أهلاً وسهلاً" in sent_start_ar[0]["text"]
