app.py

import gradio as gr
from openai import OpenAI
import openai # Import top-level for error types
from pydantic import BaseModel, Field
import os
import requests
from PIL import Image
import tempfile
import io # For BytesIO
# import numpy as np # Not strictly needed if using PIL
import markdown # Required by gr.Markdown implicitly
import base64
import datetime
import json
import re # For cleaning JSON
from dotenv import load_dotenv

# --- Configuration Initiale ---
load_dotenv() # Charge les variables depuis un fichier .env s'il existe

# Clé OpenRouter (obligatoire pour le fonctionnement de base)
openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
OPENROUTER_TEXT_MODEL = "google/gemini-pro-1.5" # Modèle OpenRouter par défaut
# OPENROUTER_TEXT_MODEL = "google/gemini-flash-1.5" # Alternative plus rapide

# Modèles OpenAI (utilisés si clé fournie)
OPENAI_TEXT_MODEL = "gpt-4o-mini" # ou "gpt-4o"
OPENAI_IMAGE_MODEL = "dall-e-3"

# --- Modèles Pydantic (Inchangé) ---
class BiasInfo(BaseModel):
    bias_type: str = Field(..., description="Type de biais identifié (ex: Stéréotype de genre, Biais de confirmation)")
    explanation: str = Field(..., description="Explication de pourquoi cela pourrait être un biais dans ce contexte.")
    advice: str = Field(..., description="Conseil spécifique pour atténuer ce biais.")

class BiasAnalysisResponse(BaseModel):
    detected_biases: list[BiasInfo] = Field(default_factory=list, description="Liste des biais potentiels détectés.")
    overall_comment: str = Field(default="", description="Commentaire général ou indication si aucun biais majeur n'est détecté.")

# --- Fonctions Utilitaires (Mises à jour) ---

# Dictionnaires de correspondance (Inchangés)
posture_mapping = {"": "","Debout": "standing up","Assis": "sitting","Allongé": "lying down","Accroupi": "crouching","En mouvement": "moving","Reposé": "resting"}
facial_expression_mapping = {"": "","Souriant": "smiling","Sérieux": "serious","Triste": "sad","En colère": "angry","Surpris": "surprised","Pensif": "thoughtful"}
skin_color_mapping = {"": "","Clair": "light","Moyen": "medium","Foncé": "dark","Très foncé": "very dark"}
eye_color_mapping = {"": "","Bleu": "blue","Vert": "green","Marron": "brown","Gris": "gray"}
hair_style_mapping = {"": "","Court": "short","Long": "long","Bouclé": "curly","Rasé": "shaved","Chauve": "bald","Tresses": "braided","Queue de cheval": "ponytail","Coiffure afro": "afro","Dégradé": "fade"}
hair_color_mapping = {"": "","Blond": "blonde","Brun": "brown","Noir": "black","Roux": "red","Gris": "gray","Blanc": "white"}
clothing_style_mapping = {"": "","Décontracté": "casual","Professionnel": "professional","Sportif": "sporty"}
accessories_mapping = {"": "","Lunettes": "glasses","Montre": "watch","Chapeau": "hat"}

# Fonction de mise à jour du journal (Limitée et formatée)
MAX_LOG_LINES = 150
def update_log(event_description, session_log_state):
    """Ajoute une entrée au log et le retourne, en limitant sa taille."""
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    new_log_entry = f"[{timestamp}] {event_description}"
    current_log = session_log_state if session_log_state else ""

    # Limiter la taille du log
    log_lines = current_log.splitlines()
    # Garde les N dernières lignes
    if len(log_lines) >= MAX_LOG_LINES:
        current_log = "\n".join(log_lines[-(MAX_LOG_LINES-1):])

    updated_log = current_log + "\n" + new_log_entry if current_log else new_log_entry
    return updated_log.strip() # Retourne le log mis à jour

def clean_json_response(raw_response):
    """Tente d'extraire un bloc JSON valide d'une réponse LLM potentiellement bruitée."""
    # Recherche d'un bloc JSON marqué par ```json ... ```
    match = re.search(r"```json\s*({.*?})\s*```", raw_response, re.DOTALL | re.IGNORECASE)
    if match:
        return match.group(1)
    # Recherche d'un objet JSON commençant par { et finissant par }
    match = re.search(r"({.*?})", raw_response, re.DOTALL)
    if match:
        # Essayer de parser pour vérifier si c'est valide
        try:
            json.loads(match.group(1))
            return match.group(1)
        except json.JSONDecodeError:
            pass # Si ça échoue, on continue

    # Si rien ne fonctionne, retourne la réponse brute en espérant qu'elle soit déjà du JSON
    return raw_response.strip()

# --- Fonctions Principales de l'Application (Mises à jour) ---

def analyze_biases_v2(app_config, objective_text, session_log_state):
    """Analyse les biais dans l'objectif marketing (utilise le client API actif)."""
    log = session_log_state
    log = update_log(f"Analyse Biais Objectif (début): '{objective_text[:50]}...'", log)

    if not objective_text:
         return BiasAnalysisResponse(overall_comment="Veuillez fournir un objectif marketing.").dict(), update_log("Analyse Biais: Objectif vide.", log)

    if not app_config.get("client"):
        return BiasAnalysisResponse(overall_comment="Erreur: Client API non configuré.").dict(), update_log("ERREUR Analyse Biais: Client non configuré.", log)

    active_client = app_config["client"]
    model_name = app_config["text_model"]

    # Prompt système V2 (Inchangé)
    system_prompt = f"""
    Tu es un expert en marketing éthique et en psychologie cognitive, spécialisé dans la création de personas.
    Analyse l'objectif marketing suivant : "{objective_text}"

    Identifie les BIAIS COGNITIFS POTENTIELS ou RISQUES DE STÉRÉOTYPES pertinents pour la création de personas. Concentre-toi sur :
    1.  **Stéréotypes / Généralisations Hâtives :** Suppose-t-on des traits basés sur le genre, l'âge, l'ethnie, le statut socio-économique sans justification ? (Ex: 'tous les jeunes urbains sont écolos')
    2.  **Biais de Confirmation / Affinité :** L'objectif semble-t-il chercher à valider une idée préconçue ou refléter trop les opinions du concepteur ? (Ex: 'prouver que notre produit est parfait pour CE type de personne')
    3.  **Simplification Excessive / Manque de Nuance :** Le groupe cible est-il décrit de manière trop monolithique, ignorant la diversité interne ? (Ex: 'les seniors actifs' sans différencier leurs motivations ou capacités)
    4.  **Autres biais pertinents** (Ex: Oubli de fréquence de base, Biais de normalité si applicable).

    Pour chaque biais potentiel identifié :
    - Nomme le type de biais (ex: Stéréotype d'âge).
    - Explique brièvement POURQUOI c'est un risque DANS CE CONTEXTE de création de persona.
    - Propose un CONSEIL PRÉCIS pour nuancer l'objectif ou être vigilant lors de la création.

    Structure ta réponse en utilisant le format JSON suivant (avec la classe Pydantic BiasAnalysisResponse):
    {{
        "detected_biases": [
            {{
                "bias_type": "Type de biais identifié",
                "explanation": "Explication contextuelle du risque.",
                "advice": "Conseil spécifique d'atténuation."
            }}
        ],
        "overall_comment": "Bref commentaire général. Indique si aucun biais majeur n'est détecté."
    }}
    Réponds en français. S'il n'y a pas de biais clair, retourne une liste 'detected_biases' vide et indique-le dans 'overall_comment'.
    """

    response_content_str = "" # Init pour le bloc except
    try:
        completion = active_client.chat.completions.create(
            model=model_name,
            messages=[
                # Note: Certains modèles préfèrent l'objectif dans le message user, d'autres intégré au system prompt.
                # Ici, on le met dans le system_prompt.
                {"role": "user", "content": system_prompt}
            ],
            temperature=0.4,
            max_tokens=800,
            # Demander explicitement du JSON si le modèle le supporte bien (OpenAI et certains OpenRouter le font)
            response_format={"type": "json_object"},
        )

        response_content_str = completion.choices[0].message.content
        # Nettoyage de la réponse avant parsing
        cleaned_response_str = clean_json_response(response_content_str)

        # Essayer de parser la réponse JSON nettoyée
        parsed_response = BiasAnalysisResponse.parse_raw(cleaned_response_str)

        log = update_log(f"Analyse Biais Objectif (fin): Biais trouvés - {len(parsed_response.detected_biases)}", log)
        return parsed_response.dict(), log

    except openai.AuthenticationError as e:
         error_msg = f"Erreur d'authentification API ({app_config.get('api_source', 'Inconnu')}). Vérifiez votre clé."
         print(error_msg)
         log = update_log(f"ERREUR API Auth: {error_msg}", log)
         return BiasAnalysisResponse(overall_comment=error_msg).dict(), log
    except openai.RateLimitError as e:
         error_msg = f"Erreur API ({app_config.get('api_source', 'Inconnu')}): Limite de taux atteinte. Réessayez plus tard."
         print(error_msg)
         log = update_log(f"ERREUR API RateLimit: {error_msg}", log)
         return BiasAnalysisResponse(overall_comment=error_msg).dict(), log
    except Exception as e:
        error_msg = f"Erreur pendant l'analyse des biais: {str(e)}. Réponse brute: '{response_content_str[:200]}...'"
        print(error_msg)
        log = update_log(f"ERREUR Analyse Biais: {str(e)}", log)
        # Essayer de retourner une structure d'erreur compatible
        return BiasAnalysisResponse(overall_comment=f"Erreur technique lors de l'analyse: {str(e)}").dict(), log

