"""Registrar endpoints for academic sessions, calendar, and statistics."""

from typing import Optional
from uuid import UUID

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

from app.api.deps import get_current_admin, get_db, require_user_type
from app.models.academic import AcademicSession, Course, Enrollment, Programme
from app.models.user import User, UserType
from app.schemas.academic import AcademicSessionResponse
from app.schemas.common import SuccessResponse

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


@router.get("/sessions", response_model=SuccessResponse)
async def list_sessions(
    is_current: Optional[bool] = Query(None),
    db: Session = Depends(get_db),
    current_user = Depends(require_user_type(UserType.REGISTRAR_OPERATIONS)),
):
    """List academic sessions (registrar only)."""
    query = db.query(AcademicSession)
    
    if is_current is not None:
        query = query.filter(AcademicSession.is_current == is_current)
    
    sessions = query.order_by(AcademicSession.start_date.desc()).all()
    
    return SuccessResponse(
        data=[AcademicSessionResponse.model_validate(s).model_dump() for s in sessions],
        message="Academic sessions retrieved successfully",
    )


@router.post("/sessions", response_model=SuccessResponse, status_code=status.HTTP_201_CREATED)
async def create_session(
    session_data: dict,
    db: Session = Depends(get_db),
    current_user = Depends(require_user_type(UserType.REGISTRAR_OPERATIONS)),
):
    """Create or update academic session (registrar only)."""
    from datetime import date
    from app.models.academic import AcademicSession
    
    # If setting as current, unset all others
    if session_data.get("is_current"):
        db.query(AcademicSession).update({"is_current": False})
    
    session = AcademicSession(
        name=session_data["name"],
        start_date=date.fromisoformat(session_data["start_date"]) if isinstance(session_data["start_date"], str) else session_data["start_date"],
        end_date=date.fromisoformat(session_data["end_date"]) if isinstance(session_data["end_date"], str) else session_data["end_date"],
        is_current=session_data.get("is_current", False),
    )
    db.add(session)
    db.commit()
    db.refresh(session)
    
    return SuccessResponse(
        data=AcademicSessionResponse.model_validate(session).model_dump(),
        message="Academic session created successfully",
    )


@router.get("/calendar", response_model=SuccessResponse)
async def get_academic_calendar(
    academic_session_id: Optional[UUID] = Query(None),
    db: Session = Depends(get_db),
):
    """Get academic calendar events."""
    # For now, return basic structure
    # In production, this would query a calendar_events table
    events = [
        {
            "id": "1",
            "title": "Registration Begins",
            "date": "2024-09-01",
            "type": "registration",
        },
        {
            "id": "2",
            "title": "Lectures Begin",
            "date": "2024-09-15",
            "type": "academic",
        },
        {
            "id": "3",
            "title": "Mid-Semester Break",
            "date": "2024-10-20",
            "type": "holiday",
        },
        {
            "id": "4",
            "title": "Examinations Begin",
            "date": "2024-12-01",
            "type": "examination",
        },
    ]
    
    return SuccessResponse(
        data=events,
        message="Academic calendar retrieved successfully",
    )


@router.get("/stats", response_model=SuccessResponse)
async def get_registrar_stats(
    db: Session = Depends(get_db),
    current_user = Depends(require_user_type(UserType.REGISTRAR_OPERATIONS)),
):
    """Get registrar dashboard statistics."""
    # Total active programmes
    total_programmes = db.query(Programme).filter(Programme.is_active == True).count()
    
    # Total students
    total_students = db.query(User).filter(User.user_type == UserType.GLOBAL_UNDERGRADUATE).count()
    
    # Students by department
    from app.models.academic import Enrollment
    students_by_dept = (
        db.query(Programme.department, func.count(func.distinct(Enrollment.student_id)))
        .join(Enrollment, Programme.id == Enrollment.programme_id)
        .group_by(Programme.department)
        .all()
    )
    dept_stats = {dept: count for dept, count in students_by_dept}
    
    # Total courses
    total_courses = db.query(Course).filter(Course.is_active == True).count()
    
    # Active enrollments
    from app.models.academic import EnrollmentStatus
    active_enrollments = db.query(Enrollment).filter(Enrollment.status == EnrollmentStatus.ACTIVE).count()
    
    # Current academic session
    current_session = db.query(AcademicSession).filter(AcademicSession.is_current == True).first()
    current_session_name = current_session.name if current_session else None
    
    return SuccessResponse(
        data={
            "total_programmes": total_programmes,
            "total_students": total_students,
            "students_by_department": dept_stats,
            "total_courses": total_courses,
            "active_enrollments": active_enrollments,
            "current_session": current_session_name,
        },
        message="Registrar statistics retrieved successfully",
    )