from typing import Annotated, List
from fastapi import APIRouter, Depends
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.orm import Session
from app.api.student import service
from app.database.main.mysql import get_db
from app.dependency.authantication import JWTPayloadSchema, get_current_student, get_current_user
from .schemas import GetSimulationGroupStudent, PasswordRequest, StudentCreate, StudentResponse ,GroupResponse, StudentUpdate
from fastapi import UploadFile, File

student_router = APIRouter()

# oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/FASTAPI/student/login")
# pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

@student_router.post("/student/creat", response_model_exclude_none=True)
async def create_student(request: StudentCreate, db: Session = Depends(get_db),token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StudentService(db,token).create_student(request)

# @student_router.post("/student/login", response_model_exclude_none=True)
# async def login_student(credentials: Annotated[OAuth2PasswordRequestForm, Depends()],db: Session = Depends(get_db),):
#     return await service.StudentService.student_login(credentials, db)

@student_router.get("/student/get/{student_id}", response_model=StudentResponse, response_model_exclude_none=True)
async def get_student(student_id: int, db: Session = Depends(get_db), token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StudentService(db, token).get_student(student_id)

@student_router.get("/studentGroup/get/{student_id}", response_model= StudentResponse, response_model_exclude_none=True)
async def get_simulation(student_id: int, db: Session = Depends(get_db), token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StudentService(db, token).get_student(student_id)

@student_router.get("/student/{student_id}/group", response_model=GroupResponse, response_model_exclude_none=True)
async def get_student_group(student_id: int, db: Session = Depends(get_db), token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StudentService(db, token).get_student_group(student_id)

@student_router.get("/get_simulation_group_student/{group_code}", response_model=List[GetSimulationGroupStudent], response_model_exclude_none=True)
async def get_simulation_group_student(group_code: str, db: Session = Depends(get_db), token: JWTPayloadSchema = Depends(get_current_user)):
    return await service.StudentService(db, token).get_simulation_group_student(group_code)

@student_router.put("/student/update", response_model_exclude_none=True)
async def update_segment(request: List[StudentUpdate], db: Session = Depends(get_db),token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StudentService(db,token).update_student(request)

@student_router.post("/student/login", response_model_exclude_none=True)
async def login_student(credentials: Annotated[OAuth2PasswordRequestForm, Depends()],db: Session = Depends(get_db),):
    return await service.StudentService.student_login(credentials, db)

@student_router.post("/logout", response_model_exclude_none=True)
async def logout_student(token: JWTPayloadSchema = Depends(get_current_student),db: Session = Depends(get_db)):
    return service.StudentService(db, token).student_logout()

@student_router.get("/download/excel", response_model_exclude_none=True)
async def download_excel(db: Session = Depends(get_db),token: JWTPayloadSchema = Depends(get_current_user)):
    """Download excel file."""
    return await service.StudentService(db, token).download_excel()

@student_router.post("/upload-students-excel")
async def upload_students_excel(file: UploadFile = File(...),db: Session = Depends(get_db),token: JWTPayloadSchema = Depends(get_current_student)):
    return await service.StudentService(db,token).upload_students_from_excel(file)

@student_router.post("/student/send-password")
def send_password(request: PasswordRequest, db: Session = Depends(get_db),token: JWTPayloadSchema = Depends(get_current_student)):
    return service.StudentService(db,token).send_password_to_email(request.student_email)

@student_router.post("/student/send-passwords")
def send_passwords_to_all(db: Session = Depends(get_db), token: JWTPayloadSchema = Depends(get_current_student)):
    return service.StudentService(db, token).send_passwords_to_all_students()


@student_router.get("/send_group_mail")
async def send_group_mail(
    group_code: str,
    db: Session = Depends(get_db),
    token: JWTPayloadSchema = Depends(get_current_student)
):
    service_ = service.StudentService(db, token)
    return await service_.send_group_mail(group_code)