"""
Exemple d'utilisation du système d'agents Ollama.
Ce script montre comment configurer et utiliser différents types d'agents
basés sur les modèles Ollama disponibles sur votre serveur.
"""

from ollama_models import (
    AgentSystem, 
    create_text_agent,
    create_multimodal_agent,
    create_embedding_agent,
    OllamaModel
)


def configurer_systeme_agents():
    """Configure et retourne un système d'agents avec différents modèles."""
    
    # Créer le système d'agents
    system = AgentSystem()
    
    # Ajouter un agent de génération de texte avec Llama 3.3
    create_text_agent(
        agent_id="assistant_texte",
        model_name="llama3.3:70b-instruct-q8_0",
        system=system,
        temperature=0.7,
        top_p=0.9,
        num_ctx=4096,
        stream=True
    )
    
    # Ajouter un agent spécialisé pour le code avec température basse
    create_text_agent(
        agent_id="assistant_code",
        model_name="qwen2.5-coder:32b-instruct-fp16",
        system=system,
        temperature=0.2,  # Température basse pour des réponses plus déterministes
        top_p=0.8,
        top_k=40,
        num_ctx=8192,  # Contexte plus large pour les tâches de code
        stream=True
    )
    
    # Ajouter un agent multimodal pour l'analyse d'images
    create_multimodal_agent(
        agent_id="assistant_vision",
        model_name="llama3.2-vision:90b-instruct-q8_0",
        system=system,
        temperature=0.8,
        num_ctx=8192,
        stream=False  # Désactiver le streaming pour les modèles vision
    )
    
    # Ajouter un agent d'embedding
    create_embedding_agent(
        agent_id="agent_embedding",
        model_name="nomic-embed-text:137m-v1.5-fp16",
        system=system,
        stream=False  # Les embeddings ne nécessitent pas de streaming
    )
    
    return system


def exemple_generation_texte(system):
    """Exemple d'utilisation d'un agent de génération de texte."""
    
    print("\n=== EXEMPLE GÉNÉRATION DE TEXTE ===")
    
    # Récupérer l'agent
    agent = system.get_agent("assistant_texte")
    
    if agent:
        # Générer du texte
        prompt = "Explique-moi les avantages des architectures basées sur les transformers en IA."
        print(f"Demande: {prompt}")
        print("\nRéponse:")
        
        # Utiliser l'API de génération
        agent.generate(prompt)
    else:
        print("Agent 'assistant_texte' non trouvé.")


def exemple_generation_code(system):
    """Exemple d'utilisation d'un agent spécialisé pour le code."""
    
    print("\n=== EXEMPLE GÉNÉRATION DE CODE ===")
    
    # Récupérer l'agent
    agent = system.get_agent("assistant_code")
    
    if agent:
        # Modifier temporairement certains paramètres pour cette requête
        agent.update_options(temperature=0.1, num_predict=500)
        
        # Générer du code
        prompt = "Écris une fonction Python pour calculer le nombre de Fibonacci de manière récursive avec mémoïsation."
        print(f"Demande: {prompt}")
        print("\nRéponse:")
        
        # Utiliser l'API de génération
        agent.generate(prompt)
        
        # Remettre les paramètres par défaut
        agent.update_options(temperature=0.2, num_predict=128)
    else:
        print("Agent 'assistant_code' non trouvé.")


def exemple_chat(system):
    """Exemple d'utilisation de l'API chat."""
    
    print("\n=== EXEMPLE CHAT ===")
    
    # Récupérer l'agent
    agent = system.get_agent("assistant_texte")
    
    if agent:
        # Créer une conversation
        messages = [
            {"role": "system", "content": "Tu es un assistant IA serviable, concis et précis."},
            {"role": "user", "content": "Quels sont les 3 principaux avantages des modèles Ollama par rapport aux API cloud?"}
        ]
        
        print("Conversation:")
        for msg in messages:
            print(f"{msg['role']}: {msg['content']}")
        
        print("\nRéponse:")
        
        # Utiliser l'API chat
        response = agent.chat(messages)
        
        # Ajouter la réponse à l'historique
        if isinstance(response, str):
            messages.append({"role": "assistant", "content": response})
        elif isinstance(response, dict) and "message" in response and "content" in response["message"]:
            messages.append({"role": "assistant", "content": response["message"]["content"]})
            
        # Continuer la conversation
        messages.append({"role": "user", "content": "Et quels sont les inconvénients?"})
        
        print("\nUtilisateur: Et quels sont les inconvénients?")
        print("\nRéponse:")
        
        # Continuer avec l'API chat
        agent.chat(messages)
    else:
        print("Agent 'assistant_texte' non trouvé.")


