Update app.py

app.py

@@ -10,103 +10,202 @@ import os
 import json
 import re
 import google.generativeai as genai
+import pdfplumber # Nueva importación
 
+# --- CONFIGURACIÓN ---
 # Configurar Gemini (ensure GEMINI_API_KEY is set in environment)
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
-    st.error("GEMINI_API_KEY no encontrada. Por favor configúrala.")
-    st.stop() # Stop execution if key is missing
+    st.error("GEMINI_API_KEY no encontrada. Por favor configúrala en tus variables de entorno.")
+    st.stop() 
 genai.configure(api_key=GEMINI_API_KEY)
 
 # Obtener la clave API de Pixabay desde los secretos de Streamlit
 PIXABAY_API_KEY = st.secrets.get("pixabay")
 if not PIXABAY_API_KEY:
     st.error("Clave API de Pixabay no encontrada en los secretos de Streamlit.")
-    st.stop() # Stop execution if key is missing
+    st.stop() 
 
+# --- MODELO CACHEADO ---
 @st.cache_resource
 def get_gemini_model():
     return genai.GenerativeModel("gemini-1.5-flash")
 
-def extract_and_clean_json(text):
-    # Intenta encontrar JSON entre ```json ... ``` o directamente
-    match = re.search(r"```json\s*(\{.*?\})\s*```", text, re.DOTALL)
+# --- FUNCIONES AUXILIARES ---
+def extract_text_from_pdf(uploaded_file):
+    """Extrae texto de un archivo PDF cargado."""
+    if uploaded_file is None:
+        return None
+    try:
+        with pdfplumber.open(uploaded_file) as pdf:
+            full_text = []
+            for page in pdf.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    full_text.append(page_text)
+            return "\n".join(full_text)
+    except Exception as e:
+        st.error(f"Error al procesar el PDF: {e}")
+        return None
+
+def extract_and_clean_json(text_response):
+    """Extrae y limpia una cadena JSON de una respuesta de texto."""
+    # Intenta encontrar JSON entre ```json ... ```
+    match = re.search(r"```json\s*(\{.*?\})\s*```", text_response, re.DOTALL)
     if match:
         json_str = match.group(1)
     else:
-        json_match = re.search(r'\{.*\}', text, re.DOTALL)
+        # Si no está en formato markdown, busca el primer '{' hasta el último '}'
+        json_match = re.search(r'\{.*\}', text_response, re.DOTALL)
         if json_match:
-            json_str = json_match.group()
+            json_str = json_match.group(0)
         else:
+            # st.warning("No se encontró un bloque JSON delimitado por ```json o llaves {}.")
+            # st.text_area("Respuesta recibida (sin JSON claro):", text_response, height=100)
             return None
             
-    json_str = re.sub(r'[\n\t\r]', '', json_str)
-    json_str = re.sub(r',\s*}', '}', json_str)
-    json_str = re.sub(r',\s*]', ']', json_str)
+    # Limpiezas comunes
+    json_str = re.sub(r'[\n\t\r]', '', json_str) # Eliminar saltos de línea, tabs dentro del JSON
+    json_str = re.sub(r',\s*([}\]])', r'\1', json_str) # Eliminar comas flotantes antes de } o ]
     return json_str
 
+def parse_gemini_response_for_slides(response_text, expected_slides_key="slides", expected_num_slides=None):
+    """Parsea la respuesta de Gemini esperando una lista de diapositivas."""
+    json_str = extract_and_clean_json(response_text)
+    if not json_str:
+        raise ValueError("No se pudo extraer una cadena JSON válida de la respuesta.")
+    
+    try:
+        data = json.loads(json_str)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Error al decodificar JSON: {e}. JSON intentado: {json_str[:500]}...")
+
+    if not isinstance(data, dict) or expected_slides_key not in data:
+        raise ValueError(f"La estructura del JSON es incorrecta. Falta la clave '{expected_slides_key}'.")
+    
+    slides = data[expected_slides_key]
+    if not isinstance(slides, list):
+        raise ValueError(f"La clave '{expected_slides_key}' debe contener una lista de diapositivas.")
+
+    if expected_num_slides is not None and len(slides) != expected_num_slides:
+        raise ValueError(f"Se esperaban {expected_num_slides} diapositivas, pero se recibieron {len(slides)}.")
+
+    for i, slide in enumerate(slides):
+        if not (isinstance(slide, dict) and 'title' in slide and 'content' in slide):
+            raise ValueError(f"La diapositiva {i+1} tiene una estructura incorrecta. Debe ser un diccionario con 'title' y 'content'.")
+        if not (isinstance(slide['title'], str) and isinstance(slide['content'], str)):
+            raise ValueError(f"El título y el contenido de la diapositiva {i+1} deben ser cadenas de texto.")
+    return slides
+
+
 def generate_presentation_content(topic, client, max_retries=3):
