from fastapi import APIRouter, Depends, Query, HTTPException
from sqlalchemy.orm import Session

from app import crud
from app.logging_utils import get_logger
from app.models import User
from app.routes import get_db, get_admin_user
from app.schemas import AdminUserDecisionRequest
from app.services import admin_dashboard_service

logger = get_logger(__name__)

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


@router.get("/users")
def admin_list_users(
    approval_status: str | None = Query(default=None),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_admin_user),
):
    users = crud.list_users(db, approval_status=approval_status)
    logger.info(
        "Admin user %s requested the user list. Approval status filter: %s. Users returned: %s.",
        current_user.id,
        approval_status,
        len(users),
    )
    return {
        "success": True,
        "data": [
            {
                "id": user.id,
                "email": user.email,
                "name": user.name,
                "role": user.role,
                "approval_status": user.approval_status,
                "calendar_sync_enabled": user.calendar_sync_enabled,
                "approved_at": user.approved_at.isoformat() if user.approved_at else None,
                "approved_by": user.approved_by,
                "denied_at": user.denied_at.isoformat() if user.denied_at else None,
            }
            for user in users
        ],
        "meta": {
            "requested_by": current_user.id,
            "approval_status": approval_status,
        },
    }


@router.post("/users/{user_id}/decision")
def admin_decide_user(
    user_id: int,
    payload: AdminUserDecisionRequest,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_admin_user),
):
    logger.info(
        "Admin user %s requested a user decision for user %s. Action: %s.",
        current_user.id,
        user_id,
        payload.action,
    )
    target_user = db.query(User).filter(User.id == user_id).first()
    if not target_user:
        raise HTTPException(status_code=404, detail="User not found")
    if target_user.role == "admin":
        raise HTTPException(status_code=400, detail="Admin user cannot be updated from this endpoint")

    action = (payload.action or "").strip().lower()
    if action == "approve":
        user = crud.approve_user(db, user_id, current_user.id)
        message = "User approved successfully"
    elif action == "deny":
        if current_user.id == user_id:
            raise HTTPException(status_code=400, detail="Admin cannot deny themselves")
        user = crud.deny_user(db, user_id)
        message = "User denied successfully"
    else:
        raise HTTPException(status_code=400, detail="Invalid action. Use 'approve' or 'deny'")

    logger.info(
        "User %s was updated by admin %s. New approval status: %s.",
        user.id,
        current_user.id,
        user.approval_status,
    )

    return {
        "success": True,
        "message": message,
        "data": {
            "id": user.id,
            "email": user.email,
            "role": user.role,
            "approval_status": user.approval_status,
            "approved_at": user.approved_at.isoformat() if user.approved_at else None,
            "approved_by": user.approved_by,
            "denied_at": user.denied_at.isoformat() if user.denied_at else None,
        },
    }


@router.get("/dashboard")
def admin_dashboard(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_admin_user),
):
    logger.info("Admin dashboard statistics were requested by admin %s.", current_user.id)
    return {
        "success": True,
        "data": admin_dashboard_service.get_admin_dashboard_stats(db),
    }


@router.get("/recording-usage")
def admin_recording_usage(
    frequency: str = "daily",
    db: Session = Depends(get_db),
    current_user: User = Depends(get_admin_user),
):
    logger.info(
        "Admin recording usage was requested by admin %s. Frequency: %s.",
        current_user.id,
        frequency,
    )
    try:
        result = admin_dashboard_service.get_admin_recording_usage(db, frequency=frequency)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))
    return {
        "success": True,
        "data": result,
    }


@router.get("/meetings")
def admin_list_meetings(
    page: int = 1,
    limit: int = 12,
    status: str | None = None,
    search: str | None = None,
    platform: str | None = None,
    meeting_type: str | None = Query(None, alias="type"),
    time_filter: str | None = Query(None, alias="time"),
    sort_by: str | None = Query(None, alias="sort_by"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_admin_user),
):
    logger.info(
        "Admin meeting list was requested by admin %s. Page: %s. Limit: %s. Status filter: %s. Search: %s. Platform: %s. Type: %s. Time: %s. Sort: %s.",
        current_user.id,
        page,
        limit,
        status,
        search,
        platform,
        meeting_type,
        time_filter,
        sort_by,
    )
    result = admin_dashboard_service.list_admin_meetings(
        db,
        page=page,
        limit=limit,
        status=status,
        search=search,
        platform=platform,
        meeting_type=meeting_type,
        time_filter=time_filter,
        sort_by=sort_by,
    )
    return {
        "success": True,
        "pagination": result["pagination"],
        "data": result["data"],
    }


@router.get("/meetings/{meeting_id}")
def admin_get_meeting_details(
    meeting_id: int,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_admin_user),
):
    logger.info("Admin meeting details were requested by admin %s for meeting %s.", current_user.id, meeting_id)
    result = admin_dashboard_service.get_admin_meeting_details(db, meeting_id)
    if not result:
        raise HTTPException(status_code=404, detail="Meeting not found")
    return {
        "success": True,
        "data": result,
    }