from fastapi import APIRouter, Depends, status
from sqlalchemy.orm import Session

from app.api.deps import (
    get_current_user,
    require_telegram_bot_secret,
    get_telegram_service,
    require_roles,
)
from app.core.config import settings
from app.db.session import get_db
from app.models.user import User
from app.schemas.action import ActionRead
from app.schemas.telegram import (
    TelegramCommandIdentity,
    TelegramLinkCodeRead,
    TelegramLinkCompleteRequest,
    TelegramLinkRead,
    TelegramRestartRequest,
    TelegramServicesCommandRead,
    TelegramServicesQuery,
    TelegramStatusCommandRead,
    TelegramStatusRead,
    TelegramTestMessageResponse,
)
from app.services.telegram_service import TelegramService


router = APIRouter()


@router.get("/status", response_model=TelegramStatusRead)
def get_telegram_status(
    _: User = Depends(require_roles("admin")),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> TelegramStatusRead:
    enabled, linked_users_count = telegram_service.get_status_overview(db)
    return TelegramStatusRead(
        enabled=enabled,
        mode=settings.telegram_mode,
        linked_users_count=linked_users_count,
    )


@router.post("/link", response_model=TelegramLinkCodeRead)
def create_telegram_link_code(
    current_user: User = Depends(get_current_user),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> TelegramLinkCodeRead:
    return telegram_service.issue_link_code(db, current_user)


@router.get("/link/me", response_model=TelegramLinkRead | None)
def get_my_telegram_link(
    current_user: User = Depends(get_current_user),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> TelegramLinkRead | None:
    link = telegram_service.get_link_for_user(db, current_user)
    if link is None:
        return None
    return TelegramLinkRead.model_validate(link)


@router.delete("/link/{link_id}", response_model=TelegramTestMessageResponse)
def delete_telegram_link(
    link_id: int,
    current_user: User = Depends(get_current_user),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> TelegramTestMessageResponse:
    telegram_service.unlink(db, link_id, current_user)
    return TelegramTestMessageResponse()


@router.post("/test-message", response_model=TelegramTestMessageResponse)
def send_telegram_test_message(
    current_user: User = Depends(get_current_user),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> TelegramTestMessageResponse:
    telegram_service.send_test_message_for_user(db, current_user)
    return TelegramTestMessageResponse()


@router.post("/bot/link/complete", response_model=TelegramLinkRead)
def complete_bot_link(
    payload: TelegramLinkCompleteRequest,
    _: str = Depends(require_telegram_bot_secret),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> TelegramLinkRead:
    link, _user = telegram_service.complete_link(
        db,
        link_code=payload.link_code,
        telegram_user_id=payload.telegram_user_id,
        chat_id=payload.chat_id,
    )
    return TelegramLinkRead.model_validate(link)


@router.post("/bot/status", response_model=TelegramStatusCommandRead)
def get_bot_status(
    payload: TelegramCommandIdentity,
    _: str = Depends(require_telegram_bot_secret),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> TelegramStatusCommandRead:
    return telegram_service.get_status_for_linked_user(db, payload.telegram_user_id)


@router.post("/bot/services", response_model=TelegramServicesCommandRead)
def get_bot_services(
    payload: TelegramServicesQuery,
    _: str = Depends(require_telegram_bot_secret),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> TelegramServicesCommandRead:
    return telegram_service.get_services_for_linked_user(
        db,
        payload.telegram_user_id,
        payload.server_name,
    )


@router.post("/bot/restart", response_model=ActionRead)
def restart_from_bot(
    payload: TelegramRestartRequest,
    _: str = Depends(require_telegram_bot_secret),
    telegram_service: TelegramService = Depends(get_telegram_service),
    db: Session = Depends(get_db),
) -> ActionRead:
    action = telegram_service.restart_service_for_linked_user(
        db,
        telegram_user_id=payload.telegram_user_id,
        server_name=payload.server_name,
        service_name=payload.service_name,
    )
    return ActionRead.model_validate(action)