+    """Genera el contenido principal de la presentación (9 diapositivas)."""
     prompt = f"""Genera una presentación de PowerPoint sobre el tema: "{topic}".
     Debes crear exactamente 9 diapositivas. Cada diapositiva debe tener un título y contenido.
     Es CRUCIAL que tu respuesta sea ÚNICAMENTE un JSON válido con la siguiente estructura exacta, sin texto adicional antes o después:
-
     {{
         "slides": [
-            {{"title": "Título de la diapositiva 1", "content": "Contenido de la diapositiva 1"}},
-            {{"title": "Título de la diapositiva 2", "content": "Contenido de la diapositiva 2"}},
-            {{"title": "Título de la diapositiva 3", "content": "Contenido de la diapositiva 3"}},
-            {{"title": "Título de la diapositiva 4", "content": "Contenido de la diapositiva 4"}},
-            {{"title": "Título de la diapositiva 5", "content": "Contenido de la diapositiva 5"}},
-            {{"title": "Título de la diapositiva 6", "content": "Contenido de la diapositiva 6"}},
-            {{"title": "Título de la diapositiva 7", "content": "Contenido de la diapositiva 7"}},
-            {{"title": "Título de la diapositiva 8", "content": "Contenido de la diapositiva 8"}},
-            {{"title": "Título de la diapositiva 9", "content": "Contenido de la diapositiva 9"}}
+            {{"title": "Título Diapositiva 1", "content": "Contenido Diapositiva 1"}},
+            {{"title": "Título Diapositiva 2", "content": "Contenido Diapositiva 2"}},
+            {{"title": "Título Diapositiva 3", "content": "Contenido Diapositiva 3"}},
+            {{"title": "Título Diapositiva 4", "content": "Contenido Diapositiva 4"}},
+            {{"title": "Título Diapositiva 5", "content": "Contenido Diapositiva 5"}},
+            {{"title": "Título Diapositiva 6", "content": "Contenido Diapositiva 6"}},
+            {{"title": "Título Diapositiva 7", "content": "Contenido Diapositiva 7"}},
+            {{"title": "Título Diapositiva 8", "content": "Contenido Diapositiva 8"}},
+            {{"title": "Título Diapositiva 9", "content": "Contenido Diapositiva 9"}}
         ]
     }}
-
     No incluyas ningún otro texto, explicación o saludo. Solo el JSON.
     Asegúrate de que el contenido sea conciso y adecuado para una diapositiva.
     Evita usar caracteres especiales o comillas dentro de los títulos o contenidos que puedan romper el JSON.
     Usa comillas dobles para las claves y los valores string del JSON.
     """
-    
+    last_error = None
+    last_response_text = ""
     for attempt in range(max_retries):
         try:
             response_obj = client.generate_content(prompt)
-            # Check for empty parts or other safety issues if necessary
             if not response_obj.parts:
                 raise ValueError("Respuesta del modelo vacía o mal formada.")
-            response = response_obj.text
-            json_str = extract_and_clean_json(response)
-            if json_str:
-                slides_data = json.loads(json_str)
-                if 'slides' in slides_data and isinstance(slides_data['slides'], list) and len(slides_data['slides']) == 9:
-                    for s_idx, s_data in enumerate(slides_data['slides']):
-                        if not (isinstance(s_data, dict) and 'title' in s_data and 'content' in s_data):
-                            raise ValueError(f"Diapositiva {s_idx+1} tiene estructura incorrecta: falta title o content, o no es un diccionario.")
-                    return slides_data['slides']
-                else:
-                    num_slides = len(slides_data.get('slides', [])) if isinstance(slides_data.get('slides'), list) else "Formato de 'slides' incorrecto"
-                    raise ValueError(f"Estructura JSON incorrecta o número de diapositivas no es 9. Diapositivas encontradas/formato: {num_slides}")
-            else:
-                raise ValueError("No se pudo extraer JSON válido de la respuesta.")
-        except (json.JSONDecodeError, ValueError) as e:
-            st.warning(f"Intento {attempt + 1}/{max_retries} fallido al procesar la respuesta: {str(e)}")
+            last_response_text = response_obj.text
+            slides_data = parse_gemini_response_for_slides(last_response_text, expected_num_slides=9)
+            return slides_data
+        except (ValueError, json.JSONDecodeError) as e:
+            last_error = e
+            st.warning(f"Intento {attempt + 1}/{max_retries} (contenido principal) fallido: {e}")
             if attempt == max_retries - 1:
