"""Student-specific endpoints."""

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

from app.api.deps import get_current_admin, get_current_user, get_db, require_user_type
from app.models.user import User, UserType
from app.schemas.common import SuccessResponse

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


@router.get("/me", response_model=SuccessResponse)
async def get_student_profile(
    current_user_data: dict = Depends(require_user_type(UserType.GLOBAL_UNDERGRADUATE)),
):
    """Get current student's profile."""
    from datetime import datetime
    from app.schemas.user import UserResponse
    
    user = current_user_data.get("user")
    
    # Convert User to dict matching UserResponse schema
    user_dict = {
        "id": str(user.id),
        "email": user.email,
        "userType": user.user_type.value,
        "matricNumber": user.matric_number,
        "applicationId": user.application_id,
        "isActive": user.is_active,
        "lastLogin": user.last_login.isoformat() if user.last_login else None,
        "createdAt": user.created_at.isoformat() if user.created_at else datetime.utcnow().isoformat(),
        "updatedAt": user.updated_at.isoformat() if user.updated_at else datetime.utcnow().isoformat(),
    }
    
    return SuccessResponse(
        data=UserResponse.model_validate(user_dict).model_dump(),
        message="Student profile retrieved successfully",
    )


@router.get("/me/courses", response_model=SuccessResponse)
async def get_student_courses(
    current_user_data: dict = Depends(require_user_type(UserType.GLOBAL_UNDERGRADUATE)),
    db: Session = Depends(get_db),
):
    """Get current student's enrolled courses."""
    from app.models.academic import Enrollment, EnrollmentStatus
    from app.schemas.academic import EnrollmentResponse
    
    user = current_user_data.get("user")
    enrollments = db.query(Enrollment).filter(
        Enrollment.student_id == user.id,
        Enrollment.status == EnrollmentStatus.ACTIVE,
    ).all()
    
    return SuccessResponse(
        data=[EnrollmentResponse.model_validate(e).model_dump() for e in enrollments],
        message="Courses retrieved successfully",
    )


@router.get("/me/results", response_model=SuccessResponse)
async def get_student_results(
    current_user_data: dict = Depends(require_user_type(UserType.GLOBAL_UNDERGRADUATE)),
    db: Session = Depends(get_db),
):
    """Get current student's academic results."""
    from app.models.academic import Enrollment
    from app.schemas.academic import EnrollmentResponse
    
    user = current_user_data.get("user")
    enrollments = db.query(Enrollment).filter(
        Enrollment.student_id == user.id,
    ).all()
    
    # Filter enrollments with grades
    results = [e for e in enrollments if e.grade is not None]
    
    return SuccessResponse(
        data=[EnrollmentResponse.model_validate(e).model_dump() for e in results],
        message="Results retrieved successfully",
    )


@router.get("/me/payments", response_model=SuccessResponse)
async def get_student_payments(
    current_user_data: dict = Depends(require_user_type(UserType.GLOBAL_UNDERGRADUATE)),
    db: Session = Depends(get_db),
):
    """Get current student's payment history."""
    from app.models.finance import StudentLedger, LedgerEntryStatus
    from app.schemas.finance import StudentLedgerResponse
    
    user = current_user_data.get("user")
    payments = db.query(StudentLedger).filter(
        StudentLedger.student_id == user.id,
        StudentLedger.status == LedgerEntryStatus.PAID,
    ).order_by(StudentLedger.paid_date.desc()).all()
    
    return SuccessResponse(
        data=[StudentLedgerResponse.model_validate(p).model_dump() for p in payments],
        message="Payment history retrieved successfully",
    )


@router.get("", response_model=SuccessResponse)
async def list_students(
    department: Optional[str] = Query(None),
    status: Optional[str] = Query(None),
    db: Session = Depends(get_db),
    current_admin = Depends(get_current_admin),
):
    """List all students with optional filters (admin/registrar only)."""
    from app.models.academic import Enrollment, EnrollmentStatus, Programme
    
    query = db.query(User).filter(User.user_type == UserType.GLOBAL_UNDERGRADUATE)
    
    # If department filter, join with enrollments and programmes
    if department:
        query = (
            query.join(Enrollment, Enrollment.student_id == User.id)
            .join(Programme, Programme.id == Enrollment.programme_id)
            .filter(Programme.department == department)
        )
    
    # Status filter would be on enrollment status
    if status:
        if status == "active":
            query = query.join(Enrollment, Enrollment.student_id == User.id).filter(
                Enrollment.status == EnrollmentStatus.ACTIVE
            )
    
    students = query.distinct().all()
    
    # Transform to include enrollment info
    result = []
    for student in students:
        student_dict = {
            "id": str(student.id),
            "email": student.email,
            "matricNumber": student.matric_number,
            "applicationId": student.application_id,
            "isActive": student.is_active,
            "createdAt": student.created_at.isoformat() if student.created_at else None,
        }
        result.append(student_dict)
    
    return SuccessResponse(
        data=result,
        message="Students retrieved successfully",
    )