"""Service pour logger les appels IA."""

from typing import Optional, Dict, Any
import time
from models.ai_log import AILog
from models.user import db


class AILoggingService:
    """Service pour enregistrer les appels IA dans la base de données."""
    
    @staticmethod
    def log_ai_call(
        call_type: str,
        prompt: str,
        response: Optional[str] = None,
        story_id: Optional[str] = None,
        turn_id: Optional[str] = None,
        model: Optional[str] = None,
        temperature: Optional[float] = None,
        max_tokens: Optional[int] = None,
        prompt_tokens: Optional[int] = None,
        completion_tokens: Optional[int] = None,
        total_tokens: Optional[int] = None,
        response_time_ms: Optional[int] = None,
        success: bool = True,
        error_message: Optional[str] = None
    ) -> AILog:
        """Enregistre un appel IA dans la base de données.
        
        Args:
            call_type: Type d'appel ('pitch_analysis', 'narrative_skeleton', etc.)
            prompt: Prompt envoyé à l'IA
            response: Réponse reçue
            story_id: ID de l'histoire (optionnel)
            turn_id: ID du tour (optionnel)
            model: Modèle utilisé
            temperature: Température utilisée
            max_tokens: Max tokens configuré
            prompt_tokens: Tokens du prompt
            completion_tokens: Tokens de la completion
            total_tokens: Total des tokens
            response_time_ms: Temps de réponse en ms
            success: Succès ou échec
            error_message: Message d'erreur (si échec)
        
        Returns:
            L'objet AILog créé
        """
        log = AILog(
            story_id=story_id,
            turn_id=turn_id,
            call_type=call_type,
            prompt=prompt,
            response=response,
            model=model,
            temperature=temperature,
            max_tokens=max_tokens,
            prompt_tokens=prompt_tokens,
            completion_tokens=completion_tokens,
            total_tokens=total_tokens,
            response_time_ms=response_time_ms,
            success=success,
            error_message=error_message
        )
        
        db.session.add(log)
        db.session.commit()
        
        return log
    
    @staticmethod
    def get_logs_for_story(story_id: str) -> list[AILog]:
        """Récupère tous les logs pour une histoire donnée.
        
        Args:
            story_id: ID de l'histoire
        
        Returns:
            Liste des logs triés par date
        """
        return AILog.query.filter_by(story_id=story_id)\
            .order_by(AILog.created_at.asc())\
            .all()
    
    @staticmethod
    def get_logs_for_turn(turn_id: str) -> list[AILog]:
        """Récupère tous les logs pour un tour donné.
        
        Args:
            turn_id: ID du tour
        
        Returns:
            Liste des logs triés par date
        """
        return AILog.query.filter_by(turn_id=turn_id)\
            .order_by(AILog.created_at.asc())\
            .all()