from typing import List
from fastapi import APIRouter, Depends, HTTPException
from sqlmodel import Session, select
from database import get_session
from models import Report, User, PerformanceNickname
from schemas import ReportCreate, ReportRead, PerformanceNicknameRead
from auth import get_current_user
from dependencies import RoleChecker

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

allow_moderator = RoleChecker(["moderator", "admin"])

@router.post("/reports", response_model=ReportRead)
def create_report(
    report: ReportCreate,
    session: Session = Depends(get_session),
    current_user: User = Depends(get_current_user)
):
    db_report = Report.model_validate(report)
    db_report.user_id = current_user.id
    session.add(db_report)
    session.commit()
    session.refresh(db_report)
    return db_report

@router.get("/queue/nicknames", response_model=List[PerformanceNicknameRead], dependencies=[Depends(allow_moderator)])
def get_pending_nicknames(session: Session = Depends(get_session)):
    nicknames = session.exec(
        select(PerformanceNickname).where(PerformanceNickname.status == "pending")
    ).all()
    return nicknames

@router.put("/nicknames/{nickname_id}/{action}", response_model=PerformanceNicknameRead, dependencies=[Depends(allow_moderator)])
def moderate_nickname(
    nickname_id: int, 
    action: str, # approve, reject
    session: Session = Depends(get_session)
):
    nickname = session.get(PerformanceNickname, nickname_id)
    if not nickname:
        raise HTTPException(status_code=404, detail="Nickname not found")
    
    if action == "approve":
        nickname.status = "approved"
    elif action == "reject":
        nickname.status = "rejected"
    else:
        raise HTTPException(status_code=400, detail="Invalid action")
        
    session.add(nickname)
    session.commit()
    session.refresh(nickname)
    return nickname

@router.get("/queue/reports", response_model=List[ReportRead], dependencies=[Depends(allow_moderator)])
def get_pending_reports(session: Session = Depends(get_session)):
    reports = session.exec(
        select(Report).where(Report.status == "pending")
    ).all()
    return reports

@router.put("/reports/{report_id}/{action}", response_model=ReportRead, dependencies=[Depends(allow_moderator)])
def moderate_report(
    report_id: int, 
    action: str, # resolve, dismiss
    session: Session = Depends(get_session)
):
    report = session.get(Report, report_id)
    if not report:
        raise HTTPException(status_code=404, detail="Report not found")
    
    if action == "resolve":
        report.status = "resolved"
    elif action == "dismiss":
        report.status = "dismissed"
    else:
        raise HTTPException(status_code=400, detail="Invalid action")
        
    session.add(report)
    session.commit()
    session.refresh(report)
    return report