from fastapi import APIRouter, Depends, HTTPException, status, Query
from sqlalchemy.ext.asyncio import AsyncSession
from typing import List, Optional

from app.database import get_db
from app.services.dashboard import DashboardService
from app.schemas.common import MessageResponse
from app.schemas.dashboard import (
    DashboardStatsResponse,
    RevenueChartPoint,
    ActiveRideLocation,
    DriverPerformance,
    PassengerListResponse,
    DriverVerificationResponse,
    RideStatsResponse,
    RideListResponse,
    TransactionListResponse,
    UserGrowthPoint
)
from app.services.auth import get_current_active_user, get_current_admin_user
from app.models.user import User

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

@router.get("/stats", response_model=DashboardStatsResponse)
async def get_dashboard_stats(
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get aggregated dashboard statistics"""
    service = DashboardService(db)
    return await service.get_stats()

@router.get("/revenue", response_model=List[RevenueChartPoint])
async def get_revenue_chart(
    days: int = 30,
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get revenue chart data"""
    service = DashboardService(db)
    return await service.get_revenue_chart(days)

@router.get("/map", response_model=List[ActiveRideLocation])
async def get_active_rides_map(
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get locations of active rides for the map"""
    service = DashboardService(db)
    return await service.get_active_rides()

@router.get("/drivers", response_model=List[DriverPerformance])
async def get_driver_performance(
    limit: int = Query(10, ge=1, le=100),
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get driver performance list"""
    service = DashboardService(db)
    return await service.get_driver_performance(limit)

@router.get("/passengers", response_model=PassengerListResponse)
async def get_passengers(
    page: int = Query(1, ge=1),
    limit: int = Query(10, ge=1, le=100),
    search: Optional[str] = None,
    status: Optional[str] = None,
    sort_by: str = Query("created_at", description="Field to sort by"),
    order: str = Query("desc", description="Sort order: asc or desc"),
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get passenger list for administration"""
    service = DashboardService(db)
    return await service.get_passengers(page, limit, search, status, sort_by, order)

@router.get("/driver-verifications", response_model=DriverVerificationResponse)
async def get_driver_verifications(
    page: int = Query(1, ge=1),
    limit: int = Query(10, ge=1, le=100),
    search: Optional[str] = None,
    status: Optional[str] = None,
    sort_by: str = Query("created_at", description="Field to sort by"),
    order: str = Query("desc", description="Sort order: asc or desc"),
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get driver verification list for administration"""
    service = DashboardService(db)
    return await service.get_driver_verifications(page, limit, search, status, sort_by, order)

@router.get("/rides/stats", response_model=RideStatsResponse)
async def get_ride_stats(
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get summarized ride statistics"""
    service = DashboardService(db)
    return await service.get_ride_stats()

@router.get("/rides", response_model=RideListResponse)
async def get_rides(
    page: int = Query(1, ge=1),
    limit: int = Query(10, ge=1, le=100),
    search: Optional[str] = None,
    status: Optional[str] = None,
    sort_by: str = Query("created_at", description="Field to sort by"),
    order: str = Query("desc", description="Sort order: asc or desc"),
    db: AsyncSession = Depends(get_db)
):
    """Get ride list for administration"""
    service = DashboardService(db)
    return await service.get_rides_list(page, limit, search, status, sort_by, order)

@router.get("/transactions", response_model=TransactionListResponse)
async def get_transactions(
    page: int = Query(1, ge=1),
    limit: int = Query(10, ge=1, le=100),
    search: Optional[str] = None,
    status: Optional[str] = None,
    sort_by: str = Query("created_at", description="Field to sort by"),
    order: str = Query("desc", description="Sort order: asc or desc"),
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get transaction list for administration"""
    service = DashboardService(db)
    return await service.get_transactions(page, limit, search, status, sort_by, order)

@router.post("/driver-verifications/{driver_id}/approve", response_model=MessageResponse)
async def approve_driver_verification(
    driver_id: int,
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Approve a driver verification"""
    service = DashboardService(db)
    from app.models.driver import DriverStatus
    result = await service.update_driver_status(driver_id, DriverStatus.APPROVED)
    return MessageResponse(message=result.get("message", "Driver approved successfully"))

@router.post("/driver-verifications/{driver_id}/reject", response_model=MessageResponse)
async def reject_driver_verification(
    driver_id: int,
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Reject a driver verification"""
    service = DashboardService(db)
    from app.models.driver import DriverStatus
    result = await service.update_driver_status(driver_id, DriverStatus.REJECTED)
    return MessageResponse(message=result.get("message", "Driver rejected"))

@router.get("/reports/user-growth", response_model=List[UserGrowthPoint])
async def get_user_growth_chart(
    current_user: User = Depends(get_current_admin_user),
    db: AsyncSession = Depends(get_db)
):
    """Get user growth chart data"""
    from app.schemas.dashboard import UserGrowthPoint # Import locally to avoid circle if any, or top level
    service = DashboardService(db)
    return await service.get_user_growth()