import requests
import json
import os
from datetime import datetime

# Configuration
MODEL_NAME = "llama3.2-vision:90b-instruct-q8_0"
OLLAMA_URL = "http://217.182.105.173:11434"

def get_model_settings():
    # Endpoint Ollama pour obtenir les informations du modèle
    model_url = f"{OLLAMA_URL}/api/show"
    
    headers = {
        "Content-Type": "application/json"
    }
    
    data = {
        "name": MODEL_NAME
    }
    
    try:
        print(f"🔄 Tentative de récupération des paramètres depuis Ollama...")
        response = requests.post(model_url, headers=headers, json=data)
        
        if response.status_code == 200:
            try:
                # S'assurer que nous avons un JSON valide
                if isinstance(response.text, str):
                    settings = json.loads(response.text)
                else:
                    settings = response.json()
                
                # Créer un dossier 'settings' s'il n'existe pas
                os.makedirs('settings', exist_ok=True)
                
                # Sauvegarder la réponse brute pour debug
                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                raw_filename = f"settings/ollama_raw_{timestamp}.json"
                with open(raw_filename, 'w', encoding='utf-8') as f:
                    json.dump(settings, f, indent=2, ensure_ascii=False)
                print(f"✅ Réponse brute sauvegardée dans: {raw_filename}")
                
                # Créer la configuration avec des valeurs par défaut
                config = {
                    "model_name": MODEL_NAME,
                    "ollama_url": OLLAMA_URL,
                    "parameters": {
                        # Paramètres fondamentaux
                        "temperature": 0.7,
                        "top_p": 0.95,
                        "top_k": 40,
                        
                        # Système de pénalités
                        "repeat_penalty": 1.1,
                        "presence_penalty": 0.2,
                        "frequency_penalty": 0.2,
                        
                        # Paramètres de longueur et contexte
                        "num_predict": 1024,  # alias pour max_tokens
                        "num_keep": 0,        # tokens à conserver
                        "stop": [],           # séquences d'arrêt
                        
                        # Paramètres Mirostat
                        "mirostat": 0,        # 0 = désactivé, 1 = v1, 2 = v2
                        "mirostat_eta": 0.1,  # taux d'apprentissage
                        "mirostat_tau": 5.0,  # cible de surprise
                        
                        # Paramètres de contrôle avancé
                        "logit_bias": {},     # biais pour certains tokens
                        "p_min": 0.05,        # probabilité minimale pour le sampling
                        "repeat_last_n": 64,  # nombre de tokens à considérer pour la pénalité de répétition
                        
                        # Paramètres système
                        "num_ctx": 4096,      # taille du contexte
                        "num_thread": 4,      # threads CPU
                        "num_gpu": 1,         # nombre de GPU
                        "seed": 0,            # graine aléatoire (0 = aléatoire)
                        
                        # Paramètres de streaming
                        "stream": True,       # activation du streaming
                        
                        # Optimisations mémoire
                        "mmap": True,         # utilisation de mmap
                        "mlock": False,       # verrouillage en mémoire
                        
                        # Paramètres expérimentaux
                        "num_batch": 512,     # taille du batch
                        "num_beam": 1,        # beam search (1 = désactivé)
                        "tfs_z": 1.0,        # tail free sampling
                        "typical_p": 1.0,     # typical sampling
                    }
                }
                
                # Mettre à jour avec les valeurs reçues si elles existent
                if isinstance(settings, dict):
                    if 'parameters' in settings:
                        params = settings['parameters']
                        if isinstance(params, dict):
                            config['parameters'].update(params)
                
                # Sauvegarder la configuration dans un fichier Python
                config_filename = "settings/model_config.py"
                with open(config_filename, 'w', encoding='utf-8') as f:
                    f.write("# Configuration automatiquement générée pour le modèle\n")
                    f.write(f"# Date de génération: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
                    f.write("MODEL_CONFIG = {\n")
                    for key, value in config.items():
                        if isinstance(value, dict):
                            f.write(f"    '{key}': {{\n")
                            for k, v in value.items():
                                f.write(f"        '{k}': {repr(v)},\n")
                            f.write("    },\n")
                        else:
                            f.write(f"    '{key}': {repr(value)},\n")
                    f.write("}\n")
                
                # Sauvegarder aussi en JSON
                config_json_filename = "settings/model_config.json"
                with open(config_json_filename, 'w', encoding='utf-8') as f:
                    json.dump(config, f, indent=2, ensure_ascii=False)
                
                print(f"✅ Configuration générée dans: {config_filename}")
                print(f"✅ Configuration JSON sauvegardée dans: {config_json_filename}")
                print("\nParamètres récupérés:")
                print(json.dumps(config, indent=2, ensure_ascii=False))
                
            except json.JSONDecodeError as e:
                print(f"❌ Erreur de décodage JSON: {str(e)}")
                print("Réponse reçue:", response.text[:200])
            
        else:
            print(f"❌ Erreur {response.status_code}: {response.text}")
            
            # Essayons de lister les modèles disponibles
            list_url = f"{OLLAMA_URL}/api/tags"
            list_response = requests.get(list_url)
            if list_response.status_code == 200:
                models = list_response.json()
                print("\n📋 Modèles disponibles:")
                for model in models.get('models', []):
                    print(f"- {model.get('name', 'Unknown')}")
            
    except requests.exceptions.RequestException as e:
        print(f"❌ Erreur de connexion: {str(e)}")
        print("\nVérifiez que:")
        print(f"1. Le serveur Ollama est accessible sur {OLLAMA_URL}")
        print(f"2. Le modèle {MODEL_NAME} est bien installé")

if __name__ == "__main__":
    get_model_settings()