def exemple_embeddings(system):
    """Exemple d'utilisation de l'agent d'embedding."""
    
    print("\n=== EXEMPLE EMBEDDINGS ===")
    
    # Récupérer l'agent
    agent = system.get_agent("agent_embedding")
    
    if agent:
        # Textes à encoder
        textes = [
            "Les modèles de langage sont très utiles pour l'IA moderne.",
            "Les embeddings permettent de représenter du texte en vecteurs numériques."
        ]
        
        print("Génération d'embeddings pour les textes suivants:")
        for i, texte in enumerate(textes):
            print(f"{i+1}. {texte}")
        
        # Obtenir les embeddings
        embeddings = agent.get_embeddings(textes)
        
        # Afficher les dimensions des embeddings
        if embeddings:
            print(f"\nEmbeddings générés avec succès!")
            print(f"Nombre d'embeddings: {len(embeddings)}")
            print(f"Dimension de chaque embedding: {len(embeddings[0])}")
            print(f"Premiers éléments du premier embedding: {embeddings[0][:5]}...")
        else:
            print("Échec de la génération des embeddings.")
    else:
        print("Agent 'agent_embedding' non trouvé.")


def exemple_vision(system):
    """Exemple d'utilisation de l'agent de vision (nécessite un fichier image)."""
    
    print("\n=== EXEMPLE VISION (NÉCESSITE UNE IMAGE) ===")
    
    # Récupérer l'agent
    agent = system.get_agent("assistant_vision")
    
    if agent:
        print("Pour tester l'agent de vision, vous devez fournir un chemin vers une image.")
        print("Exemple d'utilisation:")
        print("```python")
        print("image_path = 'chemin/vers/votre/image.jpg'")
        print("prompt = 'Décris cette image en détail.'")
        print("response = agent.analyze_image(prompt, image_path)")
        print("```")
    else:
        print("Agent 'assistant_vision' non trouvé.")


def afficher_modeles_disponibles():
    """Affiche la liste des modèles Ollama disponibles."""
    
    print("\n=== MODÈLES OLLAMA DISPONIBLES ===")
    
    # Obtenir la liste des modèles
    models = OllamaModel.list_models()
    
    if "error" in models:
        print(f"Erreur lors de la récupération des modèles: {models['error']}")
        return
    
    # Afficher les modèles
    if "models" in models:
        for i, model in enumerate(models["models"]):
            print(f"{i+1}. {model['name']} ({model['size']})")
    else:
        print("Aucun modèle trouvé ou format de réponse inattendu.")


def main():
    """Fonction principale."""
    
    print("=== SYSTÈME D'AGENTS OLLAMA ===")
    
    # Afficher les modèles disponibles
    afficher_modeles_disponibles()
    
    # Configurer le système d'agents
    system = configurer_systeme_agents()
    
    # Lister les agents configurés
    agents = system.list_agents()
    print("\n=== AGENTS CONFIGURÉS ===")
    for agent_id, model_name in agents.items():
        print(f"Agent: {agent_id}, Modèle: {model_name}")
    
    # Exemples d'utilisation
    try:
        exemple_generation_texte(system)
        exemple_generation_code(system)
        exemple_chat(system)
        exemple_embeddings(system)
        exemple_vision(system)
    except Exception as e:
        print(f"\nUne erreur s'est produite: {str(e)}")
    
    print("\n=== FIN DES EXEMPLES ===")


if __name__ == "__main__":
    main() 