#https://huggingface.co/spaces/MisterAI/GenDoc_05
#app.py_143



# [Imports et configuration des modèles restent identiques]
import os
import gradio as gr
from huggingface_hub import hf_hub_download, login
from transformers import AutoModelForCausalLM, AutoTokenizer
from pptx import Presentation
from pptx.util import Inches, Pt
import torch
from llama_cpp import Llama
import time

# Configuration des modèles et PREPROMPT [inchangés]
TEXT_MODELS = {
    "Utter-Project_EuroLLM-1.7B": "utter-project/EuroLLM-1.7B",
    "Mistral Nemo 2407 (GGUF)": "MisterAI/Bartowski_MistralAI_Mistral-Nemo-Instruct-2407-IQ4_XS.gguf",
    "Mixtral 8x7B": "mistralai/Mixtral-8x7B-v0.1",
    "Lucie 7B": "OpenLLM-France/Lucie-7B"
}

PREPROMPT = """Vous êtes un assistant IA expert en création de présentations PowerPoint professionnelles.
Générez une présentation structurée et détaillée en suivant ce format EXACT:

TITRE: [Titre principal de la présentation]

DIAPO 1:
Titre: [Titre de la diapo]
Points:
- Point 1
- Point 2
- Point 3

DIAPO 2:
Titre: [Titre de la diapo]
Points:
- Point 1
- Point 2
- Point 3

[Continuez avec ce format pour chaque diapositive]

Analysez le texte suivant et créez une présentation professionnelle :"""

# [La classe PresentationGenerator reste inchangée]
class PresentationGenerator:
    # [Le code de la classe reste identique]
    [...]

# Correction des fonctions de génération pour gérer correctement le progress
def generate_skeleton(text, text_model_name, temperature, max_tokens):
    """Génère le squelette de la présentation"""
    try:
        start_time = time.time()
        generator = PresentationGenerator()

        # Chargement du modèle de texte uniquement
        generator.load_text_model(text_model_name)

        # Génération du contenu
        full_prompt = PREPROMPT + "\n\n" + text
        generated_content = generator.generate_text(full_prompt, temperature, max_tokens)

        execution_time = time.time() - start_time
        status = f"Squelette généré avec succès en {execution_time:.2f} secondes!"

        # Retourne le statut et le contenu généré
        return status, generated_content, gr.update(visible=True)

    except Exception as e:
        print(f"Erreur lors de la génération: {str(e)}")
        return f"Erreur: {str(e)}", None, gr.update(visible=False)

def create_presentation_file(generated_content):
    """Crée le fichier PowerPoint à partir du contenu généré"""
    try:
        generator = PresentationGenerator()

        # Création de la présentation
        slides = generator.parse_presentation_content(generated_content)
        prs = generator.create_presentation(slides)

        # Sauvegarde avec chemin absolu
        output_path = os.path.abspath("presentation.pptx")
        prs.save(output_path)

        # Vérification que le fichier existe
        if not os.path.exists(output_path):
            raise FileNotFoundError(f"Le fichier {output_path} n'a pas été créé correctement")

        return output_path

    except Exception as e:
        print(f"Erreur lors de la création du fichier: {str(e)}")
        return None

# Interface Gradio corrigée
with gr.Blocks(theme=gr.themes.Glass()) as demo:
    gr.Markdown(
        """
        # Générateur de Présentations PowerPoint IA

        Créez des présentations professionnelles automatiquement avec l'aide de l'IA.
        """
    )

    with gr.Row():
        with gr.Column(scale=1):
            text_model_choice = gr.Dropdown(
                choices=list(TEXT_MODELS.keys()),
                value=list(TEXT_MODELS.keys())[0],
                label="Modèle de génération de texte"
            )
            temperature = gr.Slider(
                minimum=0.1,
                maximum=1.0,
                value=0.7,
                step=0.1,
                label="Température"
            )
            max_tokens = gr.Slider(
                minimum=1000,
                maximum=4096,
                value=2048,
                step=256,
                label="Tokens maximum"
            )

    with gr.Row():
        with gr.Column(scale=2):
            input_text = gr.Textbox(
                lines=10,
                label="Votre texte",
                placeholder="Décrivez le contenu que vous souhaitez pour votre présentation..."
            )

    with gr.Row():
        generate_skeleton_btn = gr.Button("Générer le Squelette de la Présentation", variant="primary")

    with gr.Row():
        with gr.Column():
            status_output = gr.Textbox(
                label="Statut",
                lines=2
            )
            generated_content = gr.Textbox(
                label="Contenu généré",
                lines=10,
                show_copy_button=True
            )
            create_presentation_btn = gr.Button("Créer Présentation", visible=False)
            output_file = gr.File(
                label="Présentation PowerPoint"
            )

    # Correction des événements click
    generate_skeleton_btn.click(
        fn=generate_skeleton,
        inputs=[
            input_text,
            text_model_choice,
            temperature,
            max_tokens
        ],
        outputs=[
            status_output,
            generated_content,
            create_presentation_btn
        ]
    )

    create_presentation_btn.click(
        fn=create_presentation_file,
        inputs=[generated_content],
        outputs=[output_file]
    )

if __name__ == "__main__":
    demo.launch()