def display_bias_analysis_v2(analysis_result):
    """Formate l'analyse des biais pour l'affichage avec HighlightedText."""
    # Prend directement le dict retourné par analyze_biases_v2
    if not analysis_result:
        return [("Aucune analyse effectuée.", None)], {} # Retourne format HighlightedText et dict vide

    biases = analysis_result.get("detected_biases", [])
    overall_comment = analysis_result.get("overall_comment", "")

    highlighted_data = []
    if "Erreur" in overall_comment:
         highlighted_data.append((overall_comment, "ERROR")) # Étiquette spécifique pour erreurs
    elif not biases:
        highlighted_data.append((overall_comment or "Aucun biais majeur détecté.", "INFO"))
    else:
        if overall_comment:
            highlighted_data.append((overall_comment + "\n\n", "COMMENT"))
        for bias_info in biases:
            highlighted_data.append((f"⚠️ {bias_info.get('bias_type', 'Type inconnu')}: ", "BIAS_TYPE"))
            highlighted_data.append((f"{bias_info.get('explanation', 'Pas d’explication.')}\n", "EXPLANATION"))
            highlighted_data.append((f"💡 Conseil: {bias_info.get('advice', 'Pas de conseil.')}\n", "ADVICE"))

    # Retourne les données formatées et le résultat brut (qui est déjà un dict)
    # Le second output (bias_analysis_result_state) est mis à jour par la fonction appelante si nécessaire
    return highlighted_data

def generate_persona_image_v2(app_config, *args):
    """Génère l'image du persona en utilisant OpenAI si activé, sinon retourne None."""
    # Les 13 premiers args sont les inputs de l'image, le dernier est session_log_state
    inputs = args[:-1]
    session_log_state = args[-1]
    log = session_log_state
    (first_name, last_name, age, gender, persona_description_en, # Renommé pour clarté
     skin_color, eye_color, hair_style, hair_color, facial_expression,
     posture, clothing_style, accessories) = inputs

    # Vérifier si la génération d'image est activée (nécessite clé OpenAI valide)
    if not app_config.get("image_generation_enabled", False):
        log = update_log("Génération Image: Désactivée (Clé API OpenAI non fournie/valide).", log)
        # Retourne None pour l'image et le log mis à jour.
        # On ajoute aussi un message utilisateur via gr.Info dans le .click
        return None, log, "Génération d'image désactivée. Veuillez fournir une clé API OpenAI valide dans l'onglet Configuration."

    # Vérifier les champs obligatoires
    if not first_name or not last_name or not age or not gender:
        # Ne pas générer si infos de base manquantes
        # Le message utilisateur sera géré dans le .click via gr.Info
        return None, log, "Veuillez remplir Prénom, Nom, Âge et Genre pour générer l'image."

    # Construire le prompt en anglais
    # Base
    prompt_parts = [f"one person only, close-up portrait photo of {first_name} {last_name}, a {gender} aged {age}."] # Préciser "photo", "portrait"

    # Détails (utilise les mappings pour traduire les choix FR en termes EN)
    if skin_color_mapping.get(skin_color): prompt_parts.append(f"Skin tone: {skin_color_mapping[skin_color]}.")
    if eye_color_mapping.get(eye_color): prompt_parts.append(f"Eye color: {eye_color_mapping[eye_color]}.")
    if hair_style_mapping.get(hair_style): prompt_parts.append(f"Hairstyle: {hair_style_mapping[hair_style]}.")
    if hair_color_mapping.get(hair_color): prompt_parts.append(f"Hair color: {hair_color_mapping[hair_color]}.")
    if facial_expression_mapping.get(facial_expression): prompt_parts.append(f"Facial expression: {facial_expression_mapping[facial_expression]}.")
    if posture_mapping.get(posture): prompt_parts.append(f"Posture: {posture_mapping[posture]}.")
    if clothing_style_mapping.get(clothing_style): prompt_parts.append(f"Clothing style: {clothing_style_mapping[clothing_style]}.")
    if accessories_mapping.get(accessories): prompt_parts.append(f"Wearing: {accessories_mapping[accessories]}.") # "Wearing" est souvent mieux pour les accessoires
    if persona_description_en: prompt_parts.append(f"Background or context: {persona_description_en}.")

    # Style final
    prompt_parts.append("Realistic photo style, high detail, natural lighting.")
    final_prompt = " ".join(prompt_parts)

    log = update_log(f"Génération Image (début): Prompt='{final_prompt[:100]}...'", log)

    # Utiliser le client OpenAI (car image_generation_enabled est True)
    openai_client = app_config.get("client") # Devrait être le client OpenAI ici
    if not isinstance(openai_client, OpenAI) or app_config.get("api_source") != "openai":
         error_msg = "Erreur interne: Tentative de génération d'image sans client OpenAI valide."
         log = update_log(f"ERREUR Génération Image: {error_msg}", log)
         return None, log, error_msg

    try:
        response = openai_client.images.generate(
            model=OPENAI_IMAGE_MODEL,
            prompt=final_prompt,
            size="1024x1024",
            n=1,
            response_format="url", # Ou "b64_json"
            quality="standard", # ou "hd"
            style="natural" # ou "vivid"
        )

        # Traitement de la réponse (URL ou B64)
        image_url = response.data[0].url
        # Alternative si b64_json:
        # img_b64 = response.data[0].b64_json
        # img_bytes = base64.b64decode(img_b64)
        # pil_image = Image.open(io.BytesIO(img_bytes))

        # Télécharger l'image depuis l'URL
        img_response = requests.get(image_url)
        img_response.raise_for_status() # Vérifie les erreurs HTTP

        # Ouvrir l'image avec PIL depuis les bytes téléchargés
        pil_image = Image.open(io.BytesIO(img_response.content))

        log = update_log("Génération Image (fin): Succès.", log)
        # Retourne l'objet PIL Image, le log, et None pour le message d'erreur
        return pil_image, log, None

    except openai.AuthenticationError as e:
         error_msg = f"Erreur d'authentification API OpenAI. Vérifiez votre clé."
         print(error_msg)
         log = update_log(f"ERREUR API Auth (Image): {error_msg}", log)
         return None, log, error_msg # Retourne None pour l'image, log, et message d'erreur
    except openai.RateLimitError as e:
         error_msg = f"Erreur API OpenAI (Image): Limite de taux atteinte. Réessayez plus tard."
         print(error_msg)
         log = update_log(f"ERREUR API RateLimit (Image): {error_msg}", log)
         return None, log, error_msg
    except openai.BadRequestError as e: # Erreur fréquente si le prompt est refusé
         error_msg = f"Erreur API OpenAI (Image): Requête invalide (prompt refusé ?). Détails: {e}"
         print(error_msg)
         log = update_log(f"ERREUR API BadRequest (Image): {error_msg}", log)
         return None, log, error_msg
    except Exception as e:
        error_msg = f"Erreur lors de la génération de l'image: {str(e)}"
        print(error_msg)
        log = update_log(f"ERREUR Génération Image: {str(e)}", log)
        return None, log, error_msg

