from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool

router = APIRouter(prefix="/hints", tags=["hints"])

@router.get("/first-letter/{level_id}")
async def get_first_letter_hint(request: Request, level_id: int):
    """Подсказка: показывает первую букву случайного ненайденного слова"""
    telegram_id, _ = await require_auth(request)

    pool = await get_pool()
    async with pool.acquire() as conn:
        # Проверяем, что уровень существует
        level = await conn.fetchrow("SELECT * FROM levels WHERE id = $1", level_id)
        if not level:
            raise HTTPException(404, "Level not found")

        # Проверяем, что пользователь существует
        user_exists = await conn.fetchval(
            "SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
        )
        if not user_exists:
            raise HTTPException(401, "User not registered")

        # Получаем прогресс пользователя по этому уровню
        progress = await conn.fetchrow(
            "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
            telegram_id, level_id
        )
        
        hints_already_used = progress["hints_used"] if progress else 0

        # Получаем все слова уровня
        words = await conn.fetch(
            "SELECT word_pl FROM level_words WHERE level_id = $1", level_id
        )
        
        if not words:
            raise HTTPException(404, "No words found for this level")

        word_paths = level["word_paths"]
        if isinstance(word_paths, str):
            import json
            word_paths = json.loads(word_paths)

        # Находим первое слово, у которого есть путь
        all_level_words = [w["word_pl"] for w in words]
        
        # Ищем слово с путём (сначала основные, потом filler-слова)
        found_word = None
        first_cell = None
        
        for word in all_level_words:
            if word in word_paths and word_paths[word]:
                found_word = word
                first_cell = word_paths[word][0]
                break
        
        if not found_word:
            # Если пути не нашлись — берём любое слово
            found_word = all_level_words[0]
            first_cell = [0, 0]

        return {
            "status": "ok",
            "word": found_word,
            "first_cell": first_cell,
            "hints_used_total": hints_already_used,
        }

@router.get("/word-list/{level_id}")
async def get_word_list(request: Request, level_id: int):
    """Подсказка: показывает список всех слов уровня с переводами"""
    telegram_id, _ = await require_auth(request)

    pool = await get_pool()
    async with pool.acquire() as conn:
        # Проверяем, что уровень существует
        level = await conn.fetchrow("SELECT id FROM levels WHERE id = $1", level_id)
        if not level:
            raise HTTPException(404, "Level not found")

        # Проверяем, что пользователь существует
        user_exists = await conn.fetchval(
            "SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
        )
        if not user_exists:
            raise HTTPException(401, "User not registered")

        # Получаем прогресс пользователя
        progress = await conn.fetchrow(
            "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
            telegram_id, level_id
        )
        
        hints_already_used = progress["hints_used"] if progress else 0

        # Получаем слова
        words = await conn.fetch(
            "SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id
        )

        # Определяем язык пользователя
        user = await conn.fetchrow(
            "SELECT app_language FROM users WHERE telegram_id = $1", telegram_id
        )
        lang = user["app_language"] if user else "pl"

        # Формируем список с переводами
        translation_field = f"translation_{lang}"
        word_list = []
        for w in words:
            translation = (
                w.get(translation_field) or 
                w.get("translation_pl") or 
                w.get("translation_en") or 
                ""
            )
            word_list.append({
                "word_pl": w["word_pl"],
                "translation": translation,
            })

        return {
            "status": "ok", 
            "words": word_list,
            "total_words": len(word_list),
            "hints_used_total": hints_already_used,
        }

@router.get("/remaining/{level_id}")
async def get_remaining_hints(request: Request, level_id: int):
    """Возвращает количество оставшихся подсказок для уровня"""
    telegram_id, _ = await require_auth(request)

    pool = await get_pool()
    async with pool.acquire() as conn:
        progress = await conn.fetchrow(
            "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
            telegram_id, level_id
        )
        
        hints_used = progress["hints_used"] if progress else 0
        max_hints = 3
        remaining = max(0, max_hints - hints_used)
        
        return {
            "max_hints": max_hints,
            "hints_used": hints_used,
            "remaining": remaining,
        }