-                st.error(f"Error al generar el contenido después de {max_retries} intentos.")
-                st.text("Última respuesta del modelo (puede ser muy larga):")
-                st.code(response[:2000] + "..." if len(response) > 2000 else response)
+                st.error(f"Error final al generar contenido principal después de {max_retries} intentos: {last_error}")
+                st.text_area("Última respuesta (contenido principal):", last_response_text, height=150)
                 return None
-            else:
-                st.warning("Reintentando...")
         except Exception as e: # Captura otras excepciones de genai
-            st.warning(f"Error inesperado del API de Gemini en intento {attempt + 1}/{max_retries}: {str(e)}")
+            last_error = e
+            st.warning(f"Error inesperado del API de Gemini (contenido principal) en intento {attempt + 1}/{max_retries}: {e}")
             if attempt == max_retries - 1:
-                st.error(f"Error al generar el contenido después de {max_retries} intentos con el API.")
+                st.error(f"Error final con API de Gemini (contenido principal) después de {max_retries} intentos: {last_error}")
                 return None
-            else:
-                st.warning("Reintentando...")
-    return None
+    return None # Should not be reached if loop completes
+
+def summarize_text_for_slides(text_to_summarize, num_summary_slides, client, max_retries=3):
+    """Resume texto y lo formatea para diapositivas de PowerPoint."""
+    if not text_to_summarize:
+        return []
+    
+    # Limitar la longitud del texto para evitar problemas con el API (ajustar según sea necesario)
+    # Gemini 1.5 Flash tiene un context window grande, pero seamos precavidos.
+    max_len = 30000  # Caracteres (aproximadamente 7k-8k tokens)
+    if len(text_to_summarize) > max_len:
+        st.warning(f"El texto del PDF es muy largo ({len(text_to_summarize)} caracteres). Se truncará a {max_len} caracteres para el resumen.")
+        text_to_summarize = text_to_summarize[:max_len]
+
+    prompt = f"""Eres un asistente experto en resumir documentos para presentaciones.
+    Aquí tienes un texto extraído de un documento PDF:
+    --- TEXTO DEL PDF ---
+    {text_to_summarize}
+    --- FIN DEL TEXTO DEL PDF ---
+
+    Por favor, resume este texto. El resumen debe ser adecuado para ser presentado en {num_summary_slides} diapositiva(s) de PowerPoint.
+    Si num_summary_slides es mayor que 1, divide el resumen en partes lógicas, cada una con un título y contenido.
+
+    Es CRUCIAL que tu respuesta sea ÚNICAMENTE un JSON válido con la siguiente estructura exacta, sin texto adicional antes o después:
+    {{
+        "slides": [
+            {{"title": "Resumen del PDF: Parte 1", "content": "Contenido del resumen parte 1..."}},
+            // ... (más diapositivas de resumen si num_summary_slides > 1, hasta num_summary_slides)
+            {{"title": "Resumen del PDF: Parte {num_summary_slides}", "content": "Contenido del resumen parte {num_summary_slides}..."}}
+        ]
+    }}
+    El título de cada diapositiva de resumen debe indicar claramente que es parte del resumen del PDF (ej: "Resumen PDF: Puntos Clave", "Análisis del Documento PDF").
+    Debe haber exactamente {num_summary_slides} objetos en la lista "slides".
+    Asegúrate de que el contenido de cada diapositiva sea conciso y relevante.
+    Evita usar caracteres especiales o comillas dentro de los títulos o contenidos que puedan romper el JSON.
+    Usa comillas dobles para las claves y los valores string del JSON.
+    """
+    last_error = None
+    last_response_text = ""
+    for attempt in range(max_retries):
+        try:
+            response_obj = client.generate_content(prompt)
+            if not response_obj.parts:
+                raise ValueError("Respuesta del modelo vacía o mal formada (resumen PDF).")
+            last_response_text = response_obj.text
+            summary_slides_data = parse_gemini_response_for_slides(last_response_text, expected_num_slides=num_summary_slides)
+            return summary_slides_data
+        except (ValueError, json.JSONDecodeError) as e:
+            last_error = e
+            st.warning(f"Intento {attempt + 1}/{max_retries} (resumen PDF) fallido: {e}")
+            if attempt == max_retries - 1:
+                st.error(f"Error final al generar resumen PDF después de {max_retries} intentos: {last_error}")
+                st.text_area("Última respuesta (resumen PDF):", last_response_text, height=150)
+                return [] # Retorna lista vacía en caso de error final
+        except Exception as e: # Captura otras excepciones de genai
+            last_error = e
+            st.warning(f"Error inesperado del API de Gemini (resumen PDF) en intento {attempt + 1}/{max_retries}: {e}")
+            if attempt == max_retries - 1:
+                st.error(f"Error final con API de Gemini (resumen PDF) después de {max_retries} intentos: {last_error}")
+                return []
+    return [] # Should not be reached
+
 
 def buscar_imagen_pixabay(query):
     if not PIXABAY_API_KEY:
