from typing import Annotated, Optional
from uuid import UUID
from fastapi import APIRouter, Depends, Query, status
from sqlalchemy.ext.asyncio import AsyncSession
from apps.api.dependencies import get_current_user
from infrastructure.database.session import get_db
from modules.identity.models import User
from modules.emojis.schemas import (
    CustomEmojiResponse,
    SyncPackRequest,
    BulkEmojiImportRequest,
    BulkEmojiImportResponse,
    CreateEmojiPackRequest,
    EmojiPackResponse,
    EmojiPackDetailResponse,
    EmojiValidationRequest,
    EmojiValidationResponse,
)
from modules.emojis.service import EmojiService
from shared.schemas import ApiResponse

router = APIRouter(prefix="/emojis", tags=["Custom Emojis Catalog"])


@router.get("/search", response_model=ApiResponse[list[CustomEmojiResponse]], status_code=status.HTTP_200_OK)
async def search_custom_emojis(
    q: Optional[str] = Query(default=None, description="Search term, e.g. crown, fire, vip"),
    category: Optional[str] = Query(default=None, description="Category filter"),
    limit: int = Query(default=50, ge=1, le=100),
    offset: int = Query(default=0, ge=0),
    db: Annotated[AsyncSession, Depends(get_db)] = None,
):
    service = EmojiService(db)
    emojis = await service.search(query=q, category=category, limit=limit, offset=offset)
    return ApiResponse(
        message="Custom emojis retrieved",
        data=[CustomEmojiResponse.model_validate(e) for e in emojis],
    )


@router.get("/categories", response_model=ApiResponse[list[str]], status_code=status.HTTP_200_OK)
async def get_emoji_categories(
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = EmojiService(db)
    cats = await service.get_categories()
    return ApiResponse(
        message="Emoji categories list",
        data=list(cats),
    )


@router.post("/import", response_model=ApiResponse[BulkEmojiImportResponse], status_code=status.HTTP_200_OK)
async def bulk_import_emojis(
    req: BulkEmojiImportRequest,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = EmojiService(db)
    result = await service.bulk_import(req)
    return ApiResponse(
        message=f"Bulk imported {result.imported_count} new and updated {result.updated_count} emojis",
        data=result,
    )


@router.post("/validate", response_model=ApiResponse[EmojiValidationResponse], status_code=status.HTTP_200_OK)
async def validate_emoji_tag(
    req: EmojiValidationRequest,
):
    result = EmojiService.validate_emoji(req)
    return ApiResponse(
        message="Emoji validation completed",
        data=result,
    )


@router.get("/packs", response_model=ApiResponse[list[EmojiPackResponse]], status_code=status.HTTP_200_OK)
async def list_emoji_packs(
    limit: int = Query(default=50, ge=1, le=100),
    offset: int = Query(default=0, ge=0),
    db: Annotated[AsyncSession, Depends(get_db)] = None,
):
    service = EmojiService(db)
    packs = await service.list_packs(limit=limit, offset=offset)
    return ApiResponse(
        message="Emoji packs retrieved",
        data=packs,
    )


@router.post("/packs", response_model=ApiResponse[EmojiPackResponse], status_code=status.HTTP_201_CREATED)
async def create_emoji_pack(
    req: CreateEmojiPackRequest,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = EmojiService(db)
    pack = await service.create_pack(req)
    return ApiResponse(
        message="Emoji pack created successfully",
        data=pack,
    )


@router.get("/packs/{pack_id}", response_model=ApiResponse[EmojiPackDetailResponse], status_code=status.HTTP_200_OK)
async def get_emoji_pack_detail(
    pack_id: UUID,
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = EmojiService(db)
    detail = await service.get_pack_detail(pack_id)
    return ApiResponse(
        message="Emoji pack details retrieved",
        data=detail,
    )


@router.delete("/packs/{pack_id}", response_model=ApiResponse[None], status_code=status.HTTP_200_OK)
async def delete_emoji_pack(
    pack_id: UUID,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = EmojiService(db)
    await service.delete_pack(pack_id)
    return ApiResponse(
        message="Emoji pack deleted successfully",
        data=None,
    )


@router.post("/sync-pack", response_model=ApiResponse[dict], status_code=status.HTTP_200_OK)
async def sync_emoji_pack(
    req: SyncPackRequest,
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    if not req.bot_token:
        return ApiResponse(
            success=False,
            message="bot_token is required to fetch pack from Telegram Bot API",
            data=None,
        )

    service = EmojiService(db)
    result = await service.sync_pack_from_telegram(
        pack_name=req.pack_name,
        bot_token=req.bot_token,
        category=req.category,
    )
    return ApiResponse(
        message="Pack synchronized successfully",
        data=result,
    )


@router.post("/seed", response_model=ApiResponse[dict[str, int]], status_code=status.HTTP_200_OK)
async def seed_curated_emojis(
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    service = EmojiService(db)
    synced = await service.seed_default_emojis()
    return ApiResponse(
        message="Curated Telegram emojis seeded into database",
        data={"seeded_count": synced},
    )

