from smolagent.agent.core import AgentFactory
from smolagent.ui.gradio_ui import GradioUI
import os
import sys
from dotenv import load_dotenv
from smolagent.config import load_settings
from PIL import Image, ImageDraw, ImageFont
from pathlib import Path
import logging
import traceback

# Configuration du logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(sys.stdout),
        logging.FileHandler("smolagent.log")
    ]
)
logger = logging.getLogger("smolagent")

settings = load_settings()

# Fonction de génération d'images
def create_image(text, filename, assets_path="assets", size=(200, 200), bg_color=(255, 255, 255), text_color=(0, 0, 0)):
    """Crée une image avec du texte au centre."""
    # Vérifie si le répertoire existe, sinon crée-le
    assets_dir = Path(assets_path)
    assets_dir.mkdir(exist_ok=True)
    
    # Création d'une image avec fond
    img = Image.new('RGB', size, color=bg_color)
    draw = ImageDraw.Draw(img)
    
    # Utilisation d'une police simple pour afficher le texte
    try:
        # Essai d'utiliser une police système si disponible (plus joli)
        try:
            # Chemin de police différent selon OS
            if os.name == 'nt':  # Windows
                font_path = "C:/Windows/Fonts/Arial.ttf"
            else:  # Linux/Mac
                font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
                
            font = ImageFont.truetype(font_path, 24)
        except:
            # Fallback à la police par défaut
            font = ImageFont.load_default()
    except Exception as e:
        logger.warning(f"Impossible de charger la police: {e}")
        font = ImageFont.load_default()
    
    # Calcul de la position du texte au centre de l'image
    try:
        # Pour les versions plus récentes de PIL
        bbox = draw.textbbox((0, 0), text, font=font)
        text_width = bbox[2] - bbox[0]
        text_height = bbox[3] - bbox[1]
    except AttributeError:
        # Fallback pour les anciennes versions
        text_width, text_height = draw.textsize(text, font)
    
    # Position du texte au centre de l'image
    text_position = ((size[0] - text_width) / 2, (size[1] - text_height) / 2)
    draw.text(text_position, text, fill=text_color, font=font)
    
    # Sauvegarde de l'image dans le bon répertoire
    full_path = assets_dir / filename
    img.save(full_path)
    logger.info(f"Image créée: {full_path}")
    return full_path

# Fonction pour vérifier et générer les images d'avatar
def ensure_assets_exist():
    """Vérifie et génère les assets nécessaires à l'interface."""
    assets_path = Path("assets")
    assets_path.mkdir(exist_ok=True)
    
    # Liste des fichiers à vérifier/créer
    assets_to_check = {
        "user.png": ("User", (230, 106, 210)),  # Rose pour l'utilisateur
        "bot.png": ("Bot", (66, 133, 244))      # Bleu pour le bot
    }
    
    for filename, (text, color) in assets_to_check.items():
        file_path = assets_path / filename
        if not file_path.exists():
            logger.info(f"Création de l'image {filename}...")
            create_image(
                text=text,
                filename=filename,
                assets_path=assets_path,
                bg_color=(250, 250, 250),
                text_color=color,
                size=(300, 300)
            )
    
    # Vérification après création
    missing = [f for f, _ in assets_to_check.items() if not (assets_path / f).exists()]
    if missing:
        raise FileNotFoundError(f"Impossible de créer les assets: {missing}")
    else:
        logger.info("Tous les assets sont disponibles.")

def main():
    """Fonction principale de l'application."""
    logger.info("Démarrage de SmolAgent...")
    
    try:
        # Chargement des variables d'environnement
        if not os.getenv('SPACE_ID'):
            load_dotenv()
            logger.info("Variables d'environnement chargées depuis .env")
        
        # Validation du token API
        hf_token = os.getenv('HUGGINGFACEHUB_API_TOKEN')
        if not hf_token:
            env_context = "Hugging Face Space" if os.getenv('SPACE_ID') else "local"
            raise RuntimeError(f"🔒 Token API manquant ({env_context}) - Configurez HUGGINGFACEHUB_API_TOKEN !")
        
        # Génération des assets graphiques
        ensure_assets_exist()
        
        # Configuration de l'agent
        config_path = os.environ.get('AGENT_CONFIG_PATH', 'smolagent/config/tools.yaml')
        logger.info(f"Chargement de la configuration depuis: {config_path}")
        
        factory = AgentFactory(config_path=config_path)
        logger.info("Agent factory initialisée avec succès")
        
        # Création de l'interface utilisateur
        ui = GradioUI(agent_factory=factory)
        logger.info("Interface Gradio créée avec succès")
        
        # Configuration du serveur selon l'environnement
        server_port = int(os.getenv('PORT', '7860'))
        server_host = "0.0.0.0" if os.getenv('SPACE_ID') else None
        share = os.getenv('ENVIRONMENT') == 'dev'
        
        # Lancement de l'interface
        logger.info(f"Lancement de l'interface sur {'0.0.0.0' if server_host else 'localhost'}:{server_port}")
        logger.info(f"Mode partage: {'activé' if share else 'désactivé'}")
        
        # Lancement de l'interface avec les paramètres appropriés
        ui.launch()
        
    except Exception as e:
        logger.error(f"🚨 ERREUR SYSTÈME: {str(e)}")
        if os.getenv('DEBUG_MODE', 'false').lower() == 'true':
            logger.error(traceback.format_exc())
        else:
            logger.error("Pour plus de détails, activez DEBUG_MODE=true dans votre fichier .env")
        sys.exit(1)

if __name__ == "__main__":
    main()