"""User management endpoints."""

from datetime import datetime
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
from app.schemas.user import UserCreate, UserResponse
from app.schemas.common import SuccessResponse
from app.models.user import User, UserType
from app.utils.security import get_password_hash


def user_to_response_dict(user: User) -> dict:
    """Convert User model to dict matching UserResponse schema."""
    return {
        "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(),
    }

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


@router.post("", response_model=SuccessResponse, status_code=status.HTTP_201_CREATED)
async def create_user(
    user_data: UserCreate,
    db: Session = Depends(get_db),
    current_admin = Depends(get_current_admin),
):
    """Create a new user (admin only)."""
    # Check if user already exists
    existing_user = db.query(User).filter(User.email == user_data.email).first()
    if existing_user:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="User with this email already exists",
        )
    
    # Create user
    user = User(
        email=user_data.email,
        password_hash=get_password_hash(user_data.password),
        user_type=user_data.user_type,
        matric_number=user_data.matric_number,
        application_id=user_data.application_id,
        is_active=True,
    )
    
    db.add(user)
    db.commit()
    db.refresh(user)
    
    return SuccessResponse(
        data=UserResponse.model_validate(user_to_response_dict(user)).model_dump(),
        message="User created successfully",
    )


@router.get("/me", response_model=SuccessResponse)
async def get_current_user_info(
    current_user_data: dict = Depends(get_current_user),
):
    """Get current authenticated user information."""
    user_data = current_user_data
    
    if user_data.get("type") == "admin":
        from app.schemas.admin import AdminResponse
        return SuccessResponse(
            data=AdminResponse.model_validate(user_data.get("user")).model_dump(),
            message="User retrieved successfully",
        )
    else:
        user = user_data.get("user")
        return SuccessResponse(
            data=UserResponse.model_validate(user_to_response_dict(user)).model_dump(),
            message="User retrieved successfully",
        )


@router.get("", response_model=SuccessResponse)
async def list_users(
    user_type: Optional[UserType] = Query(None),
    db: Session = Depends(get_db),
    current_admin = Depends(get_current_admin),
):
    """List users with optional filter by user type (admin only)."""
    query = db.query(User)
    
    if user_type:
        query = query.filter(User.user_type == user_type)
    
    users = query.all()
    
    return SuccessResponse(
        data=[UserResponse.model_validate(user_to_response_dict(u)).model_dump() for u in users],
        message="Users retrieved successfully",
    )


@router.get("/{user_id}", response_model=SuccessResponse)
async def get_user(
    user_id: str,
    db: Session = Depends(get_db),
    current_admin = Depends(get_current_admin),
):
    """Get user by ID (admin only)."""
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="User not found",
        )
    
    return SuccessResponse(
        data=UserResponse.model_validate(user_to_response_dict(user)).model_dump(),
        message="User retrieved successfully",
    )