def refine_persona_details_v2(app_config, first_name, last_name, age, field_name, field_value, bias_analysis_json_str, marketing_objectives, session_log_state):
    """Affine les détails du persona (utilise le client API actif)."""
    log = session_log_state
    log = update_log(f"Refinement (début): Champ='{field_name}', Valeur initiale='{field_value[:50]}...'", log)

    # Vérifier le client API
    if not app_config.get("client"):
        error_msg = "Erreur: Client API non configuré pour le raffinement."
        log = update_log(f"ERREUR Refinement: Client non configuré.", log)
        # Retourner le log et le message d'erreur pour affichage
        return log, error_msg

    active_client = app_config["client"]
    model_name = app_config["text_model"]

    # Essayer de récupérer les biais détectés précédemment
    biases_text = "Aucune analyse de biais précédente disponible ou chargée."
    if bias_analysis_json_str: # C'est maintenant un dict, pas une str JSON
        try:
            # bias_analysis_data = json.loads(bias_analysis_json_str) # Plus nécessaire si c'est un dict
            detected_biases = bias_analysis_json_str.get("detected_biases", [])
            if detected_biases:
                biases_text = "\n".join([f"- {b.get('bias_type','N/A')}: {b.get('explanation','N/A')}" for b in detected_biases])
            else:
                biases_text = "Aucun biais majeur détecté lors de l'analyse initiale."
        except Exception as e:
            biases_text = f"Erreur lors de la lecture des biais analysés: {e}"
            log = update_log(f"ERREUR Lecture Biais pour Refinement: {e}", log)

    # Prompt système
    system_prompt = f"""
    Tu es un assistant IA expert en marketing éthique, aidant à affiner le persona marketing pour '{first_name} {last_name}' ({age} ans).
    L'objectif marketing initial était : "{marketing_objectives}"
    L'analyse initiale de cet objectif a soulevé les biais potentiels suivants :
    {biases_text}

    Tâche: Concentre-toi UNIQUEMENT sur le champ '{field_name}' dont la valeur actuelle est '{field_value}'.
    Propose 1 à 2 suggestions CONCISES et ACTIONNABLES pour améliorer, nuancer ou enrichir cette valeur.
    Tes suggestions doivent viser à :
    - Rendre le persona plus réaliste et moins cliché.
    - ATTÉNUER spécifiquement les biais potentiels listés ci-dessus s'ils sont pertinents pour ce champ.
    - Rester cohérent avec l'objectif marketing général.
    - Éviter les généralisations excessives.

    Si la valeur actuelle semble bonne ou si tu manques de contexte pour faire une suggestion pertinente, indique-le simplement (ex: "La valeur actuelle semble appropriée." ou "Difficile de suggérer sans plus de contexte.").
    Réponds en français. Ne fournis QUE les suggestions ou le commentaire d'approbation/manque de contexte. Ne répète pas la question.
    """
    suggestions = "" # Init pour le bloc except
    try:
        response = active_client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": system_prompt}],
            temperature=0.6, # Un peu plus de créativité pour les suggestions
            max_tokens=150,
        )
        suggestions = response.choices[0].message.content.strip()

        log = update_log(f"Refinement (fin): Champ='{field_name}'. Suggestions: '{suggestions[:50]}...'", log)
        # Retourne le log mis à jour et les suggestions (ou None si erreur)
        return log, suggestions

    except openai.AuthenticationError as e:
         error_msg = f"Erreur d'authentification API ({app_config.get('api_source', 'Inconnu')}) pendant raffinement. Vérifiez votre clé."
         print(error_msg)
         log = update_log(f"ERREUR API Auth (Refine): {error_msg}", log)
         return log, f"ERREUR: {error_msg}" # Retourne message d'erreur pour affichage
    except openai.RateLimitError as e:
         error_msg = f"Erreur API ({app_config.get('api_source', 'Inconnu')}) (Refine): Limite de taux atteinte."
         print(error_msg)
         log = update_log(f"ERREUR API RateLimit (Refine): {error_msg}", log)
         return log, f"ERREUR: {error_msg}"
    except Exception as e:
        error_msg = f"Erreur lors du raffinement pour '{field_name}': {str(e)}"
        print(error_msg)
        log = update_log(f"ERREUR Refinement '{field_name}': {str(e)}", log)
        return log, f"ERREUR: {error_msg}"

