from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.database import get_db
from app.dependencies import get_current_user
from app.models.telegram_config import TelegramConfig
from app.models.user import User
from app.schemas.telegram_config import TelegramConfigResponse, TelegramConfigUpdate
from app.services import telegram_service

router = APIRouter()


def _require_spbu_admin(spbu_id: int, user: User) -> None:
    if user.is_superadmin:
        return
    assigned = any(a.spbu_id == spbu_id for a in (user.assignments or []))
    if not assigned:
        raise HTTPException(403, "Akses ditolak")


@router.get(
    "/spbus/{spbu_id}/telegram-config",
    response_model=dict,
    summary="Get Telegram config for SPBU",
)
async def get_telegram_config(
    spbu_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    _require_spbu_admin(spbu_id, current_user)
    result = await db.execute(
        select(TelegramConfig).where(TelegramConfig.spbu_id == spbu_id)
    )
    cfg = result.scalar_one_or_none()
    if not cfg:
        # Return empty defaults
        return {"data": TelegramConfigResponse(
            spbu_id=spbu_id, is_active=False,
            chat_operasional_id=None, thread_penjualan_id=None,
            thread_penerimaan_id=None, thread_stock_id=None,
            chat_finansial_id=None, thread_penyetoran_id=None,
            thread_expense_id=None, thread_pb_id=None, thread_penebusan_id=None,
            chat_ga_id=None, thread_absensi_id=None,
            thread_housekeeping_id=None, thread_sapras_id=None,
        ).model_dump()}
    return {"data": TelegramConfigResponse.model_validate(cfg).model_dump()}


@router.put(
    "/spbus/{spbu_id}/telegram-config",
    response_model=dict,
    summary="Save Telegram config for SPBU (upsert)",
)
async def save_telegram_config(
    spbu_id: int,
    body: TelegramConfigUpdate,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    _require_spbu_admin(spbu_id, current_user)

    result = await db.execute(
        select(TelegramConfig).where(TelegramConfig.spbu_id == spbu_id)
    )
    cfg = result.scalar_one_or_none()

    if not cfg:
        cfg = TelegramConfig(spbu_id=spbu_id)
        db.add(cfg)

    for field, value in body.model_dump(exclude_none=False).items():
        setattr(cfg, field, value)

    await db.commit()
    await db.refresh(cfg)
    return {"data": TelegramConfigResponse.model_validate(cfg).model_dump(), "message": "Telegram config disimpan"}


@router.post(
    "/spbus/{spbu_id}/telegram-config/test",
    response_model=dict,
    summary="Send a test message to a specific topic",
)
async def test_telegram_config(
    spbu_id: int,
    body: dict,
    background_tasks: BackgroundTasks,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    """body: { "chat_id": "-100...", "thread_id": 123 }"""
    _require_spbu_admin(spbu_id, current_user)

    chat_id: str = body.get("chat_id", "")
    thread_id: int | None = body.get("thread_id")

    if not chat_id:
        raise HTTPException(400, "chat_id wajib diisi")

    background_tasks.add_task(
        telegram_service._send_text,
        chat_id,
        thread_id,
        "✅ <b>Test berhasil!</b>\n\nKonfigurasi Telegram SPBU Manager aktif.",
    )
    return {"message": "Test message dikirim"}