"""System router — endpoints for system-wide settings (maintenance mode)."""

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

from app.core.database import get_db
from app.dependencies import get_current_user
from app.models.user import User
from app.schemas.system import SystemSettingsUpdate, SystemStatusResponse, TruncateRequest, TruncateResponse
from app.services import system_service


def _service_error(e: ValueError | PermissionError) -> HTTPException:
    """Convert service-layer ValueError → 404 and PermissionError → 403."""
    if isinstance(e, PermissionError):
        return HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=str(e))
    return HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))


router = APIRouter()


async def _build_status(db: AsyncSession) -> SystemStatusResponse:
    maintenance = await system_service.get_maintenance_mode(db)
    env_mode = await system_service.get_env_mode(db)
    number_format = await system_service.get_number_format(db)
    return SystemStatusResponse(
        maintenance_mode=maintenance,
        environment_mode=env_mode,
        number_format=number_format,
    )


@router.get("/status", response_model=SystemStatusResponse)
async def get_status(db: AsyncSession = Depends(get_db)) -> SystemStatusResponse:
    """Public endpoint — no auth required. Returns current system status."""
    return await _build_status(db)


@router.patch("/settings", response_model=SystemStatusResponse)
async def update_settings(
    data: SystemSettingsUpdate,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> SystemStatusResponse:
    """Superadmin only — toggle maintenance mode, environment mode, and/or number format."""
    if not current_user.is_superadmin:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only Super Admin can change system settings",
        )
    if data.maintenance_mode is not None:
        await system_service.set_maintenance_mode(db, data.maintenance_mode, current_user.id)
    if data.environment_mode is not None:
        try:
            await system_service.set_env_mode(db, data.environment_mode, current_user.id)
        except ValueError as e:
            raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e))
    if data.number_format is not None:
        try:
            await system_service.set_number_format(db, data.number_format, current_user.id)
        except ValueError as e:
            raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e))
    return await _build_status(db)


@router.post("/truncate", response_model=TruncateResponse)
async def truncate_tables(
    data: TruncateRequest,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> TruncateResponse:
    """Superadmin only, development mode only — truncate operational table group."""
    if not current_user.is_superadmin:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only Super Admin can truncate tables",
        )
    env_mode = await system_service.get_env_mode(db)
    if env_mode != "development":
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Truncate is only allowed in development mode",
        )
    rows_deleted = await system_service.truncate_group(db, data.group)
    return TruncateResponse(
        message=f"Truncated '{data.group}' successfully",
        rows_deleted=rows_deleted,
    )