@@ -119,7 +218,7 @@ def buscar_imagen_pixabay(query):
         data = response.json()
 
         if data.get('hits') and len(data['hits']) > 0:
-            image_info = data['hits'][0]
+            image_info = data['hits'][0] # Tomar la primera imagen relevante
             image_url = image_info.get('largeImageURL', image_info.get('webformatURL'))
             if not image_url: return None
 
@@ -127,77 +226,76 @@ def buscar_imagen_pixabay(query):
             image_response.raise_for_status()
             
             img_bytes = BytesIO(image_response.content)
-            img = Image.open(img_bytes)
-            img.verify() 
-            
-            # Reabrir después de verify, ya que verify puede cerrar el stream
-            img_bytes.seek(0)
-            img = Image.open(img_bytes)
-            return img
+            # Validar y reabrir imagen con PIL
+            try:
+                img = Image.open(img_bytes)
+                img.verify() # Puede cerrar el stream de BytesIO
+                img_bytes.seek(0) # Rebobinar para reabrir
+                img = Image.open(img_bytes)
+                return img
+            except Exception as pil_e:
+                print(f"Error con PIL al procesar imagen de Pixabay ({query}): {pil_e}")
+                return None
     except requests.exceptions.RequestException as e:
         print(f"Error en la solicitud a Pixabay ({query}): {e}")
-    except Exception as e:
-        print(f"Error procesando imagen de Pixabay ({query}): {e}")
+    except Exception as e: # Otros errores (ej. JSONDecodeError de Pixabay)
+        print(f"Error general procesando imagen de Pixabay ({query}): {e}")
     return None
 
-def create_powerpoint(slides_content, template_path):
-    prs = Presentation(template_path)
+def add_slide_content_and_image(slide, slide_data, prs_slide_width, prs_slide_height, add_image=True):
+    """Añade título, contenido y opcionalmente una imagen a una diapositiva."""
+    if slide.shapes.title:
+        slide.shapes.title.text = slide_data['title']
+    
+    content_placeholder = None
+    if slide.placeholders and len(slide.placeholders) > 1 and slide.placeholders[1]:
+         content_placeholder = slide.placeholders[1]
     
-    slide_width_emu = prs.slide_width # Already in EMUs (int)
-    slide_height_emu = prs.slide_height # Already in EMUs (int)
+    margin_emu = Inches(0.3)
+    common_top_emu = Inches(1.6) # Ajustar si el título es más grande/pequeño
+    content_bottom_emu = prs_slide_height - margin_emu
+    
+    # Por defecto, el texto ocupa más si no hay imagen
+    text_area_width_float = prs_slide_width - (2 * margin_emu)
+    text_area_left_emu = margin_emu
+    
+    img_area_width_float = 0
+    if add_image:
+        img_area_width_float = prs_slide_width * 0.40 
+        text_area_width_float = prs_slide_width - img_area_width_float - (2 * margin_emu)
+        # img_area_left_float = text_area_left_emu + text_area_width_float + margin_emu (No es necesario calcular aquí)
 
-    for i, slide_data in enumerate(slides_content):
-        slide_layout = prs.slide_layouts[1] 
-        slide = prs.slides.add_slide(slide_layout)
 
