Update app.py

app.py

@@ -10,17 +10,15 @@ import os
 import json
 import re
 import google.generativeai as genai
-import pdfplumber # Nueva importación
+import pdfplumber
 
 # --- 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 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.")
@@ -33,44 +31,31 @@ def get_gemini_model():
 
 # --- 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)
+            full_text = [page.extract_text() for page in pdf.pages if page.extract_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:
-        # 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(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
-            
-    # 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 ]
+    json_str = re.sub(r'[\n\t\r]', '', json_str)
+    json_str = re.sub(r',\s*([}\]])', r'\1', json_str)
     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."""
+def parse_gemini_response_for_slides(response_text, expected_slides_key="slides", expected_num_slides=None, is_single_slide=False):
     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.")
@@ -80,6 +65,13 @@ def parse_gemini_response_for_slides(response_text, expected_slides_key="slides"
     except json.JSONDecodeError as e:
         raise ValueError(f"Error al decodificar JSON: {e}. JSON intentado: {json_str[:500]}...")
 
+    if is_single_slide: # Para el título creativo
+        if not (isinstance(data, dict) and 'title' in data and 'content' in data):
+             raise ValueError("La estructura del JSON para la diapositiva de título es incorrecta. Se esperaba 'title' y 'content'.")
+        if not (isinstance(data['title'], str) and isinstance(data['content'], str)):
+            raise ValueError("El título y el contenido de la diapositiva de título deben ser cadenas.")
+        return [data] # Devolver como lista de una diapositiva
+
     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}'.")
     
@@ -97,226 +89,216 @@ def parse_gemini_response_for_slides(response_text, expected_slides_key="slides"
             raise ValueError(f"El título y el contenido de la diapositiva {i+1} deben ser cadenas de texto.")
     return slides
 
+def generate_creative_title_slide(topic, client, max_retries=3):
+    """Genera una única diapositiva de título creativa."""
+    prompt = f"""Genera un título MUY llamativo y creativo para una presentación sobre "{topic}".
+    Además, proporciona una breve frase o subtítulo de impacto para acompañar el título.
+    Es CRUCIAL que tu respuesta sea ÚNICAMENTE un JSON válido con la siguiente estructura exacta, sin texto adicional antes o después:
+    {{
+        "title": "Título Creativo y Llamativo Generado",
+        "content": "Breve subtítulo o frase de impacto."
+    }}
+    No incluyas ningún otro texto, explicación o saludo. Solo el JSON.
+    El título debe despertar curiosidad e interés. El contenido debe ser muy conciso.
+    """
+    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 (título creativo).")
+            last_response_text = response_obj.text
+            title_slide_data = parse_gemini_response_for_slides(last_response_text, is_single_slide=True)
+            return title_slide_data # Es una lista con un solo diccionario de slide
+        except (ValueError, json.JSONDecodeError) as e:
+            last_error = e
+            st.warning(f"Intento {attempt + 1}/{max_retries} (título creativo) fallido: {e}")
+            if attempt == max_retries - 1:
+                st.error(f"Error final al generar título creativo: {last_error}")
+                st.text_area("Última respuesta (título creativo):", last_response_text, height=100)
+                return None
+        except Exception as e:
+            last_error = e; st.warning(f"Error API Gemini (título creativo) intento {attempt + 1}: {e}")
+            if attempt == max_retries - 1: st.error(f"Error API Gemini (título creativo): {last_error}"); return None
+    return None
+
 
 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.
+    Debes crear exactamente 9 diapositivas de contenido principal. 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 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"}},
+            // ...hasta...
             {{"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.
+    No incluyas ningún otro texto. Solo el JSON. Los títulos deben ser informativos y seguir una progresión lógica.
+    El contenido debe ser conciso. Usa comillas dobles para claves y strings.
     """
-    last_error = None
-    last_response_text = ""
+    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.")
+            if not response_obj.parts: raise ValueError("Respuesta del modelo vacía (contenido principal).")
             last_response_text = response_obj.text
-            slides_data = parse_gemini_response_for_slides(last_response_text, expected_num_slides=9)
-            return slides_data
+            return parse_gemini_response_for_slides(last_response_text, expected_num_slides=9)
         except (ValueError, json.JSONDecodeError) as e:
-            last_error = e
-            st.warning(f"Intento {attempt + 1}/{max_retries} (contenido principal) fallido: {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 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
-        except Exception as e: # Captura otras excepciones de genai
-            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 final con API de Gemini (contenido principal) después de {max_retries} intentos: {last_error}")
-                return None
-    return None # Should not be reached if loop completes
+                st.error(f"Error final (contenido principal): {last_error}")
+                st.text_area("Última resp. (contenido principal):", last_response_text, height=150); return None
+        except Exception as e:
+            last_error = e; st.warning(f"Error API Gemini (contenido principal) intento {attempt + 1}: {e}")
+            if attempt == max_retries - 1: st.error(f"Error API Gemini (contenido principal): {last_error}"); return None
+    return None
 
-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)
+def generate_conclusion_slides_from_text(text_to_summarize, num_conclusion_slides, topic, client, max_retries=3):
+    """Genera diapositivas de conclusión basadas en el texto y el tema general."""
+    if not text_to_summarize: return []
+    max_len = 30000 
     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.")
+        st.warning(f"Texto del PDF ({len(text_to_summarize)} chars) truncado a {max_len} para conclusiones.")
         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 ---
+    prompt = f"""Dado el siguiente texto (extraído de un documento relacionado con el tema general "{topic}"):
+    --- TEXTO DEL DOCUMENTO ---
     {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.
+    --- FIN DEL TEXTO ---
 
+    Genera {num_conclusion_slides} diapositiva(s) de CONCLUSIÓN para una presentación sobre "{topic}".
+    Estas diapositivas deben sintetizar las ideas clave del texto proporcionado y conectarlas como conclusiones relevantes para el tema "{topic}".
+    Los títulos de estas diapositivas deben sonar como conclusiones o puntos finales (ej: "Reflexiones Finales", "Mirando Hacia Adelante", "Conclusiones Clave", "Implicaciones y Futuro"). NO uses la palabra "PDF" ni "Resumen" en los títulos.
+    
     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}..."}}
+            {{"title": "Título Conclusión 1", "content": "Contenido conclusión 1..."}},
+            // ... (hasta num_conclusion_slides)
+            {{"title": "Título Conclusión {num_conclusion_slides}", "content": "Contenido conclusión {num_conclusion_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.
+    Debe haber exactamente {num_conclusion_slides} objetos en la lista "slides". Contenido conciso.
+    Usa comillas dobles para claves y strings.
     """
-    last_error = None
-    last_response_text = ""
+    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).")
+            if not response_obj.parts: raise ValueError("Respuesta del modelo vacía (conclusiones).")
             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
