import json
from typing import Any
from unittest.mock import AsyncMock

import pytest
from fastapi import HTTPException
from starlette.requests import Request

from app.config import settings
from app.webserver.telegram import (
    TelegramWebhookProcessor,
    create_telegram_router,
)


@pytest.fixture(autouse=True)
def reset_webhook_settings(monkeypatch: pytest.MonkeyPatch) -> None:
    monkeypatch.setattr(settings, 'WEBHOOK_PATH', '/telegram-webhook', raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_SECRET_TOKEN', '', raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_URL', None, raising=False)
    monkeypatch.setattr(settings, 'BOT_RUN_MODE', 'webhook', raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_MAX_QUEUE_SIZE', 8, raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_WORKERS', 1, raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_ENQUEUE_TIMEOUT', 0.0, raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_WORKER_SHUTDOWN_TIMEOUT', 1.0, raising=False)


def _get_route(router, path: str, method: str = 'POST'):
    for route in router.routes:
        if getattr(route, 'path', '') == path and method in getattr(route, 'methods', set()):
            return route
    raise AssertionError(f'Route {path} with method {method} not found')


def _build_request(path: str, body: bytes, headers: dict[str, str] | None = None) -> Request:
    scope = {
        'type': 'http',
        'asgi': {'version': '3.0'},
        'method': 'POST',
        'path': path,
        'headers': [(k.lower().encode('latin-1'), v.encode('latin-1')) for k, v in (headers or {}).items()],
    }

    async def receive() -> dict[str, Any]:
        return {'type': 'http.request', 'body': body, 'more_body': False}

    return Request(scope, receive)


def _webhook_path() -> str:
    return settings.get_telegram_webhook_path()


@pytest.mark.anyio
async def test_webhook_without_secret() -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    sample_update = {
        'update_id': 123,
        'message': {
            'message_id': 10,
            'date': 1715700000,
            'chat': {'id': 456, 'type': 'private'},
            'text': 'ping',
        },
    }

    router = create_telegram_router(bot, dispatcher)
    path = _webhook_path()
    route = _get_route(router, path)
    request = _build_request(path, json.dumps(sample_update).encode('utf-8'))

    response = await route.endpoint(request)

    assert response.status_code == 200
    dispatcher.feed_update.assert_awaited_once()
    args, _kwargs = dispatcher.feed_update.await_args
    assert args[0] is bot


@pytest.mark.anyio
async def test_webhook_with_secret(monkeypatch: pytest.MonkeyPatch) -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    monkeypatch.setattr(settings, 'WEBHOOK_SECRET_TOKEN', 'super-secret', raising=False)

    sample_update = {
        'update_id': 321,
        'message': {
            'message_id': 20,
            'date': 1715700000,
            'chat': {'id': 789, 'type': 'private'},
            'text': 'pong',
        },
    }

    router = create_telegram_router(bot, dispatcher)
    path = _webhook_path()
    route = _get_route(router, path)
    request = _build_request(
        path,
        json.dumps(sample_update).encode('utf-8'),
        headers={'X-Telegram-Bot-Api-Secret-Token': 'super-secret'},
    )

    response = await route.endpoint(request)

    assert response.status_code == 200
    dispatcher.feed_update.assert_awaited_once()


@pytest.mark.anyio
async def test_webhook_secret_mismatch(monkeypatch: pytest.MonkeyPatch) -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    monkeypatch.setattr(settings, 'WEBHOOK_SECRET_TOKEN', 'expected', raising=False)

    router = create_telegram_router(bot, dispatcher)
    path = _webhook_path()
    route = _get_route(router, path)
    request = _build_request(
        path,
        json.dumps({'update_id': 1}).encode('utf-8'),
        headers={'X-Telegram-Bot-Api-Secret-Token': 'wrong'},
    )

    with pytest.raises(HTTPException) as exc:
        await route.endpoint(request)

    assert exc.value.status_code == 401
    dispatcher.feed_update.assert_not_called()


@pytest.mark.anyio
async def test_webhook_invalid_payload() -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    router = create_telegram_router(bot, dispatcher)
    path = _webhook_path()
    route = _get_route(router, path)
    request = _build_request(path, b'not-json')

    with pytest.raises(HTTPException) as exc:
        await route.endpoint(request)

    assert exc.value.status_code == 400
    dispatcher.feed_update.assert_not_called()