-        if slide.shapes.title:
-            slide.shapes.title.text = slide_data['title']
-        
-        content_placeholder = None
-        if slide.placeholders and len(slide.placeholders) > 1 and slide.placeholders[1]:
-             content_placeholder = slide.placeholders[1]
-        
-        margin_emu = Inches(0.3) # int
-        
-        # Calculate dimensions, these can be float initially
-        img_area_width_float = slide_width_emu * 0.40 
-        img_area_left_float = slide_width_emu - img_area_width_float - margin_emu
-        
-        text_area_width_float = slide_width_emu - img_area_width_float - (2 * margin_emu)
-        text_area_left_emu = margin_emu # int
-
-        common_top_emu = Inches(1.6) # int
-        common_height_emu = slide_height_emu - common_top_emu - margin_emu # int
-
-        if content_placeholder:
-            # Apply int() casting for all dimensions set
-            content_placeholder.left = int(text_area_left_emu)
-            content_placeholder.top = int(common_top_emu)
-            content_placeholder.width = int(text_area_width_float) # CRITICAL FIX
-            content_placeholder.height = int(common_height_emu)
-            
-            tf = content_placeholder.text_frame
-            tf.clear() 
-            p = tf.add_paragraph()
-            p.text = slide_data['content']
-            tf.word_wrap = True
-            tf.auto_size = MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE
-        else:
-            txBox = slide.shapes.add_textbox(
-                int(text_area_left_emu), 
-                int(common_top_emu), 
-                int(text_area_width_float), # CRITICAL FIX
-                int(common_height_emu)
-            )
-            tf = txBox.text_frame
-            tf.text = slide_data['content']
-            tf.word_wrap = True
-            tf.auto_size = MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE
+    common_height_emu = content_bottom_emu - common_top_emu
 
+    if content_placeholder:
+        content_placeholder.left = int(text_area_left_emu)
+        content_placeholder.top = int(common_top_emu)
+        content_placeholder.width = int(text_area_width_float)
+        content_placeholder.height = int(common_height_emu)
+        
+        tf = content_placeholder.text_frame
+        tf.clear() 
+        p = tf.add_paragraph()
+        p.text = slide_data['content']
+        tf.word_wrap = True
+        tf.auto_size = MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE
+    else: # Fallback si no hay placeholder de contenido (típico para slide_layouts[5] o [6])
+        txBox = slide.shapes.add_textbox(
+            int(text_area_left_emu), 
+            int(common_top_emu), 
+            int(text_area_width_float),
+            int(common_height_emu)
+        )
+        tf = txBox.text_frame
+        tf.text = slide_data['content']
+        tf.word_wrap = True
+        tf.auto_size = MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE
+
+    if add_image:
         try:
             first_sentence = slide_data['content'].split('.')[0] if '.' in slide_data['content'] else slide_data['content'][:70]
             image_query = f"{slide_data['title']} {first_sentence}"
-            
             pil_image = buscar_imagen_pixabay(image_query)
 
             if pil_image:
@@ -211,165 +309,213 @@ def create_powerpoint(slides_content, template_path):
 
                 img_native_width_px, img_native_height_px = pil_image.size
                 
-                # Area for image in EMUs (can be float from calculation)
-                available_width_for_img_float = img_area_width_float
-                available_height_for_img_emu = common_height_emu # This is already int
+                available_width_for_img_emu = int(img_area_width_float) # ya es float * EMU_per_inch
+                available_height_for_img_emu = common_height_emu
 
-                # Convert native pixel dimensions to EMU for comparison, assuming 96 DPI
-                # This is a rough conversion; Inches() is more robust for direct sizing
-                # Better: calculate desired Inches and let Inches() convert to EMU
-                
-                # Desired display area in Inches
-                target_img_display_width_inches = available_width_for_img_float / 914400.0 # Convert EMU to Inches
-                target_img_display_height_inches = available_height_for_img_emu / 914400.0 # Convert EMU to Inches
+                # Convertir dimensiones nativas a EMUs para ratio (asumiendo 96 DPI para px -> inches)
+                native_width_inches = img_native_width_px / 96.0
+                native_height_inches = img_native_height_px / 96.0
 
-                # Calculate scaling ratios based on Inches
-                ratio_w = target_img_display_width_inches / (img_native_width_px / 96.0) if (img_native_width_px > 0) else 1.0
-                ratio_h = target_img_display_height_inches / (img_native_height_px / 96.0) if (img_native_height_px > 0) else 1.0
+                # Convertir area disponible a Inches para ratio
+                available_width_inches = available_width_for_img_emu / 914400.0
+                available_height_inches = available_height_for_img_emu / 914400.0
                 
-                scale_ratio = min(ratio_w, ratio_h, 1.0) # Don't scale up beyond 100% of original if it's small
-                                                        # Or, simply min(ratio_w, ratio_h) to fill space
+                ratio_w = available_width_inches / native_width_inches if native_width_inches > 0 else 1.0
+                ratio_h = available_height_inches / native_height_inches if native_height_inches > 0 else 1.0
+                scale_ratio = min(ratio_w, ratio_h)
                 
-                # Final picture dimensions in Inches, then converted to EMU by Inches()
-                pic_width_emu = Inches((img_native_width_px / 96.0) * scale_ratio) # int
-                pic_height_emu = Inches((img_native_height_px / 96.0) * scale_ratio) # int
+                pic_width_emu = Inches(native_width_inches * scale_ratio)
+                pic_height_emu = Inches(native_height_inches * scale_ratio)
 