+            return parse_gemini_response_for_slides(last_response_text, expected_num_slides=num_conclusion_slides)
         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}")
+            last_error = e; st.warning(f"Intento {attempt + 1}/{max_retries} (conclusiones) fallido: {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
+                st.error(f"Error final (conclusiones): {last_error}")
+                st.text_area("Última resp. (conclusiones):", last_response_text, height=150); return []
+        except Exception as e:
+            last_error = e; st.warning(f"Error API Gemini (conclusiones) intento {attempt + 1}: {e}")
+            if attempt == max_retries - 1: st.error(f"Error API Gemini (conclusiones): {last_error}"); return []
+    return []
 
 
 def buscar_imagen_pixabay(query):
-    if not PIXABAY_API_KEY:
-        print("Pixabay API Key no configurada.")
-        return None
+    if not PIXABAY_API_KEY: return None
     url = f"https://pixabay.com/api/?key={PIXABAY_API_KEY}&q={requests.utils.quote(query)}&image_type=photo&per_page=3&safesearch=true"
     try:
-        response = requests.get(url, timeout=10)
-        response.raise_for_status() 
+        response = requests.get(url, timeout=10); response.raise_for_status()
         data = response.json()
-
-        if data.get('hits') and len(data['hits']) > 0:
-            image_info = data['hits'][0] # Tomar la primera imagen relevante
+        if data.get('hits'):
+            image_info = data['hits'][0]
             image_url = image_info.get('largeImageURL', image_info.get('webformatURL'))
             if not image_url: return None
-
-            image_response = requests.get(image_url, timeout=10)
-            image_response.raise_for_status()
-            
+            image_response = requests.get(image_url, timeout=10); image_response.raise_for_status()
             img_bytes = BytesIO(image_response.content)
-            # 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: # Otros errores (ej. JSONDecodeError de Pixabay)
-        print(f"Error general procesando imagen de Pixabay ({query}): {e}")
+                img = Image.open(img_bytes); img.verify(); img_bytes.seek(0)
+                return Image.open(img_bytes)
+            except Exception as pil_e: print(f"Error PIL ({query}): {pil_e}"); return None
+    except requests.exceptions.RequestException as e: print(f"Error Pixabay req ({query}): {e}")
+    except Exception as e: print(f"Error Pixabay gral ({query}): {e}")
     return None
 
-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."""
+def add_slide_content_and_image(slide, slide_data, prs_slide_width, prs_slide_height, add_image=True, is_title_slide=False):
     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]
-    
+    # Para la diapositiva de título, el placeholder de contenido puede ser el primero si el layout es de título solo
+    if is_title_slide and slide.placeholders and slide.placeholders[0] == slide.shapes.title and len(slide.placeholders) > 1:
+        content_placeholder = slide.placeholders[1] # Subtitle placeholder
+    elif not is_title_slide and slide.placeholders and len(slide.placeholders) > 1 and slide.placeholders[1]:
+         content_placeholder = slide.placeholders[1] # Body placeholder
+
     margin_emu = Inches(0.3)
-    common_top_emu = Inches(1.6) # Ajustar si el título es más grande/pequeño
+    # Si es diapositiva de título, el contenido (subtítulo) puede estar más arriba
+    common_top_emu = Inches(0.5) if is_title_slide and slide.shapes.title else Inches(1.6)
+    if is_title_slide and content_placeholder: # Ajustar top del subtitulo
+         common_top_emu = content_placeholder.top 
+    
     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:
+    if add_image and not is_title_slide: # No añadir imagen a la diapositiva de título principal
         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í)
+        text_area_width_float = prs_slide_width - img_area_width_float - (3 * margin_emu) # +margen entre texto e img
 
 
     common_height_emu = content_bottom_emu - common_top_emu
-
+    if is_title_slide and content_placeholder: # Ajustar altura del subtitulo
+        common_height_emu = content_placeholder.height
+    
     if content_placeholder:
         content_placeholder.left = int(text_area_left_emu)
-        content_placeholder.top = int(common_top_emu)
+        if not is_title_slide: # No sobreescribir el top del subtítulo si ya está bien
+            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 = 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])
+        tf.auto_size = MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE if not is_title_slide else MSO_AUTO_SIZE.NONE
+        if is_title_slide: # Centrar subtítulo
+            p.alignment = PP_ALIGN.CENTER # Necesitarías: from pptx.enum.text import PP_ALIGN
+            tf.vertical_anchor = MSO_ANCHOR.MIDDLE
+    else: 
+        txBox_top = common_top_emu
+        if is_title_slide and slide.shapes.title: # Colocar subtítulo debajo del título principal
+            txBox_top = slide.shapes.title.top + slide.shapes.title.height + Inches(0.2)
+
         txBox = slide.shapes.add_textbox(
-            int(text_area_left_emu), 
-            int(common_top_emu), 
-            int(text_area_width_float),
-            int(common_height_emu)
+            int(text_area_left_emu), int(txBox_top), 
+            int(text_area_width_float), int(common_height_emu / (1.5 if is_title_slide else 1) ) # Menos altura para subtitulo
         )
-        tf = txBox.text_frame
-        tf.text = slide_data['content']
+        tf = txBox.text_frame; tf.text = slide_data['content']
         tf.word_wrap = True
-        tf.auto_size = MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE
+        tf.auto_size = MSO_AUTO_SIZE.SHAPE_TO_FIT_TEXT if is_title_slide else MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE
+        if is_title_slide: # Centrar subtítulo
+            p = tf.paragraphs[0]; p.alignment = PP_ALIGN.CENTER # Necesitarías: from pptx.enum.text import PP_ALIGN
+            tf.vertical_anchor = MSO_ANCHOR.TOP
 
-    if add_image:
+
+    if add_image and not is_title_slide:
         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:
-                img_byte_arr = io.BytesIO()
-                img_format = pil_image.format if pil_image.format in ['JPEG', 'PNG', 'GIF'] else 'PNG'
-                if img_format == 'JPEG' and pil_image.mode == 'RGBA': 
-                    pil_image = pil_image.convert('RGB')
-                
-                pil_image.save(img_byte_arr, format=img_format)
-                img_byte_arr.seek(0)
+                img_byte_arr = io.BytesIO(); img_format = pil_image.format if pil_image.format in ['JPEG', 'PNG', 'GIF'] else 'PNG'
+                if img_format == 'JPEG' and pil_image.mode == 'RGBA': pil_image = pil_image.convert('RGB')
+                pil_image.save(img_byte_arr, format=img_format); img_byte_arr.seek(0)
 
                 img_native_width_px, img_native_height_px = pil_image.size
-                
-                available_width_for_img_emu = int(img_area_width_float) # ya es float * EMU_per_inch
+                available_width_for_img_emu = int(img_area_width_float)
                 available_height_for_img_emu = common_height_emu
 
-                # 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
-
-                # Convertir area disponible a Inches para ratio
+                native_width_inches = img_native_width_px / 96.0; native_height_inches = img_native_height_px / 96.0
                 available_width_inches = available_width_for_img_emu / 914400.0
                 available_height_inches = available_height_for_img_emu / 914400.0
                 
@@ -327,63 +309,55 @@ def add_slide_content_and_image(slide, slide_data, prs_slide_width, prs_slide_he
                 pic_width_emu = Inches(native_width_inches * scale_ratio)
                 pic_height_emu = Inches(native_height_inches * scale_ratio)
 
-                # 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 = prs_slide_width - margin_emu - pic_width_emu 
+                if img_left_float < text_area_left_emu + text_area_width_float + Inches(0.1):
                     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(img_left_float), 
-                    int(img_top_float),  
-                    width=pic_width_emu,  
-                    height=pic_height_emu 
+                    img_byte_arr, 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 ('{slide_data['title']}'): {e}")
+            print(f"No se pudo procesar/insertar imagen ('{slide_data['title']}'): {e}")
 
 
-def create_powerpoint(main_slides_content, template_path, summary_slides_content=None):
+def create_powerpoint(title_slide_content, main_slides_content, template_path, conclusion_slides_content=None):
     prs = Presentation(template_path)
     slide_width_emu = prs.slide_width
     slide_height_emu = prs.slide_height
+    from pptx.enum.text import PP_ALIGN # Importar aquí para evitar error si no se usa add_slide_content_and_image
 
-    # 1. Añadir diapositivas principales (con imágenes)
+    # 0. Diapositiva de Título Creativa (usar layout de título, ej. 0 o 5)
+    if title_slide_content: # es una lista con 1 slide_data
+        # Intentar usar un layout de solo título si está disponible, sino el de título y contenido.
+        title_layout = prs.slide_layouts[0] if prs.slide_layouts else prs.slide_layouts[5] if len(prs.slide_layouts) > 5 else prs.slide_layouts[1]
+        slide = prs.slides.add_slide(title_layout)
+        add_slide_content_and_image(slide, title_slide_content[0], slide_width_emu, slide_height_emu, add_image=False, is_title_slide=True)
+
+    # 1. 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)
 
-    # 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
+    # 2. Diapositivas de Conclusión (sin imágenes)
+    if conclusion_slides_content:
+        for slide_data in conclusion_slides_content:
+            slide_layout = prs.slide_layouts[1] 
             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)
+    # 3. Diapositiva final de agradecimiento
+    final_slide_layout = prs.slide_layouts[1] 
     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 final_slide.shapes.title: final_slide.shapes.title.text = "¡Gracias por su atención!"
     if len(final_slide.placeholders) > 1 and final_slide.placeholders[1]:
-        try: 
-            content_ph = final_slide.placeholders[1]
-            sp = content_ph.element
-            sp.getparent().remove(sp)
-        except Exception as e:
-            print(f"No se pudo eliminar el placeholder de contenido de la diapositiva final: {e}")
+        try: content_ph = final_slide.placeholders[1]; sp = content_ph.element; sp.getparent().remove(sp)
+        except Exception as e: print(f"No se pudo quitar placeholder de diap. final: {e}")
     
-    pptx_buffer = io.BytesIO()
-    prs.save(pptx_buffer)
-    pptx_buffer.seek(0)
+    pptx_buffer = io.BytesIO(); prs.save(pptx_buffer); pptx_buffer.seek(0)
     return pptx_buffer
 
 
@@ -391,131 +365,104 @@ def create_powerpoint(main_slides_content, template_path, summary_slides_content
 def main():
     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, incluyendo resúmenes de PDF.")
+    st.markdown("Genera presentaciones impactantes con IA, incluyendo conclusiones de PDF.")
 
     if not GEMINI_API_KEY or not PIXABAY_API_KEY: return
-
     client = get_gemini_model()
 
-    # --- 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"
+    # ... (resto de la lógica de plantillas sin cambios, solo movida a sidebar si no estaba ya) ...
     if not os.path.exists(plantillas_dir):
-        try:
-            os.makedirs(plantillas_dir)
-            st.sidebar.info(f"Directorio '{plantillas_dir}' creado. Añada sus plantillas .pptx allí.")
-        except OSError as e:
-            st.sidebar.error(f"No se pudo crear el dir de plantillas '{plantillas_dir}': {e}")
-            st.stop()
-
+        try: os.makedirs(plantillas_dir); st.sidebar.info(f"Directorio '{plantillas_dir}' creado.")
+        except OSError as e: st.sidebar.error(f"No se pudo crear dir '{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.sidebar.error(f"Error al acceder al dir de plantillas: {e}")
-
+    except Exception as e: st.sidebar.error(f"Error al acceder dir plantillas: {e}")
     if not available_templates:
         st.sidebar.warning(f"No hay plantillas .pptx en '{plantillas_dir}'.")
         default_prs = Presentation()
-        # 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.sidebar.info(f"Plantilla 'default.pptx' creada.")
-            available_templates.append("default.pptx")
-        except Exception as e:
-            st.sidebar.error(f"No se pudo crear plantilla por defecto: {e}")
-            
+        try: default_prs.save(default_template_path); st.sidebar.info(f"Plantilla 'default.pptx' creada."); available_templates.append("default.pptx")
+        except Exception as e: 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.sidebar.error("CRÍTICO: No hay plantillas. Cree 'PLANTILLAS' y añada un .pptx.")
-        st.stop()
-
+    if not template_options: st.sidebar.error("CRÍTICO: No hay plantillas."); st.stop()
     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
+
+    st.sidebar.subheader("Conclusiones desde PDF (Opcional)")
+    uploaded_pdf = st.sidebar.file_uploader("📄 Cargue un PDF para generar conclusiones:", type="pdf")
+    num_conclusion_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)
+        num_conclusion_slides = st.sidebar.number_input("Nº de diapositivas para las conclusiones del PDF:", min_value=1, max_value=3, value=1, 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
+        if not topic: st.warning("⚠️ Ingrese un tema."); return
+        if not selected_template_name: st.warning("⚠️ Seleccione una plantilla."); 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
+        if not os.path.exists(template_path): st.error(f"No se encontró plantilla: {template_path}"); return
 
+        title_slide_content = None
         main_slides_content = []
-        summary_slides_content = []
+        conclusion_slides_content = []
         
         overall_progress = st.progress(0)
         status_text = st.empty()
 
+        # 0. Generar título creativo
+        status_text.info("🎨 Creando un título impactante...")
+        title_slide_content = generate_creative_title_slide(topic, client)
+        if not title_slide_content:
+            status_text.warning("⚠️ No se pudo generar el título creativo, continuando sin él.")
+            # No detenemos la ejecución, solo no habrá diapositiva de título.
+        else:
+            status_text.success("👍 Título creativo generado.")
+        overall_progress.progress(10)
+
+
         # 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)
+            status_text.error("❌ Falló la generación del contenido principal."); overall_progress.progress(100); return
+        status_text.success("👍 Contenido principal generado."); overall_progress.progress(50)
 
+        # 2. Procesar PDF para conclusiones
+        if uploaded_pdf and num_conclusion_slides > 0:
+            status_text.info(f"📄 Procesando PDF '{uploaded_pdf.name}' para conclusiones...")
+            pdf_text = extract_text_from_pdf(uploaded_pdf); overall_progress.progress(60)
             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)
+                status_text.info("✍️ Generando diapositivas de conclusión con Gemini...")
+                conclusion_slides_content = generate_conclusion_slides_from_text(pdf_text, num_conclusion_slides, topic, client)
+                if conclusion_slides_content: status_text.success(f"👍 Conclusiones generadas ({len(conclusion_slides_content)} diap.).")
+                else: status_text.warning("⚠️ No se pudo generar conclusiones del PDF.")
+            else: status_text.warning("⚠️ No se pudo extraer texto del PDF.")
+        overall_progress.progress(80)
 
         # 3. Crear archivo PowerPoint
         status_text.info("🛠️ Creando archivo PowerPoint...")
         try:
-            pptx_buffer = create_powerpoint(main_slides_content, template_path, summary_slides_content)
+            # Necesitamos PP_ALIGN para centrar el subtítulo de la diapositiva de título
+            from pptx.enum.text import PP_ALIGN 
+            pptx_buffer = create_powerpoint(title_slide_content, main_slides_content, template_path, conclusion_slides_content)
             overall_progress.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,
+                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)
+            overall_progress.progress(100); status_text.error(f"❌ Error al crear PowerPoint: {str(e)}"); st.exception(e)
 
 if __name__ == "__main__":
     main()