@pytest.mark.anyio
async def test_webhook_invalid_content_type() -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    sample_update = {
        'update_id': 123,
        'message': {
            'message_id': 10,
            'date': 1715700000,
            'chat': {'id': 456, 'type': 'private'},
            'text': 'ping',
        },
    }

    router = create_telegram_router(bot, dispatcher)
    path = _webhook_path()
    route = _get_route(router, path)
    request = _build_request(
        path,
        json.dumps(sample_update).encode('utf-8'),
        headers={'Content-Type': 'text/plain'},
    )

    with pytest.raises(HTTPException) as exc:
        await route.endpoint(request)

    assert exc.value.status_code == 415
    dispatcher.feed_update.assert_not_called()


@pytest.mark.anyio
async def test_webhook_uses_processor() -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    processor = TelegramWebhookProcessor(
        bot=bot,
        dispatcher=dispatcher,
        queue_maxsize=1,
        worker_count=0,
        enqueue_timeout=0.0,
        shutdown_timeout=1.0,
    )
    await processor.start()

    sample_update = {
        'update_id': 999,
        'message': {
            'message_id': 77,
            'date': 1715700000,
            'chat': {'id': 111, 'type': 'private'},
            'text': 'processor',
        },
    }

    router = create_telegram_router(bot, dispatcher, processor=processor)
    path = _webhook_path()
    route = _get_route(router, path)
    request = _build_request(path, json.dumps(sample_update).encode('utf-8'))

    response = await route.endpoint(request)

    assert response.status_code == 200
    dispatcher.feed_update.assert_not_awaited()
    assert processor.is_running

    await processor.stop()


@pytest.mark.anyio
async def test_webhook_processor_overloaded() -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    processor = TelegramWebhookProcessor(
        bot=bot,
        dispatcher=dispatcher,
        queue_maxsize=1,
        worker_count=0,
        enqueue_timeout=0.0,
        shutdown_timeout=1.0,
    )
    await processor.start()

    router = create_telegram_router(bot, dispatcher, processor=processor)
    path = _webhook_path()
    route = _get_route(router, path)

    request_payload = json.dumps({'update_id': 1}).encode('utf-8')
    request = _build_request(path, request_payload)
    await route.endpoint(request)

    with pytest.raises(HTTPException) as exc:
        await route.endpoint(request)

    assert exc.value.status_code == 503
    assert exc.value.detail == 'webhook_queue_full'
    dispatcher.feed_update.assert_not_called()

    await processor.stop()


@pytest.mark.anyio
async def test_webhook_processor_not_running() -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    processor = TelegramWebhookProcessor(
        bot=bot,
        dispatcher=dispatcher,
        queue_maxsize=1,
        worker_count=1,
        enqueue_timeout=0.0,
        shutdown_timeout=1.0,
    )

    router = create_telegram_router(bot, dispatcher, processor=processor)
    path = _webhook_path()
    route = _get_route(router, path)
    request = _build_request(path, json.dumps({'update_id': 5}).encode('utf-8'))

    with pytest.raises(HTTPException) as exc:
        await route.endpoint(request)

    assert exc.value.status_code == 503
    assert exc.value.detail == 'webhook_processor_unavailable'
    dispatcher.feed_update.assert_not_called()


@pytest.mark.anyio
async def test_webhook_path_normalization(monkeypatch: pytest.MonkeyPatch) -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    monkeypatch.setattr(settings, 'WEBHOOK_PATH', '  telegram/webhook ', raising=False)

    router = create_telegram_router(bot, dispatcher)
    normalized_path = settings.get_telegram_webhook_path()

    assert normalized_path == '/telegram/webhook'
    route = _get_route(router, normalized_path)

    request = _build_request(normalized_path, json.dumps({'update_id': 7}).encode('utf-8'))
    response = await route.endpoint(request)

    assert response.status_code == 200
    dispatcher.feed_update.assert_awaited_once()


@pytest.mark.anyio
async def test_health_endpoint(monkeypatch: pytest.MonkeyPatch) -> None:
    bot = AsyncMock()
    dispatcher = AsyncMock()
    dispatcher.feed_update = AsyncMock()

    monkeypatch.setattr(settings, 'WEBHOOK_URL', 'https://example.com', raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_PATH', '/custom', raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_MAX_QUEUE_SIZE', 42, raising=False)
    monkeypatch.setattr(settings, 'WEBHOOK_WORKERS', 2, raising=False)

    router = create_telegram_router(bot, dispatcher)
    route = _get_route(router, '/health/telegram-webhook', method='GET')

    response = await route.endpoint()

    assert response.status_code == 200
    payload = json.loads(response.body.decode('utf-8'))
    assert payload['status'] == 'ok'
    assert payload['mode'] == settings.get_bot_run_mode()
    assert payload['path'] == '/custom'
    assert payload['webhook_configured'] is True
    assert payload['queue_maxsize'] == 42
    assert payload['workers'] == 2