-                # Centering calculation (can result in floats)
-                pic_left_float = img_area_left_float + (available_width_for_img_float - pic_width_emu) / 2.0
-                pic_top_float = float(common_top_emu) + (float(available_height_for_img_emu) - pic_height_emu) / 2.0
+                # Posicionar imagen a la derecha del texto
+                img_left_float = prs_slide_width - margin_emu - pic_width_emu # Alinear a la derecha con margen
+                if img_left_float < text_area_left_emu + text_area_width_float + Inches(0.1): # Si se solapa, ajustar
+                    img_left_float = text_area_left_emu + text_area_width_float + Inches(0.1)
+                
+                # Centrar verticalmente la imagen en el espacio común
+                img_top_float = float(common_top_emu) + (float(common_height_emu) - pic_height_emu) / 2.0
                 
                 slide.shapes.add_picture(
                     img_byte_arr, 
-                    int(pic_left_float), # CRITICAL FIX
-                    int(pic_top_float),  # CRITICAL FIX
-                    width=pic_width_emu,  # Already int
-                    height=pic_height_emu # Already int
+                    int(img_left_float), 
+                    int(img_top_float),  
+                    width=pic_width_emu,  
+                    height=pic_height_emu 
                 )
         except Exception as e:
-            print(f"No se pudo procesar o insertar imagen para slide {i+1} ('{slide_data['title']}'): {e}")
+            print(f"No se pudo procesar o insertar imagen para slide ('{slide_data['title']}'): {e}")
+
+
+def create_powerpoint(main_slides_content, template_path, summary_slides_content=None):
+    prs = Presentation(template_path)
+    slide_width_emu = prs.slide_width
+    slide_height_emu = prs.slide_height
+
+    # 1. Añadir diapositivas principales (con imágenes)
+    for slide_data in main_slides_content:
+        slide_layout = prs.slide_layouts[1] # Título y Contenido
+        slide = prs.slides.add_slide(slide_layout)
+        add_slide_content_and_image(slide, slide_data, slide_width_emu, slide_height_emu, add_image=True)
 
-    final_slide_layout = prs.slide_layouts[1] 
+    # 2. Añadir diapositivas de resumen del PDF (sin imágenes por ahora)
+    if summary_slides_content:
+        for slide_data in summary_slides_content:
+            slide_layout = prs.slide_layouts[1] # Título y Contenido
+            slide = prs.slides.add_slide(slide_layout)
+            # Llamamos a la misma función, pero con add_image=False
+            add_slide_content_and_image(slide, slide_data, slide_width_emu, slide_height_emu, add_image=False)
+
+
+    # 3. Agregar diapositiva final de agradecimiento
+    final_slide_layout = prs.slide_layouts[1] # O un layout de solo título si existe (ej. layout 5)
     final_slide = prs.slides.add_slide(final_slide_layout)
     if final_slide.shapes.title:
         final_slide.shapes.title.text = "¡Gracias por su atención!"
     
+    # Limpiar el placeholder de contenido si existe en la diapositiva final y no se usa
     if len(final_slide.placeholders) > 1 and final_slide.placeholders[1]:
-        try: # Attempt to remove the content placeholder
+        try: 
             content_ph = final_slide.placeholders[1]
             sp = content_ph.element
             sp.getparent().remove(sp)
         except Exception as e:
-            print(f"Could not remove content placeholder from final slide: {e}") # Non-critical
+            print(f"No se pudo eliminar el placeholder de contenido de la diapositiva final: {e}")
     
     pptx_buffer = io.BytesIO()
     prs.save(pptx_buffer)
     pptx_buffer.seek(0)
     return pptx_buffer
 
+
+# --- INTERFAZ DE STREAMLIT (main) ---
 def main():
-    st.set_page_config(page_title="PowerPoint Mágico", layout="wide")
+    st.set_page_config(page_title="PowerPoint Mágico", layout="wide", initial_sidebar_state="expanded")
     st.title("✨ PowerPoint Mágico con el Búho 🦉")
-    st.markdown("Genera presentaciones impactantes con IA y un toque de magia.")
+    st.markdown("Genera presentaciones impactantes con IA, incluyendo resúmenes de PDF.")
 
-    # Ensure GEMINI_API_KEY and PIXABAY_API_KEY are checked at the start or handled if None
-    if not GEMINI_API_KEY or not PIXABAY_API_KEY:
-        # Error messages already shown at the top
-        return
+    if not GEMINI_API_KEY or not PIXABAY_API_KEY: return
 
     client = get_gemini_model()
 