def generate_summary_v2(*args):
    """Génère le résumé HTML du persona (gestion image PIL)."""
    # Le dernier arg est session_log_state, l'avant-dernier est persona_image (PIL ou None)
    inputs = args[:-2] # Tous les champs textuels/numériques/dropdowns
    persona_image_pil = args[-2] # Peut être None ou un objet PIL Image
    session_log_state = args[-1]
    log = session_log_state

    # Extrait tous les champs (assurez-vous que l'ordre correspond à all_persona_inputs_for_summary)
    (first_name, last_name, age, gender, persona_description_en, # Utiliser la version EN pour le contexte image
     skin_color, eye_color, hair_style, hair_color, facial_expression,
     posture, clothing_style, accessories,
     marital_status, education_level, profession, income,
     personality_traits, values_beliefs, motivations, hobbies_interests,
     main_responsibilities, daily_activities, technology_relationship,
     product_related_activities, pain_points, product_goals, usage_scenarios,
     brand_relationship, market_segment, commercial_objectives,
     visual_codes, special_considerations, daily_life, references
     ) = inputs

    log = update_log(f"Génération Résumé: Pour '{first_name} {last_name}'.", log)

    summary = ""
    image_html = "<div style='flex: 0 0 320px; margin-left: 20px; text-align: center;'>\n" # Div pour l'image

    if not first_name or not last_name or not age:
        summary += "<h2>Informations de base manquantes</h2>\n"
        summary += "<p><i>Veuillez fournir au moins le prénom, le nom et l'âge (Étape 2).</i></p>\n"
        image_html += "<p>Image non générée.</p>\n"
    else:
        # Intégrer l'image si elle existe (objet PIL)
        if persona_image_pil and isinstance(persona_image_pil, Image.Image):
            try:
                # Convertir l'image PIL en base64 pour l'intégrer directement
                buffered = io.BytesIO()
                # Sauvegarder en PNG (ou JPEG si préféré) dans le buffer mémoire
                persona_image_pil.save(buffered, format="PNG")
                img_bytes = buffered.getvalue()
                img_base64 = base64.b64encode(img_bytes).decode()
                img_data_url = f"data:image/png;base64,{img_base64}"
                image_html += f"<img src='{img_data_url}' alt='Persona {first_name}' style='max-width: 300px; height: auto; border: 1px solid #eee; border-radius: 5px; margin-top: 10px;'/>\n"
            except Exception as e:
                img_err_msg = f"Erreur encodage image: {e}"
                image_html += f"<p><i>{img_err_msg}</i></p>\n"
                log = update_log(f"ERREUR Encodage Image Résumé: {e}", log)
        else:
            image_html += "<p><i>Aucune image générée ou disponible.</i></p>\n"

        # Section Informations Personnelles (Titre centré)
        summary += f"<div style='text-align: center;'><h1>{first_name} {last_name}, {age} ans ({gender})</h1></div>\n"
        # Utiliser persona_description_en ici car c'est ce qui a été utilisé pour l'image, ou ajouter un champ description générale FR ?
        # Pour l'instant, on affiche pas la desc EN dans le résumé FR. Ajoutons un champ 'description_persona_fr' ?
        # Solution simple: ne pas afficher de description ici ou ajouter un nouveau champ.
        # summary += f"<p><i>{persona_description_en}</i></p>\n" # Commenté

        # Assemblage des autres sections (avec vérification si champ rempli)
        def add_section(title, fields):
            content = ""
            for label, value in fields.items():
                # N'ajoute que si la valeur existe (n'est pas None, False, 0, ou chaîne vide)
                if value:
                    # Formatage spécial pour les revenus
                    if label == "Revenus annuels (€)" and isinstance(value, (int, float)):
                        # Format numérique avec séparateur de milliers (espace)
                        try:
                           value_str = f"{int(value):,} €".replace(",", " ")
                        except ValueError: # Gère le cas où income serait une chaîne ou autre chose
                            value_str = str(value) + " €"
                    else:
                        value_str = str(value)
                    # Remplace les sauts de ligne par <br> pour l'affichage HTML
                    value_str_html = value_str.replace("\n", "<br>")
                    content += f"<b>{label}:</b> {value_str_html}<br>\n"
            if content:
                # Ajoute un peu d'espace avant la section
                return f"<h3 style='margin-top: 15px; margin-bottom: 5px; border-bottom: 1px solid #eee; padding-bottom: 2px;'>{title}</h3>\n{content}\n"
            return ""

        # Construire le résumé par sections
        summary += add_section("Infos Socio-Démographiques", {
            "État civil": marital_status, "Niveau d'éducation": education_level,
            "Profession": profession, "Revenus annuels (€)": income
        })
        summary += add_section("Psychographie", {
            "Traits de personnalité": personality_traits, "Valeurs et croyances": values_beliefs,
            "Motivations intrinsèques": motivations, "Hobbies et intérêts": hobbies_interests
        })
        summary += add_section("Relation au Produit/Service", {
            "Relation avec la technologie": technology_relationship,
            "Tâches liées au produit/service": product_related_activities,
            "Points de douleur (Pain points)": pain_points,
            "Objectifs d’utilisation du produit/service": product_goals,
            "Scénarios d’utilisation typiques": usage_scenarios
        })
        summary += add_section("Contexte Professionnel/Vie Quotidienne", {
              "Responsabilités principales": main_responsibilities,
              "Activités journalières": daily_activities,
              "Une journée type / Citation": daily_life # Renommé pour correspondre au label
        })
        summary += add_section("Marketing & Considérations Spéciales", {
              "Relation avec la marque": brand_relationship,
              "Segment de marché": market_segment,
              "Objectifs commerciaux (SMART)": commercial_objectives,
              "Codes visuels / Marques préférées": visual_codes,
              "Considérations spéciales (accessibilité, culture...)": special_considerations,
              "Références / Sources de données": references
        })

    image_html += "</div>\n" # Ferme div image

    # Assemblage final avec flexbox pour mettre le texte et l'image côte à côte
    final_html = "<div style='display: flex; flex-wrap: wrap; align-items: flex-start; font-family: sans-serif; padding: 10px;'>\n"
    final_html += f"<div style='flex: 1; min-width: 350px; padding-right: 15px;'>\n{summary}</div>\n" # Colonne texte
    final_html += image_html # Colonne image
    final_html += "</div>"

    # Retourne le HTML généré et le log mis à jour
    return final_html, log

# --- Interface Gradio V2 (Mise à jour avec BYOK et suggestions) ---

