from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from typing import List
from uuid import UUID

from app.api.dependencies import get_db
from app.services.history_manager import HistoryManager
from app.services.chat_service import ChatService
from app.models.schemas import (
    SessionCreate, SessionResponse, ChatMessageRequest, ChatMessageResponse
)

router = APIRouter()

@router.post("/sessions", response_model=SessionResponse, status_code=status.HTTP_201_CREATED)
def create_session(session_in: SessionCreate, db: Session = Depends(get_db)):
    # For now, we assume a default user or handle auth separately.
    # Using a hardcoded user ID for demonstration if no auth middleware.
    # In production, get user_id from current_user.
    import uuid
    # Placeholder user ID. In real app, ensure user exists.
    # We might need to create a default user if not exists or require auth.
    # For this task, we'll create a dummy user if needed or just use a random UUID 
    # but that might fail FK constraint if user doesn't exist.
    # Let's assume we need to create a user first or use an existing one.
    # For simplicity, we'll generate a UUID but this will fail FK.
    # So we should probably have a "get_or_create_default_user" helper.
    
    # Quick fix: Create a default user if table is empty or just use a fixed ID 
    # and ensure it exists in startup event.
    # For now, let's just use a fixed UUID and assume the user exists or we create it.
    # Actually, let's just create a user on the fly for this session if we don't have auth.
    
    manager = HistoryManager(db)
    # Check if we have any user, if not create one.
    from app.models.models import User
    user = db.query(User).first()
    if not user:
        user = User(username="default_user", email="default@example.com")
        db.add(user)
        db.commit()
        db.refresh(user)
    
    session = manager.create_session(
        user_id=user.id,
        title=session_in.title,
        rag_config=session_in.rag_config
    )
    return session

@router.get("/sessions", response_model=List[SessionResponse])
def list_sessions(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    manager = HistoryManager(db)
    # Again, need user_id. Using the default user strategy.
    from app.models.models import User
    user = db.query(User).first()
    if not user:
        return []
        
    sessions = manager.list_sessions(user_id=user.id, skip=skip, limit=limit)
    return sessions

@router.get("/sessions/{session_id}/history")
def get_session_history(session_id: UUID, db: Session = Depends(get_db)):
    manager = HistoryManager(db)
    # This returns context format, might need a different schema for full history display
    # For now reusing get_conversation_context logic but maybe we want full objects.
    # Let's just return the raw messages for now or map to a schema.
    # The requirement said "Get full history".
    from app.models.models import ChatMessage
    messages = db.query(ChatMessage).filter(ChatMessage.session_id == session_id).order_by(ChatMessage.created_at.asc()).all()
    return messages