-    topic = st.text_input("📝 Por favor, ingrese el tema de la presentación:", placeholder="Ej: El futuro de la inteligencia artificial")
+    # --- COLUMNA DE CONFIGURACIÓN (IZQUIERDA) ---
+    st.sidebar.header("Configuración de la Presentación")
+    topic = st.sidebar.text_input("📝 Tema principal de la presentación:", placeholder="Ej: El futuro de la IA")
 
+    # Plantillas
     plantillas_dir = "PLANTILLAS"
     if not os.path.exists(plantillas_dir):
         try:
             os.makedirs(plantillas_dir)
-            st.info(f"Directorio '{plantillas_dir}' creado. Por favor, añada sus plantillas .pptx allí.")
+            st.sidebar.info(f"Directorio '{plantillas_dir}' creado. Añada sus plantillas .pptx allí.")
         except OSError as e:
-            st.error(f"No se pudo crear el directorio de plantillas '{plantillas_dir}': {e}")
+            st.sidebar.error(f"No se pudo crear el dir de plantillas '{plantillas_dir}': {e}")
             st.stop()
 
-
     available_templates = []
     try:
         if os.path.isdir(plantillas_dir):
              available_templates = [f for f in os.listdir(plantillas_dir) if f.endswith(".pptx") and os.path.isfile(os.path.join(plantillas_dir, f))]
     except Exception as e:
-        st.error(f"Error al acceder al directorio de plantillas: {e}")
-        # available_templates remains empty
+        st.sidebar.error(f"Error al acceder al dir de plantillas: {e}")
 
     if not available_templates:
-        st.warning(f"No se encontraron plantillas .pptx en el directorio '{plantillas_dir}'.")
-        # Attempt to create a default one
+        st.sidebar.warning(f"No hay plantillas .pptx en '{plantillas_dir}'.")
         default_prs = Presentation()
-        # Add a title slide layout if not present by default for a blank presentation
-        try:
-            title_slide_layout = default_prs.slide_layouts[0] # Typically Title Slide
-            default_prs.slides.add_slide(title_slide_layout)
-        except IndexError:
-             st.warning("Plantilla por defecto no pudo añadir slide layout inicial.")
+        # Asegurar que hay al menos un layout usable
+        if not default_prs.slide_layouts: default_prs.slide_master.slide_layouts.add_slide_layout()
+        if default_prs.slide_layouts: default_prs.slides.add_slide(default_prs.slide_layouts[0])
 
         default_template_path = os.path.join(plantillas_dir, "default.pptx")
         try:
             default_prs.save(default_template_path)
-            st.info(f"Plantilla por defecto 'default.pptx' creada en '{plantillas_dir}'.")
+            st.sidebar.info(f"Plantilla 'default.pptx' creada.")
             available_templates.append("default.pptx")
         except Exception as e:
-            st.error(f"No se pudo crear la plantilla por defecto: {e}")
-            # If default creation fails and no other templates, it will fail at selectbox
-
+            st.sidebar.error(f"No se pudo crear plantilla por defecto: {e}")
+            
     template_options = {os.path.splitext(t)[0]: os.path.join(plantillas_dir, t) for t in available_templates}
     
     if not template_options:
-        st.error("Error crítico: No hay plantillas disponibles y no se pudo crear una por defecto. Por favor, cree el directorio 'PLANTILLAS' y añada un archivo .pptx.")
+        st.sidebar.error("CRÍTICO: No hay plantillas. Cree 'PLANTILLAS' y añada un .pptx.")
         st.stop()
 