with gr.Blocks(theme=gr.themes.Glass()) as demo:
    gr.Markdown("# PersonaGenAI V2 : Assistant de Création de Persona Marketing")
    gr.Markdown("Outil d'aide à la création de personas, intégrant l'IA générative (OpenRouter ou OpenAI) pour stimuler la créativité et la réflexivité face aux biais.")

    # --- État Global Partagé ---
    # Stocke la configuration active (client API, modèles, flags)
    app_config_state = gr.State(value={
        "client": None,
        "api_source": None, # 'openai' or 'openrouter'
        "text_model": None,
        "image_generation_enabled": False,
        "openai_key_provided": False,
        "openrouter_key_provided": bool(openrouter_api_key)
    })
    # Stocke le résultat de l'analyse de biais (maintenant un dict)
    bias_analysis_result_state = gr.State(value={})
    # Stocke l'image générée (objet PIL ou None)
    persona_image_pil_state = gr.State(value=None)
    # Stocke le log de session (chaîne de caractères)
    session_log_state = gr.State(value="")
    # Pour afficher les messages d'erreur/status globaux
    status_message_state = gr.State(value="")

    # --- Affichage Global du Statut/Erreur ---
    status_display = gr.Markdown(value="", elem_classes="status-message") # Pour afficher les messages d'erreur/info

    # Fonction pour mettre à jour le message de statut
    def update_status_display(new_message, current_log):
        # Met aussi à jour le log si un message est affiché
        if new_message:
             current_log = update_log(f"STATUS: {new_message}", current_log)
        return new_message, current_log

    # --- Onglets ---
    with gr.Tabs() as tabs:

        # --- Onglet 0 : Configuration API (BYOK) ---
        with gr.Tab("🔑 Configuration API", id=-1):
            gr.Markdown("### Configuration des Clés API")
            gr.Markdown("Cette application utilise une IA pour analyser et générer du contenu. Choisissez votre fournisseur d'API.")

            # Statut de la clé OpenRouter (obligatoire pour le mode de base)
            if openrouter_api_key:
                gr.Markdown("✅ Clé API **OpenRouter** trouvée dans l'environnement (`OPENROUTER_API_KEY`).")
            else:
                gr.Markdown("❌ **Clé API OpenRouter (`OPENROUTER_API_KEY`) non trouvée.** L'application ne pourra pas fonctionner sans cette clé. Veuillez la définir dans vos variables d'environnement ou un fichier `.env`.")

            # Champ pour la clé OpenAI (optionnelle)
            openai_api_key_input = gr.Textbox(
                label="Clé API OpenAI (Optionnelle)",
                type="password",
                placeholder="Entrez votre clé OpenAI ici pour activer DALL-E 3 et utiliser OpenAI pour le texte",
                info="Si fournie, cette clé sera utilisée pour la génération d'images (DALL-E 3) ET pour l'analyse/raffinement de texte (GPT). Sinon, OpenRouter sera utilisé pour le texte et la génération d'images sera désactivée."
            )
            # Bouton pour appliquer la config (initialise les clients)
            configure_api_button = gr.Button("Appliquer la Configuration API")
            # Affichage du statut de la configuration active
            api_status_display = gr.Markdown("Statut API: Non configuré.")

            # Fonction de configuration des clients API
            def configure_api_clients(openai_key, current_config, current_log):
                openai_key_provided = bool(openai_key)
                openrouter_key_available = current_config["openrouter_key_provided"]
                status_msg = ""
                config = current_config.copy() # Copie pour modification

                client = None
                api_source = None
                text_model = None
                image_enabled = False

                # Priorité à OpenAI si clé fournie
                if openai_key_provided:
                    try:
                        client = OpenAI(api_key=openai_key)
                        # Faire un petit appel test (optionnel mais recommandé)
                        # client.models.list() # Peut coûter un peu
                        api_source = "openai"
                        text_model = OPENAI_TEXT_MODEL
                        image_enabled = True
                        status_msg = f"✅ Configuration **OpenAI** active (Modèle texte: `{text_model}`, Images: DALL-E 3 activé)."
                        config["openai_key_provided"] = True
                    except Exception as e:
                        status_msg = f"⚠️ Clé OpenAI fournie mais invalide ou problème de connexion: {e}. Basculement vers OpenRouter si possible."
                        log_msg = f"ERREUR API Config OpenAI: {e}"
                        current_log = update_log(log_msg, current_log)
                        print(log_msg)
                        # Reset OpenAI specific flags
                        config["openai_key_provided"] = False
                        openai_key_provided = False # Force fallback if error

                # Fallback vers OpenRouter si clé OpenAI non fournie ou invalide, ET si clé OpenRouter existe
                if not openai_key_provided:
                    if openrouter_key_available:
                        try:
                            client = OpenAI(
                                base_url="https://openrouter.ai/api/v1",
                                api_key=openrouter_api_key,
                            )
                            api_source = "openrouter"
                            text_model = OPENROUTER_TEXT_MODEL
                            image_enabled = False # Image désactivée avec OpenRouter dans cette config
                            status_msg = f"✅ Configuration **OpenRouter** active (Modèle texte: `{text_model}`, Images: Désactivé)."
                        except Exception as e:
                            status_msg = f"❌ Erreur lors de l'initialisation d'OpenRouter: {e}. L'application risque de ne pas fonctionner."
                            log_msg = f"ERREUR API Config OpenRouter: {e}"
                            current_log = update_log(log_msg, current_log)
                            print(log_msg)
                            client = None # Assure que le client est None
                    else:
                        status_msg = "❌ Aucune clé API valide (OpenAI ou OpenRouter) n'est configurée. L'application ne peut pas fonctionner."
                        client = None # Assure que le client est None

                # Mettre à jour l'état global
                config["client"] = client
                config["api_source"] = api_source
                config["text_model"] = text_model
                config["image_generation_enabled"] = image_enabled

                log_msg = f"Configuration API appliquée. Source: {api_source or 'Aucune'}, Images: {'Actif' if image_enabled else 'Inactif'}."
                current_log = update_log(log_msg, current_log)

                # Retourne la nouvelle config, le message de statut, le log mis à jour,
                # et l'état interactif du bouton de génération d'image
                return config, status_msg, current_log, gr.update(interactive=image_enabled)

            # Lier le bouton de configuration
            # La sortie met à jour : l'état de config, le markdown de statut, l'état du log,
            # et l'interactivité du bouton de génération d'image (qui est dans un autre onglet)
            # On a besoin de référencer le bouton de génération d'image ici. Il faut le définir avant.
            # Solution : On va plutôt mettre à jour l'état `app_config_state`, et le bouton d'image
            # lira cet état quand il sera cliqué. La désactivation visuelle se fera via un .change() sur l'état.

            configure_api_button.click(
                fn=configure_api_clients,
                inputs=[openai_api_key_input, app_config_state, session_log_state],
                outputs=[app_config_state, api_status_display, session_log_state]
                # L'interactivité du bouton image sera gérée séparément via un .change()
            )

        # --- Onglet 1 : Objectif & Analyse Biais ---
        with gr.Tab("🎯 Étape 1: Objectif & Analyse Biais", id=0):
            gr.Markdown("### 1. Définissez votre objectif marketing")
            gr.Markdown("Décrivez pourquoi vous créez ce persona. L'IA analysera votre objectif pour identifier des biais cognitifs potentiels.")
            with gr.Row():
                objective_input = gr.Textbox(label="Objectif marketing pour ce persona", lines=4, scale=3)
                with gr.Column(scale=1):
                    gr.Markdown("<small>Suggestions d'objectifs :</small>")
                    suggestion_button1 = gr.Button("Exemple 1 : Service Écologique Urbain", size="sm")
                    suggestion_button2 = gr.Button("Exemple 2 : App Fitness Seniors", size="sm")
            analyze_button = gr.Button("🔍 Analyser l'Objectif pour Biais")
            gr.Markdown("---")
            gr.Markdown("### Analyse des Biais Potentiels")
            bias_analysis_output_highlighted = gr.HighlightedText(
                label="Biais détectés et Conseils",
                show_legend=True,
                color_map={"BIAS_TYPE": "red", "EXPLANATION": "gray", "ADVICE": "green", "INFO": "blue", "COMMENT": "orange", "ERROR": "darkred"} # Ajout ERROR
            )
            gr.Markdown("---")
            gr.Markdown("### 🤔 Réflexion")
            user_reflection_on_biases = gr.Textbox(
                label="Comment comptez-vous utiliser cette analyse pour la suite ?",
                lines=2,
                placeholder="Ex: Je vais veiller à ne pas tomber dans le stéréotype X, je vais chercher des données pour nuancer Y..."
            )
            log_reflection_button = gr.Button("📝 Enregistrer la réflexion", size='sm')

            # Logique de l'onglet 1
            suggestion1_text = "Je souhaite créer un persona pour promouvoir un nouveau service de livraison écologique destiné aux jeunes professionnels urbains soucieux de l'environnement (25-35 ans). Il doit incarner ces valeurs et besoins identifiés lors de notre étude préalable."
            suggestion2_text = "Développer une application mobile de fitness personnalisée pour les seniors actifs (+65 ans) cherchant à maintenir une vie saine et sociale. Le persona doit refléter leurs besoins (facilité, convivialité) et préférences."

            suggestion_button1.click(lambda: suggestion1_text, outputs=objective_input)
            suggestion_button2.click(lambda: suggestion2_text, outputs=objective_input)

            # Action du bouton Analyser
            analyze_button.click(
                fn=analyze_biases_v2,
                inputs=[app_config_state, objective_input, session_log_state],
                outputs=[bias_analysis_result_state, session_log_state] # Stocke le dict résultat + maj log
            ).then(
                fn=display_bias_analysis_v2,
                inputs=bias_analysis_result_state, # Utilise le résultat stocké (dict)
                outputs=bias_analysis_output_highlighted # Affiche formaté
            ).then(
                 # Met à jour le statut global si l'analyse a retourné une erreur
                 fn=lambda result, log: update_status_display(result.get("overall_comment", "") if "Erreur" in result.get("overall_comment", "") else "", log),
                 inputs=[bias_analysis_result_state, session_log_state],
                 outputs=[status_display, session_log_state]
            )

            # Action du bouton Enregistrer Réflexion
            def log_user_reflection(reflection_text, log_state):
                log = update_log(f"Réflexion Utilisateur (Étape 1): '{reflection_text}'", log_state)
                return log
            log_reflection_button.click(
                fn=log_user_reflection,
                inputs=[user_reflection_on_biases, session_log_state],
                outputs=[session_log_state]
            )


        # --- Onglet 2 : Image & Infos Base ---
        with gr.Tab("👤 Étape 2: Image & Infos Base", id=1):
            gr.Markdown("### 2. Créez l'identité visuelle et les informations de base")
            with gr.Row():
                with gr.Column(scale=1.4): # Colonne de gauche pour les inputs
                    first_name_input = gr.Textbox(label="Prénom")
                    last_name_input = gr.Textbox(label="Nom")
                    age_input = gr.Slider(label="Âge", minimum=18, maximum=100, step=1, value=30)
                    gender_input = gr.Radio(label="Genre", choices=["Homme", "Femme", "Non-binaire"], value="Homme")
                    persona_description_en_input = gr.Textbox(label="Contexte/Activité pour l'image (optionnel, en anglais)", lines=1, info="Ex: 'reading a book in a cozy cafe', 'working on a laptop in a modern office', 'hiking on a sunny day'")

                    with gr.Accordion("🎨 Détails Visuels (Optionnel)", open=False):
                        with gr.Row():
                            skin_color_input = gr.Dropdown(label="Teint", choices=list(skin_color_mapping.keys()), value="")
                            eye_color_input = gr.Dropdown(label="Yeux", choices=list(eye_color_mapping.keys()), value="")
                        with gr.Row():
                            hair_style_input = gr.Dropdown(label="Coiffure", choices=list(hair_style_mapping.keys()), value="")
                            hair_color_input = gr.Dropdown(label="Cheveux", choices=list(hair_color_mapping.keys()), value="")
                        with gr.Row():
                            facial_expression_input = gr.Dropdown(label="Expression", choices=list(facial_expression_mapping.keys()), value="")
                            posture_input = gr.Dropdown(label="Posture", choices=list(posture_mapping.keys()), value="")
                        with gr.Row():
                            clothing_style_input = gr.Dropdown(label="Style Vêtements", choices=list(clothing_style_mapping.keys()), value="")
                            accessories_input = gr.Dropdown(label="Accessoires", choices=list(accessories_mapping.keys()), value="")
                        reset_visuals_button = gr.Button("Réinitialiser Détails Visuels", size="sm")

                with gr.Column(scale=1): # Colonne de droite pour l'image et le bouton
                     # Utiliser type="pil" pour gérer l'image en mémoire
                    persona_image_output = gr.Image(label="Image du Persona", type="pil", height=400, interactive=False) # Non éditable par l'utilisateur
                    # Ce bouton sera activé/désactivé par la config API
                    generate_image_button = gr.Button("🖼️ Générer / Mettre à jour l'Image")
                    gr.Markdown("<small>💡 **Attention :** Les IA génératrices d'images peuvent reproduire des stéréotypes. Utilisez les détails visuels avec discernement pour créer une représentation nuancée et inclusive. La génération d'image nécessite une clé API OpenAI valide (voir onglet Configuration).</small>", elem_classes="warning")

            # Logique de l'onglet 2
            visual_inputs = [
                skin_color_input, eye_color_input, hair_style_input, hair_color_input,
                facial_expression_input, posture_input, clothing_style_input, accessories_input
            ]
            reset_visuals_button.click(lambda: [""] * len(visual_inputs), outputs=visual_inputs)

            # Action du bouton Générer Image
            # Définit une fonction intermédiaire pour gérer les sorties multiples et les messages
            def handle_image_generation(*args):
                # Le dernier input est app_config_state, l'avant-dernier est log_state
                # Les autres sont les champs du persona
                app_config = args[0]
                log_state = args[-1]
                persona_inputs = args[1:-1] # first_name, last_name, etc.

                pil_image, updated_log, error_message = generate_persona_image_v2(app_config, *persona_inputs, log_state)

                # Préparer les mises à jour des composants
                status_update = error_message if error_message else "" # Message pour le statut global
                # Si infos manquantes (retournées par generate_persona.. comme error_message)
                if "Veuillez remplir" in (error_message or ""):
                    gr.Info(error_message) # Affiche un popup Gradio Info
                    status_update = "" # Ne pas mettre dans le statut global

                # Si génération désactivée (aussi retourné comme error_message)
                if "Génération d'image désactivée" in (error_message or ""):
                    gr.Info(error_message) # Affiche popup
                    status_update = "" # Ne pas mettre dans le statut global

                return pil_image, updated_log, status_update

            generate_image_button.click(
                fn=handle_image_generation,
                inputs=[app_config_state] + [ # Passer l'état de config en premier
                    first_name_input, last_name_input, age_input, gender_input, persona_description_en_input,
                    skin_color_input, eye_color_input, hair_style_input, hair_color_input,
                    facial_expression_input, posture_input, clothing_style_input, accessories_input,
                    session_log_state # Passer l'état du log en dernier
                ],
                outputs=[
                    persona_image_pil_state, # Met à jour l'état de l'image (PIL ou None)
                    session_log_state,    # Met à jour l'état du log
                    status_message_state  # Met à jour l'état du message (pour affichage global)
                ]
            ).then( # Chaîne pour mettre à jour l'affichage de l'image depuis l'état
                 fn=lambda img_state: img_state,
                 inputs=persona_image_pil_state,
                 outputs=persona_image_output
            ).then( # Chaîne pour mettre à jour l'affichage du statut depuis l'état
                 fn=lambda status_state, log_state: update_status_display(status_state, log_state),
                 inputs=[status_message_state, session_log_state],
                 outputs=[status_display, session_log_state]
            )

            # Mettre à jour l'interactivité du bouton quand la config API change
            app_config_state.change(
                 fn=lambda config: gr.update(interactive=config.get("image_generation_enabled", False)),
                 inputs=app_config_state,
                 outputs=generate_image_button
            )

        # --- Onglet 3 : Profil Détaillé & Raffinement IA ---
        with gr.Tab("📝 Étape 3: Profil Détaillé & Raffinement IA", id=2):
            gr.Markdown("### 3. Complétez les détails du persona")
            gr.Markdown("Remplissez les champs suivants. Utilisez le bouton '💡 Affiner' pour obtenir des suggestions de l'IA visant à améliorer le champ spécifique, en tenant compte de votre objectif initial et des biais potentiels identifiés.")

            # Organiser en sections pour plus de clarté
            with gr.Row():
                with gr.Column():
                    gr.Markdown("#### Infos Socio-Démographiques")
                    marital_status_input = gr.Dropdown(label="État civil", choices=["", "Célibataire", "En couple", "Marié(e)", "Divorcé(e)", "Veuf(ve)"])
                    education_level_input = gr.Dropdown(label="Niveau d'éducation", choices=["", "Études secondaires", "Baccalauréat", "Licence", "Master", "Doctorat", "Autre"])
                    profession_input = gr.Textbox(label="Profession")
                    income_input = gr.Number(label="Revenus annuels (€)", minimum=0, step=1000)

                    gr.Markdown("#### Psychographie")
                    with gr.Row(equal_height=False):
                        personality_traits_input = gr.Textbox(label="Traits de personnalité", lines=2, scale=4)
                        refine_personality_traits_button = gr.Button("💡 Affiner", scale=1, size='sm')
                    with gr.Row(equal_height=False):
                        values_beliefs_input = gr.Textbox(label="Valeurs et croyances", lines=2, scale=4)
                        refine_values_beliefs_button = gr.Button("💡 Affiner", scale=1, size='sm')
                    with gr.Row(equal_height=False):
                        motivations_input = gr.Textbox(label="Motivations (objectifs, désirs)", lines=2, scale=4)
                        refine_motivations_button = gr.Button("💡 Affiner", scale=1, size='sm')
                    with gr.Row(equal_height=False):
                        hobbies_interests_input = gr.Textbox(label="Loisirs et intérêts", lines=2, scale=4)
                        refine_hobbies_interests_button = gr.Button("💡 Affiner", scale=1, size='sm')

                with gr.Column():
                    gr.Markdown("#### Relation au Produit/Service")
                    with gr.Row(equal_height=False):
                        technology_relationship_input = gr.Textbox(label="Relation avec la technologie", lines=2, scale=4, info="Ex: early adopter, prudent, technophobe, pragmatique...")
                        refine_technology_relationship_button = gr.Button("💡 Affiner", scale=1, size='sm')
                    with gr.Row(equal_height=False):
                        product_related_activities_input = gr.Textbox(label="Tâches/activités liées à votre produit/service", lines=2, scale=4)
                        refine_product_related_activities_button = gr.Button("💡 Affiner", scale=1, size='sm')
                    with gr.Row(equal_height=False):
                        pain_points_input = gr.Textbox(label="Points de douleur (frustrations, problèmes)", lines=2, scale=4)
                        refine_pain_points_button = gr.Button("💡 Affiner", scale=1, size='sm')
                    with gr.Row(equal_height=False):
                        product_goals_input = gr.Textbox(label="Objectifs en utilisant votre produit/service", lines=2, scale=4)
                        refine_product_goals_button = gr.Button("💡 Affiner", scale=1, size='sm')
                    with gr.Row(equal_height=False):
                        usage_scenarios_input = gr.Textbox(label="Scénarios d'utilisation typiques", lines=2, scale=4)
                        refine_usage_scenarios_button = gr.Button("💡 Affiner", scale=1, size='sm')

            # Ajouter les autres champs de V1 ici si nécessaire (Responsabilités, Journée type, Marketing...) pour un persona complet
            with gr.Accordion("Autres Informations (Optionnel)", open=False):
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("#### Contexte Professionnel/Vie Quotidienne")
                        with gr.Row(equal_height=False):
                            main_responsibilities_input = gr.Textbox(label="Responsabilités principales (pro/perso)", lines=2, scale=4)
                            refine_main_responsibilities_button = gr.Button("💡 Affiner", scale=1, size='sm')
                        with gr.Row(equal_height=False):
                            daily_activities_input = gr.Textbox(label="Activités journalières typiques", lines=2, scale=4)
                            refine_daily_activities_button = gr.Button("💡 Affiner", scale=1, size='sm')
                        with gr.Row(equal_height=False):
                            daily_life_input = gr.Textbox(label="Une journée type / Citation marquante", lines=2, scale=4)
                            refine_daily_life_button = gr.Button("💡 Affiner", scale=1, size='sm')

                    with gr.Column():
                        gr.Markdown("#### Marketing & Considérations Spéciales")
                        with gr.Row(equal_height=False):
                            brand_relationship_input = gr.Textbox(label="Relation avec la marque", lines=2, scale=4)
                            refine_brand_relationship_button = gr.Button("💡 Affiner", scale=1, size='sm')
                        with gr.Row(equal_height=False):
                            market_segment_input = gr.Textbox(label="Segment de marché", lines=2, scale=4)
                            refine_market_segment_button = gr.Button("💡 Affiner", scale=1, size='sm')
                        with gr.Row(equal_height=False):
                            commercial_objectives_input = gr.Textbox(label="Objectifs commerciaux liés (SMART)", lines=2, scale=4)
                            refine_commercial_objectives_button = gr.Button("💡 Affiner", scale=1, size='sm')
                        with gr.Row(equal_height=False):
                            visual_codes_input = gr.Textbox(label="Codes visuels / Marques préférées", lines=2, scale=4)
                            refine_visual_codes_button = gr.Button("💡 Affiner", scale=1, size='sm')
                        with gr.Row(equal_height=False):
                            special_considerations_input = gr.Textbox(label="Considérations spéciales (accessibilité, culturelles...)", lines=2, scale=4)
                            refine_special_considerations_button = gr.Button("💡 Affiner", scale=1, size='sm')
                        with gr.Row(equal_height=False):
                            references_input = gr.Textbox(label="Références / Sources de données", lines=2, scale=4)
                            refine_references_button = gr.Button("💡 Affiner", scale=1, size='sm')


            # Fonction intermédiaire pour gérer l'appel de raffinement et l'affichage
            def handle_refinement_request(app_config, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state):
                # Appel de la fonction de raffinement
                updated_log, result = refine_persona_details_v2(app_config, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state)

                # Afficher le résultat (suggestions ou erreur)
                if result and "ERREUR:" in result:
                    # Afficher dans le statut global si c'est une erreur API
                    status_update = result
                    gr.Warning(f"Erreur lors du raffinement pour '{field_name_display}'. Vérifiez le log.")
                elif result:
                    # Afficher les suggestions dans une InfoBox
                    gr.Info(f"Suggestions pour '{field_name_display}':\n{result}")
                    status_update = "" # Pas d'erreur à afficher globalement
                else:
                    # Cas où result est None ou vide (ne devrait pas arriver mais au cas où)
                     status_update = ""
                     gr.Warning(f"Pas de suggestion reçue pour '{field_name_display}'.")

                return updated_log, status_update

            # Fonction lambda générique pour appeler le handler de raffinement
            def create_refine_handler(field_name_display, input_component):
                 # Le lambda prend les inputs requis par handle_refinement_request
                return lambda app_conf, fname, lname, age_val, field_val, bias_state, objectives, log_state: \
                    handle_refinement_request(app_conf, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state)

            # Lier chaque bouton "Affiner"
            common_inputs_refine = [app_config_state, first_name_input, last_name_input, age_input]
            state_inputs_refine = [bias_analysis_result_state, objective_input, session_log_state]
            # La sortie met à jour le log et potentiellement le message de statut global
            common_outputs_refine = [session_log_state, status_message_state]

            # Lier tous les boutons
            refine_buttons_map = {
                refine_personality_traits_button: ("Traits de personnalité", personality_traits_input),
                refine_values_beliefs_button: ("Valeurs et croyances", values_beliefs_input),
                refine_motivations_button: ("Motivations", motivations_input),
                refine_hobbies_interests_button: ("Loisirs et intérêts", hobbies_interests_input),
                refine_technology_relationship_button: ("Relation avec la technologie", technology_relationship_input),
                refine_product_related_activities_button: ("Tâches liées au produit", product_related_activities_input),
                refine_pain_points_button: ("Points de douleur", pain_points_input),
                refine_product_goals_button: ("Objectifs produit", product_goals_input),
                refine_usage_scenarios_button: ("Scénarios d'utilisation", usage_scenarios_input),
                refine_main_responsibilities_button: ("Responsabilités principales", main_responsibilities_input),
                refine_daily_activities_button: ("Activités journalières", daily_activities_input),
                refine_daily_life_button: ("Journée type/Citation", daily_life_input),
                refine_brand_relationship_button: ("Relation marque", brand_relationship_input),
                refine_market_segment_button: ("Segment marché", market_segment_input),
                refine_commercial_objectives_button: ("Objectifs commerciaux", commercial_objectives_input),
                refine_visual_codes_button: ("Codes visuels", visual_codes_input),
                refine_special_considerations_button: ("Considérations spéciales", special_considerations_input),
                refine_references_button: ("Références", references_input),
            }

            for btn, (label, input_comp) in refine_buttons_map.items():
                btn.click(
                    fn=create_refine_handler(label, input_comp),
                    inputs=common_inputs_refine + [input_comp] + state_inputs_refine,
                    outputs=common_outputs_refine
                 ).then( # Chaîne pour mettre à jour l'affichage du statut depuis l'état
                     fn=lambda status_state, log_state: update_status_display(status_state, log_state),
                     inputs=[status_message_state, session_log_state],
                     outputs=[status_display, session_log_state]
                 )


        # --- Onglet 4 : Résumé du Persona ---
        with gr.Tab("📄 Étape 4: Résumé du Persona", id=3):
            gr.Markdown("### 4. Visualisez le persona complet")
            summary_button = gr.Button("Générer le Résumé du Persona")
            # Utiliser Markdown pour afficher le HTML du résumé
            summary_content = gr.Markdown(elem_classes="persona-summary", value="Cliquez sur 'Générer' pour voir le résumé.")

            # Collecter tous les inputs nécessaires pour le résumé DANS LE BON ORDRE pour generate_summary_v2
            all_persona_inputs_for_summary = [
                first_name_input, last_name_input, age_input, gender_input, persona_description_en_input, # Input EN utilisé pour l'image
                skin_color_input, eye_color_input, hair_style_input, hair_color_input,
                facial_expression_input, posture_input, clothing_style_input, accessories_input,
                marital_status_input, education_level_input, profession_input, income_input,
                personality_traits_input, values_beliefs_input, motivations_input, hobbies_interests_input,
                main_responsibilities_input, daily_activities_input, technology_relationship_input,
                product_related_activities_input, pain_points_input, product_goals_input, usage_scenarios_input,
                brand_relationship_input, market_segment_input, commercial_objectives_input,
                visual_codes_input, special_considerations_input, daily_life_input, references_input,
                # Ajouter les états nécessaires en dernier
                persona_image_pil_state, # Passer l'état contenant l'image PIL
                session_log_state
            ]

            summary_button.click(
                fn=generate_summary_v2,
                inputs=all_persona_inputs_for_summary,
                outputs=[summary_content, session_log_state] # Met à jour le contenu et le log
            )

        # --- Onglet 5 : Journal de Bord ---
        with gr.Tab("📓 Journal de Bord", id=4):
            gr.Markdown("### Suivi du Processus de Création")
            gr.Markdown("Ce journal enregistre les étapes clés et les erreurs de votre session.")
            log_display_final = gr.Textbox(label="Historique de la session", lines=20, interactive=False, max_lines=MAX_LOG_LINES)
            export_log_button_final = gr.Button("Exporter le Journal en .txt")
            # Utiliser gr.DownloadButton pour une meilleure UX
            # log_file_output = gr.File(label="Télécharger le Journal", file_count="single", visible=False) # Caché initialement
            download_log_button = gr.DownloadButton(label="Télécharger le Journal", visible=False)


            # Mettre à jour l'affichage du log quand l'état change
            session_log_state.change(
                fn=lambda log_data: log_data,
                inputs=session_log_state,
                outputs=log_display_final
            )

            # Mettre à jour l'affichage global du statut quand l'état change
            status_message_state.change(
                 fn=lambda status_msg, log: update_status_display(status_msg, log),
                 inputs=[status_message_state, session_log_state],
                 outputs=[status_display, session_log_state]
            )

            # Fonction pour préparer le fichier log pour le DownloadButton
            def prepare_log_for_download(log_data):
                if not log_data:
                    return gr.update(visible=False) # Cache le bouton si pas de log

                # Créer un fichier texte temporaire que Gradio peut servir
                # Utiliser delete=False car Gradio doit pouvoir lire le fichier après le retour de la fonction
                try:
                    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt', encoding='utf-8') as temp_file:
                        temp_file.write(log_data)
                        temp_filepath = temp_file.name
                    print(f"Fichier log prêt pour téléchargement : {temp_filepath}")
                    # Retourner le chemin pour le DownloadButton et le rendre visible
                    # Note: Gradio est censé gérer le nettoyage de ce fichier temporaire.
                    return gr.update(value=temp_filepath, visible=True)
                except Exception as e:
                    print(f"Erreur création fichier log pour téléchargement: {e}")
                    return gr.update(visible=False) # Cache le bouton en cas d'erreur

            export_log_button_final.click(
                fn=prepare_log_for_download,
                inputs=session_log_state,
                outputs=download_log_button
            )

# Lancer l'application
# Utiliser queue() pour gérer les appels API potentiellement longs
# debug=True est utile pour le développement, False en production
# share=False est plus sûr par défaut, surtout avec des clés API
if not openrouter_api_key:
     print("\n" + "="*60)
     print("ERREUR CRITIQUE : Clé API OpenRouter non trouvée.")
     print("Veuillez définir OPENROUTER_API_KEY dans votre environnement.")
     print("L'application ne fonctionnera pas correctement sans elle.")
     print("="*60 + "\n")
     # On pourrait arrêter ici, mais on lance quand même Gradio pour voir l'interface
     # et permettre la configuration OpenAI si l'utilisateur le souhaite.
     # Cependant, l'état initial sera non fonctionnel sans config valide.

demo.queue().launch(debug=False, share=False)