"""Modèle pour les logs des appels IA."""

import uuid
from datetime import datetime
from typing import Optional
from sqlalchemy import String, Integer, Float, Boolean, Text, DateTime, ForeignKey
from sqlalchemy.orm import Mapped, mapped_column, relationship
from models.user import db


class AILog(db.Model):
    """Modèle pour enregistrer tous les appels à l'IA.
    
    Permet de suivre et analyser les prompts/réponses pour améliorer la qualité narrative.
    """
    
    __tablename__ = 'ai_logs'
    
    id: Mapped[str] = mapped_column(
        String(36),
        primary_key=True,
        default=lambda: str(uuid.uuid4())
    )
    
    # Lien avec l'histoire (optionnel pour certains appels)
    story_id: Mapped[Optional[str]] = mapped_column(
        String(36),
        ForeignKey('stories.id', ondelete='CASCADE'),
        nullable=True
    )
    turn_id: Mapped[Optional[str]] = mapped_column(
        String(36),
        ForeignKey('story_turns.id', ondelete='CASCADE'),
        nullable=True
    )
    
    # Type d'appel IA
    call_type: Mapped[str] = mapped_column(String(50), nullable=False)
    # Types possibles: 'pitch_analysis', 'narrative_skeleton', 'cover_image', 
    #                  'narrative_passage', 'choices_generation', 'lorebook_update'
    
    # Prompt envoyé
    prompt: Mapped[str] = mapped_column(Text, nullable=False)
    
    # Réponse reçue
    response: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
    
    # Métadonnées OpenAI
    model: Mapped[Optional[str]] = mapped_column(String(50), nullable=True)  # gpt-4, dall-e-3, etc.
    temperature: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
    max_tokens: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
    
    # Métriques
    prompt_tokens: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
    completion_tokens: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
    total_tokens: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
    response_time_ms: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)  # Temps de réponse en ms
    
    # Statut
    success: Mapped[bool] = mapped_column(Boolean, default=True)
    error_message: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
    
    # Dates
    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, nullable=False)
    
    # Relations
    story = relationship('Story', backref='ai_logs', lazy=True)
    turn = relationship('StoryTurn', backref='ai_logs', lazy=True)
    
    def to_dict(self) -> dict:
        """Convertit le log en dictionnaire.
        
        Returns:
            Dictionnaire contenant les données du log.
        """
        return {
            'id': str(self.id),
            'story_id': str(self.story_id) if self.story_id else None,
            'turn_id': str(self.turn_id) if self.turn_id else None,
            'call_type': self.call_type,
            'prompt': self.prompt,
            'response': self.response,
            'model': self.model,
            'temperature': self.temperature,
            'max_tokens': self.max_tokens,
            'prompt_tokens': self.prompt_tokens,
            'completion_tokens': self.completion_tokens,
            'total_tokens': self.total_tokens,
            'response_time_ms': self.response_time_ms,
            'success': self.success,
            'error_message': self.error_message,
            'created_at': self.created_at.isoformat() if self.created_at else None
        }