-    selected_template_name = st.selectbox("🎨 Seleccione una plantilla:", list(template_options.keys()))
-
-    if st.button("🚀 Generar Presentación", type="primary"):
-        if topic and selected_template_name:
-            template_path = template_options[selected_template_name]
-            if not os.path.exists(template_path):
-                st.error(f"No se encontró la plantilla seleccionada: {template_path}")
-                return
+    selected_template_name = st.sidebar.selectbox("🎨 Seleccione una plantilla:", list(template_options.keys()))
+
+    # Carga y resumen de PDF
+    st.sidebar.subheader("Resumen de PDF (Opcional)")
+    uploaded_pdf = st.sidebar.file_uploader("📄 Cargue un PDF para resumir:", type="pdf")
+    num_summary_slides = 0
+    if uploaded_pdf:
+        num_summary_slides = st.sidebar.number_input("Nº de diapositivas para el resumen del PDF:", min_value=1, max_value=5, value=2, step=1)
+
+    # --- ÁREA PRINCIPAL (DERECHA) ---
+    if st.button("🚀 Generar Presentación", type="primary", use_container_width=True):
+        if not topic:
+            st.warning("⚠️ Por favor, ingrese un tema para la presentación.")
+            return
+        if not selected_template_name:
+            st.warning("⚠️ Por favor, seleccione una plantilla.") # Debería ser prevenido por la lógica anterior
+            return
+
+        template_path = template_options[selected_template_name]
+        if not os.path.exists(template_path):
+            st.error(f"No se encontró la plantilla: {template_path}")
+            return
+
+        main_slides_content = []
+        summary_slides_content = []
+        
+        overall_progress = st.progress(0)
+        status_text = st.empty()
+
+        # 1. Generar contenido principal
+        status_text.info("🧠 Generando contenido principal con Gemini...")
+        main_slides_content = generate_presentation_content(topic, client)
+        if not main_slides_content:
+            status_text.error("❌ Falló la generación del contenido principal.")
+            overall_progress.progress(100) # Finalizar barra
+            return
+        status_text.success("👍 Contenido principal generado.")
+        overall_progress.progress(33)
+
+        # 2. Procesar y resumir PDF si se cargó
+        if uploaded_pdf and num_summary_slides > 0:
+            status_text.info(f"📄 Procesando PDF '{uploaded_pdf.name}'...")
+            pdf_text = extract_text_from_pdf(uploaded_pdf)
+            overall_progress.progress(45)
+
+            if pdf_text:
+                status_text.info("✍️ Resumiendo texto del PDF con Gemini...")
+                summary_slides_content = summarize_text_for_slides(pdf_text, num_summary_slides, client)
+                if summary_slides_content:
+                    status_text.success(f"👍 Resumen del PDF generado en {len(summary_slides_content)} diapositiva(s).")
+                else:
+                    status_text.warning("⚠️ No se pudo generar el resumen del PDF o la respuesta fue vacía.")
+            else:
+                status_text.warning("⚠️ No se pudo extraer texto del PDF.")
+        overall_progress.progress(66)
 
-            progress_bar = st.progress(0)
-            status_text = st.empty()
+        # 3. Crear archivo PowerPoint
+        status_text.info("🛠️ Creando archivo PowerPoint...")
+        try:
+            pptx_buffer = create_powerpoint(main_slides_content, template_path, summary_slides_content)
+            overall_progress.progress(100)
+            status_text.success("🎉 ¡Presentación generada con éxito!")
 
-            status_text.text("🧠 Generando contenido de la presentación con Gemini...")
-            slides_content = generate_presentation_content(topic, client)
+            clean_topic = re.sub(r'[^\w\s-]', '', topic).strip().replace(' ', '_')
+            file_name = f"{clean_topic}_{selected_template_name}_presentacion.pptx"
             
-            if not slides_content: # Check if content generation failed
-                progress_bar.progress(100) # Show full bar on failure too
-                status_text.error("No se pudo generar el contenido para la presentación. Verifique los mensajes de error anteriores.")
-                return # Stop further execution
-
-            progress_bar.progress(50) # Content generated
-
-            status_text.text("🖼️ Añadiendo imágenes y creando archivo PowerPoint...")
-            try:
-                pptx_buffer = create_powerpoint(slides_content, template_path)
-                progress_bar.progress(100)
-                status_text.success("¡Presentación generada con éxito!")
-
-                clean_topic = re.sub(r'[^\w\s-]', '', topic).strip().replace(' ', '_')
-                file_name = f"{clean_topic}_{selected_template_name}_presentacion.pptx"
-                
-                st.download_button(
-                    label="📥 Descargar Presentación",
-                    data=pptx_buffer,
-                    file_name=file_name,
-                    mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
-                )
-            except Exception as e:
-                progress_bar.progress(100) 
-                status_text.error(f"Ocurrió un error al crear el archivo PowerPoint: {str(e)}")
-                st.exception(e) 
-        else:
-            if not topic:
-                st.warning("⚠️ Por favor, ingrese un tema para la presentación.")
-            if not selected_template_name: # Should not happen if template_options is populated
-                st.warning("⚠️ Por favor, seleccione una plantilla.")
+            st.download_button(
+                label="📥 Descargar Presentación",
+                data=pptx_buffer,
+                file_name=file_name,
+                mime="application/vnd.openxmlformats-officedocument.presentationml.presentation",
+                use_container_width=True
+            )
+        except Exception as e:
+            overall_progress.progress(100)
+            status_text.error(f"❌ Ocurrió un error al crear el archivo PowerPoint: {str(e)}")
+            st.exception(e)
 
 if __name__ == "__main__":
     main()