from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import List
from app.db.session import get_db
from app.models.user import User
from app.models.tutor_session import TutorSession
from app.models.tutor_message import TutorMessage
from app.schemas.tutor_session import (
    TutorSessionCreate, 
    TutorSessionUpdate, 
    TutorSession as TutorSessionSchema
)
from app.schemas.tutor_message import (
    TutorMessageCreate, 
    TutorMessage as TutorMessageSchema
)
from app.api.auth import get_current_user

router = APIRouter()


@router.post("/sessions", response_model=TutorSessionSchema)
def create_tutor_session(
    session: TutorSessionCreate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    db_session = TutorSession(
        user_id=current_user.id,
        subject=session.subject,
        topic=session.topic,
        difficulty_level=session.difficulty_level
    )
    db.add(db_session)
    db.commit()
    db.refresh(db_session)
    return db_session


@router.get("/sessions", response_model=List[TutorSessionSchema])
def get_user_sessions(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    return db.query(TutorSession).filter(
        TutorSession.user_id == current_user.id
    ).all()


@router.get("/sessions/{session_id}", response_model=TutorSessionSchema)
def get_session(
    session_id: int,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    session = db.query(TutorSession).filter(
        TutorSession.id == session_id,
        TutorSession.user_id == current_user.id
    ).first()
    if not session:
        raise HTTPException(status_code=404, detail="Session not found")
    return session


@router.put("/sessions/{session_id}", response_model=TutorSessionSchema)
def update_session(
    session_id: int,
    session_update: TutorSessionUpdate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    session = db.query(TutorSession).filter(
        TutorSession.id == session_id,
        TutorSession.user_id == current_user.id
    ).first()
    if not session:
        raise HTTPException(status_code=404, detail="Session not found")
    
    update_data = session_update.dict(exclude_unset=True)
    for field, value in update_data.items():
        setattr(session, field, value)
    
    db.commit()
    db.refresh(session)
    return session


@router.post("/sessions/{session_id}/messages", response_model=TutorMessageSchema)
def add_message_to_session(
    session_id: int,
    message: TutorMessageCreate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    session = db.query(TutorSession).filter(
        TutorSession.id == session_id,
        TutorSession.user_id == current_user.id
    ).first()
    if not session:
        raise HTTPException(status_code=404, detail="Session not found")
    
    db_message = TutorMessage(
        session_id=session_id,
        message_type=message.message_type,
        content=message.content
    )
    db.add(db_message)
    db.commit()
    db.refresh(db_message)
    return db_message


@router.get("/sessions/{session_id}/messages", response_model=List[TutorMessageSchema])
def get_session_messages(
    session_id: int,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    session = db.query(TutorSession).filter(
        TutorSession.id == session_id,
        TutorSession.user_id == current_user.id
    ).first()
    if not session:
        raise HTTPException(status_code=404, detail="Session not found")
    
    return db.query(TutorMessage).filter(
        TutorMessage.session_id == session_id
    ).order_by(TutorMessage.created_at).all()