Update app.py

app.py

@@ -5,475 +5,281 @@ import re
 import os
 import shutil
 import fitz  # PyMuPDF
-from PIL import Image, ImageDraw, ImageFont
-from collections import defaultdict
+from PIL import Image
 import io
-from pypdf import PdfWriter
-import random
 
-# New imports for the SVG Emoji Engine
-from lxml import etree
-from svglib.svglib import svg2rlg
-
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, BaseDocTemplate, Frame, PageTemplate, Image as ReportLabImage, Flowable
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, BaseDocTemplate, Frame, PageTemplate, Image as ReportLabImage
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.pagesizes import letter, A4, legal, landscape
+from reportlab.lib.pagesizes import letter
 from reportlab.lib.units import inch
 from reportlab.lib import colors
 from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
-from functools import partial
 
-# --- Configuration & Setup ---
+# --- Configuration ---
 CWD = Path.cwd()
-TEMP_DIR = CWD / "temp_icons"
-LAYOUTS = {
-    "A4 Portrait": {"size": A4},
-    "A4 Landscape": {"size": landscape(A4)},
-    "Letter Portrait": {"size": letter},
-    "Letter Landscape": {"size": landscape(letter)},
-    "Legal Portrait": {"size": legal},
-    "Legal Landscape": {"size": landscape(legal)},
-}
-OUTPUT_DIR = CWD / "generated_pdfs"
-PREVIEW_DIR = CWD / "previews"
-FONT_DIR = CWD # Assumes fonts are in the same directory as the script
-
-# Create necessary directories
-OUTPUT_DIR.mkdir(exist_ok=True)
-PREVIEW_DIR.mkdir(exist_ok=True)
-TEMP_DIR.mkdir(exist_ok=True)
+# Create dedicated directories for clarity
+INPUT_DIR = CWD / "uploaded_files"
+OUTPUT_DIR = CWD / "output_pdfs"
+TEMP_DIR = CWD / "temp_emoji_images"
+FONT_DIR = CWD  # Assumes fonts are in the same directory as the script
 
+# Ensure all directories exist
+for d in [INPUT_DIR, OUTPUT_DIR, TEMP_DIR]:
+    d.mkdir(exist_ok=True)
 
 # --- Font & Emoji Handling ---
-EMOJI_IMAGE_CACHE, EMOJI_SVG_CACHE = {}, {}
-EMOJI_FONT_PATH, UI_FONT_PATH = None, None
+EMOJI_FONT_PATH = None
+EMOJI_IMAGE_CACHE = {}
 
-def register_local_fonts():
-    """Finds and registers all .ttf files from the application's base directory."""
-    global EMOJI_FONT_PATH, UI_FONT_PATH
-    print("--- Font Registration Process Starting ---")
-    text_font_names = []
+def setup_fonts():
+    """Finds the NotoColorEmoji font, which is critical for this process."""
+    global EMOJI_FONT_PATH
+    print("--- Setting up fonts ---")
     
+    # Locate the essential NotoColorEmoji font
     noto_emoji_path = FONT_DIR / "NotoColorEmoji-Regular.ttf"
     if noto_emoji_path.exists():
         EMOJI_FONT_PATH = str(noto_emoji_path)
+        print(f"Found emoji font: {EMOJI_FONT_PATH}")
     else:
-        print("CRITICAL: 'NotoColorEmoji-Regular.ttf' not found. Color emojis will not work.")
-    
-    print(f"Scanning for fonts in: {FONT_DIR.absolute()}")
-    font_files = list(FONT_DIR.glob("*.ttf"))
-    
-    for font_path in font_files:
-        try:
-            font_name = font_path.stem
-            if not UI_FONT_PATH: UI_FONT_PATH = str(font_path) # Grab first available font for UI icons
-            
-            pdfmetrics.registerFont(TTFont(font_name, str(font_path)))
-            pdfmetrics.registerFontFamily(font_name, normal=font_name, bold=font_name, italic=font_name, boldItalic=font_name)
-            
-            if "notocoloremoji-regular" not in font_name.lower() and "notoemoji" not in font_name.lower():
-                text_font_names.append(font_name)
-        except Exception as e:
-            print(f"Could not register font {font_path.name}: {e}")
-
-    if not text_font_names:
-        text_font_names.append('Helvetica')
-    print(f"Successfully registered user-selectable fonts: {text_font_names}")
-    return sorted(text_font_names)
-
-def render_emoji_as_image(emoji_char, size_pt):
-    if not EMOJI_FONT_PATH: return None
-    if (emoji_char, size_pt) in EMOJI_IMAGE_CACHE: return EMOJI_IMAGE_CACHE[(emoji_char, size_pt)]
-    try:
-        rect, doc = fitz.Rect(0, 0, size_pt*1.5, size_pt*1.5), fitz.open()
-        page = doc.new_page(width=rect.width, height=rect.height)
-        page.insert_font(fontname="emoji", fontfile=EMOJI_FONT_PATH)
-        page.insert_text(fitz.Point(0, size_pt * 1.1), emoji_char, fontname="emoji", fontsize=size_pt)
-        pix, img_buffer = page.get_pixmap(alpha=True, dpi=300), io.BytesIO(pix.tobytes("png"))
-        doc.close(); img_buffer.seek(0)
-        EMOJI_IMAGE_CACHE[(emoji_char, size_pt)] = img_buffer
-        return img_buffer
-    except Exception as e: print(f"Could not render emoji {emoji_char} as image: {e}"); return None
-
-def render_emoji_as_svg(emoji_char, size_pt):
-    if not EMOJI_FONT_PATH: return None
-    if (emoji_char, size_pt) in EMOJI_SVG_CACHE: return EMOJI_SVG_CACHE[(emoji_char, size_pt)]
+        print("CRITICAL ERROR: 'NotoColorEmoji-Regular.ttf' not found in the application directory.")
+        print("This file is required to render emojis as images. Please add it to the directory.")
+        # Raise an error to stop the app from running in a broken state
+        raise FileNotFoundError("Could not find NotoColorEmoji-Regular.ttf. The application cannot proceed.")
+        
+    # Register a basic font for ReportLab
     try:
-        doc = fitz.open(); page = doc.new_page(width=1000, height=1000)
-        page.insert_font(fontname="emoji", fontfile=EMOJI_FONT_PATH)
-        svg_image = page.get_svg_image(page.rect, text=emoji_char, fontname="emoji")
-        doc.close()
-        drawing = svg2rlg(io.BytesIO(svg_image.encode('utf-8')))
-        scale_factor = (size_pt * 1.2) / drawing.height
-        drawing.width, drawing.height = drawing.width*scale_factor, drawing.height*scale_factor
-        drawing.scale(scale_factor, scale_factor)
-        EMOJI_SVG_CACHE[(emoji_char, size_pt)] = drawing
-        return drawing
-    except Exception as e: print(f"Could not render emoji {emoji_char} as SVG: {e}"); return None
+        pdfmetrics.registerFont(TTFont('DejaVuSans', 'DejaVuSans.ttf'))
+        pdfmetrics.registerFontFamily('DejaVuSans', normal='DejaVuSans', bold='DejaVuSans-Bold', italic='DejaVuSans-Oblique', boldItalic='DejaVuSans-BoldOblique')
+    except:
+        print("Warning: DejaVuSans font not found. Falling back to Helvetica. Please add DejaVuSans.ttf for better Unicode support.")
 
-# --- AI Content Generation (Simulation) ---
-def generate_ai_content_api(prompt):
+def render_emoji_as_image(emoji_char, size_pt):
     """
-    Simulates a call to an LLM to generate markdown content.
+    Takes a single emoji character and renders it as a transparent PNG image in memory.
+    This is the core of the solution to ensure emojis appear in color in any PDF viewer.
     """
-    if not prompt:
-        return "# The Golem awaits your command!\n\nPlease enter a prompt in the box above and click '🧠 Animate Golem!' to get started. I can help you write reports, stories, poems, and more! ✨"
-
-    import time
-    time.sleep(1.5)
-
-    sample_story = f"""
-# The Quest for the Sunstone ☀️
-
-Long ago, in the mystical land of Aerthos, a creeping shadow began to fall across the valleys. The once-vibrant flowers 🌸 drooped, and the rivers ran slow. The elders knew the cause: the light of the Sunstone, hidden deep within Mount Cinder, was fading.
-
-## The Prophecy 📜
-
-An ancient prophecy spoke of a hero who would rekindle the stone. It read:
-> When darkness drapes the verdant ground,
-> A soul of courage shall be found.
-> Through trials of fire 🔥, wit, and might,
-> They'll bring once more the sacred light.
-
-## The Chosen One 🦸‍♀️
-
-A young woman named Elara, known for her kindness and bravery, was chosen. She accepted the quest, her only companions a loyal wolf 🐺 and a map gifted by the village shaman.
-"""
-    return f"# Golem's Vision for: '{prompt}'\n\n{sample_story}"
-
-
-# --- UI & File Handling ---
-FILE_ICONS = defaultdict(lambda: '❓', {
-    '.md': '📜', '.txt': '📄', '.py': '🐍', '.js': '⚡', '.html': '🌐', '.css': '🎨', '.json': '�',
-    '.png': '🖼️', '.jpg': '🖼️', '.jpeg': '🖼️', '.gif': '🖼️', '.bmp': '🖼️', '.tiff': '🖼️',
-    '.pdf': '📚'
-})
+    if not EMOJI_FONT_PATH:
+        print("Cannot render emoji: Emoji font path not set.")
+        return None
+    
+    # Use a cache to avoid re-rendering the same emoji multiple times
+    if (emoji_char, size_pt) in EMOJI_IMAGE_CACHE:
+        return EMOJI_IMAGE_CACHE[(emoji_char, size_pt)]
 
-def create_file_icon_image(file_path: Path):
-    """Creates a preview image for a file with an icon and its name."""
-    icon = FILE_ICONS[file_path.suffix.lower()]
-    img = Image.new('RGB', (150, 100), color='#1f2937')
-    draw = ImageDraw.Draw(img)
     try:
-        icon_font = ImageFont.truetype(EMOJI_FONT_PATH, 40) if EMOJI_FONT_PATH else ImageFont.load_default()
-        text_font = ImageFont.truetype(UI_FONT_PATH, 10) if UI_FONT_PATH else ImageFont.load_default()
-    except:
-        icon_font, text_font = ImageFont.load_default(), ImageFont.load_default()
+        # Use PyMuPDF (fitz) to draw the emoji onto a temporary, transparent canvas
+        rect = fitz.Rect(0, 0, size_pt * 1.5, size_pt * 1.5)
+        doc = fitz.open()
+        page = doc.new_page(width=rect.width, height=rect.height)
         
-    draw.text((75, 40), icon, font=icon_font, anchor="mm", fill="#a855f7")
-    draw.text((75, 80), file_path.name, font=text_font, anchor="mm", fill="#d1d5db")
-    
-    out_path = TEMP_DIR / f"{file_path.stem}_{file_path.suffix[1:]}.png"
-    img.save(out_path)
-    return out_path
-
-def update_staging_and_manuscript(files, current_manuscript):
-    """Processes uploaded files, updates staging galleries, and consolidates text content."""
-    shutil.rmtree(TEMP_DIR, ignore_errors=True); TEMP_DIR.mkdir(exist_ok=True)
-    
-    text_gallery, image_gallery, pdf_gallery = [], [], []
-    text_content_to_add = []
-    has_text_files = False
-    
-    if not files:
-        return text_gallery, image_gallery, pdf_gallery, current_manuscript
-
-    sorted_files = sorted(files, key=lambda x: Path(x.name).suffix)
-    
-    for file_obj in sorted_files:
-        file_path = Path(file_obj.name)
-        ext = file_path.suffix.lower()
+        # Load the color emoji font
+        page.insert_font(fontname="emoji", fontfile=EMOJI_FONT_PATH)
+        
+        # Insert the emoji character. The vertical alignment may need tweaking.
+        page.insert_text(fitz.Point(0, size_pt * 1.1), emoji_char, fontname="emoji", fontsize=size_pt)
         
-        if ext in ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff']:
-            image_gallery.append((file_path, file_path.name))
-        elif ext == '.pdf':
-            pdf_gallery.append((create_file_icon_image(file_path), file_path.name))
-        else: # Treat everything else as a text file
-            has_text_files = True
-            text_gallery.append((create_file_icon_image(file_path), file_path.name))
-            try:
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    text_content_to_add.append(f.read())
-            except Exception as e:
-                print(f"Could not read {file_path.name}: {e}")
+        # Get a high-resolution PNG of the emoji with a transparent background
+        pix = page.get_pixmap(alpha=True, dpi=300)
+        doc.close()
 
-    # If any text-based files were uploaded, their content replaces the manuscript.
-    # Otherwise, the manuscript is left untouched.
-    if has_text_files:
-        updated_manuscript = "\n\n---\n\n".join(text_content_to_add)
-    else:
-        updated_manuscript = current_manuscript
+        # Save the PNG to an in-memory buffer
+        img_buffer = io.BytesIO(pix.tobytes("png"))
+        img_buffer.seek(0)
 
-    return text_gallery, image_gallery, pdf_gallery, updated_manuscript
+        # Add the buffer to the cache and return it
+        EMOJI_IMAGE_CACHE[(emoji_char, size_pt)] = img_buffer
+        return img_buffer
+    except Exception as e:
+        print(f"ERROR: Could not render emoji '{emoji_char}': {e}")
+        return None
 
-# --- Main PDF Generation Logic (heavily adapted from before) ---
-def _draw_header_footer(canvas, doc, header_text, footer_text, title):
-    """Draws the header and footer on each page."""
-    canvas.saveState()
-    page_num = canvas.getPageNumber()
+# --- PDF Generation ---
+def create_pdf_from_markdown(md_filepath: Path):
+    """
+    The main function to convert a single Markdown file into a PDF.
+    It reads the text, processes it line by line, and replaces emojis with images.
+    """
+    print(f"--- Starting PDF conversion for: {md_filepath.name} ---")
     
-    final_footer_text = footer_text.replace("[Page #]", str(page_num)).replace("[Total Pages]", str(doc.page))
-    final_header_text = header_text.replace("[Page #]", str(page_num)).replace("[Title]", title)
-
-    if final_header_text:
-        canvas.setFont('Helvetica', 9)
-        canvas.setFillColor(colors.grey)
-        canvas.drawRightString(doc.width + doc.leftMargin, doc.height + doc.topMargin + 0.25*inch, final_header_text)
-
-    if final_footer_text:
-        canvas.setFont('Helvetica', 9)
-        canvas.setFillColor(colors.grey)
-        canvas.drawString(doc.leftMargin, doc.bottomMargin - 0.25*inch, final_footer_text)
-
-    canvas.restoreState()
-
-def markdown_to_story(markdown_text, font_name, font_sizes, use_svg_engine):
+    # Define styles for the PDF document
     styles = getSampleStyleSheet()
-    font_size_body, font_size_h1, font_size_h2, font_size_h3 = font_sizes
-    style_normal = ParagraphStyle('BodyText', fontName=font_name, fontSize=font_size_body, leading=font_size_body*1.4, spaceAfter=6)
-    style_h1 = ParagraphStyle('h1', parent=styles['h1'], fontName=font_name, fontSize=font_size_h1, leading=font_size_h1*1.2, spaceBefore=12, textColor=colors.HexColor("#a855f7"))
-    style_h2 = ParagraphStyle('h2', parent=styles['h2'], fontName=font_name, fontSize=font_size_h2, leading=font_size_h2*1.2, spaceBefore=10, textColor=colors.HexColor("#6366f1"))
-    style_h3 = ParagraphStyle('h3', parent=styles['h3'], fontName=font_name, fontSize=font_size_h3, leading=font_size_h3*1.2, spaceBefore=8, textColor=colors.HexColor("#3b82f6"))
-    style_code = ParagraphStyle('Code', fontName='Courier', backColor=colors.HexColor("#333333"), textColor=colors.HexColor("#f472b6"), borderWidth=1, borderColor=colors.HexColor("#444444"), padding=8, leading=12, fontSize=9)
-    style_table_header = ParagraphStyle('TableHeader', parent=style_normal, fontName=font_name) # Bold is handled in text
-
+    # Use a font that supports a wide range of characters, if available
+    body_font = 'DejaVuSans' if 'DejaVuSans' in pdfmetrics.getRegisteredFontNames() else 'Helvetica'
+    style_body = ParagraphStyle('Body', fontName=body_font, fontSize=11, leading=14)
+    style_h1 = ParagraphStyle('H1', fontName=body_font, fontSize=24, leading=28, spaceAfter=12, textColor=colors.darkblue)
+    style_h2 = ParagraphStyle('H2', fontName=body_font, fontSize=18, leading=22, spaceAfter=10)
+    
+    # Regex to find all emojis in a string
     emoji_pattern = re.compile(f"([{re.escape(''.join(map(chr, range(0x1f600, 0x1f650))))}"
                                f"{re.escape(''.join(map(chr, range(0x1f300, 0x1f5ff))))}"
                                f"{re.escape(''.join(map(chr, range(0x1f900, 0x1f9ff))))}"
-                               f"{re.escape(''.join(map(chr, range(0x2600, 0x26ff))))}"
-                               f"{re.escape(''.join(map(chr, range(0x2700, 0x27bf))))}]+)")
-
-    def create_flowables_for_line(text, style):
-        parts, flowables = emoji_pattern.split(text), []
+                               f"{re.escape(''.join(map(chr, range(0x2600, 0x26ff))))}]+)")
+
+    def text_to_flowables(text, style):
+        """
+        Splits a line of text into a list of Paragraphs and Images.
+        This allows text and emoji-images to flow together on the same line.
+        """
+        parts = emoji_pattern.split(text)
+        flowables = []
         for part in parts:
             if not part: continue
+            
             if emoji_pattern.match(part):
+                # This part is an emoji or a sequence of them
                 for emoji_char in part:
-                    emoji_flowable = render_emoji_as_svg(emoji_char, style.fontSize) if use_svg_engine else (lambda b: ReportLabImage(b, height=style.fontSize*1.2, width=style.fontSize*1.2) if b else None)(render_emoji_as_image(emoji_char, style.fontSize))
-                    if emoji_flowable: flowables.append(emoji_flowable)
+                    img_buffer = render_emoji_as_image(emoji_char, style.fontSize)
+                    if img_buffer:
+                        # Create an Image object, slightly larger than the text for better spacing
+                        img = ReportLabImage(img_buffer, height=style.fontSize * 1.2, width=style.fontSize * 1.2)
+                        flowables.append(img)
             else:
-                formatted_part = re.sub(r'_(.*?)_', r'<i>\1</i>', re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', part))
-                flowables.append(Paragraph(formatted_part, style))
-        if not flowables: return [Spacer(0, 0)]
-        table = Table([flowables], colWidths=[None]*len(flowables))
-        table.setStyle(TableStyle([('VALIGN', (0,0), (-1,-1), 'MIDDLE'), ('LEFTPADDING', (0,0), (-1,-1), 0), ('RIGHTPADDING', (0,0), (-1,-1), 0)]))
-        return [table]
-
-    story, lines = [], markdown_text.split('\n')
-    in_code_block, in_table, first_heading, document_title = False, False, True, "Untitled Document"
-    code_block_text, table_data = "", []
+                # This part is plain text
+                flowables.append(Paragraph(part.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;'), style))
+        
+        # Use a Table to keep all parts on the same line. This is a common ReportLab technique.
+        if flowables:
+            return Table([flowables], colWidths=[None] * len(flowables), style=[('VALIGN', (0,0), (-1,-1), 'MIDDLE')])
+        return None
 
+    # Read the markdown file
+    try:
+        with open(md_filepath, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+    except Exception as e:
+        print(f"ERROR: Could not read file {md_filepath.name}: {e}")
+        return None
+        
+    # The "story" is ReportLab's list of things to draw in the PDF
+    story = []
     for line in lines:
         stripped_line = line.strip()
-        if stripped_line.startswith("```"):
-            if in_code_block:
-                escaped_code = code_block_text.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
-                story.extend([Paragraph(escaped_code.replace('\n', '<br/>'), style_code), Spacer(1, 0.1*inch)])
-                in_code_block, code_block_text = False, ""
-            else: in_code_block = True
-            continue
-        if in_code_block: code_block_text += line + '\n'; continue
-        if stripped_line.startswith('|'):
-            if not in_table: in_table = True
-            if all(c in '-|: ' for c in stripped_line): continue
-            table_data.append([cell.strip() for cell in stripped_line.strip('|').split('|')])
-            continue
-        if in_table:
-            in_table = False
-            if table_data:
-                processed_table_data = [[create_flowables_for_line(cell, style_normal)[0] for cell in row] for row in table_data[1:]]
-                header_row = [create_flowables_for_line(f"<b>{cell}</b>", style_table_header)[0] for cell in table_data[0]]
-                table = Table([header_row] + processed_table_data, hAlign='LEFT', repeatRows=1)
-                table.setStyle(TableStyle([('BACKGROUND', (0,0), (-1,0), colors.HexColor("#4a044e")), ('GRID', (0,0), (-1,-1), 1, colors.HexColor("#6b21a8")), ('VALIGN', (0,0), (-1,-1), 'MIDDLE'), ('TOPPADDING', (0,0), (-1,-1), 6), ('BOTTOMPADDING', (0,0), (-1,-1), 6)]))
-                story.extend([table, Spacer(1, 0.2*inch)])
-            table_data = []
-            continue
-
-        if not stripped_line: continue
-        content, style, bullet_text = stripped_line, style_normal, None
-        if stripped_line.startswith("# "):
-            if not first_heading: story.append(PageBreak())
-            content, style, first_heading = stripped_line.lstrip('# '), style_h1, False
-            if document_title == "Untitled Document": document_title = content
-        elif stripped_line.startswith("## "): content, style = stripped_line.lstrip('## '), style_h2
-        elif stripped_line.startswith("### "): content, style = stripped_line.lstrip('### '), style_h3
-        elif stripped_line.startswith(("- ", "* ")): content, bullet_text = stripped_line[2:], '• '
         
-        line_flowables = create_flowables_for_line(content, style)
-        if bullet_text:
-            list_item_table = Table([[Paragraph(bullet_text, style)] + line_flowables], colWidths=[style.fontSize*1.5] + [None]*len(line_flowables))
-            list_item_table.setStyle(TableStyle([('VALIGN', (0,0), (-1,-1), 'TOP'), ('LEFTPADDING', (0,0), (-1,-1), 0), ('RIGHTPADDING', (0,0), (-1,-1), 0)]))
-            story.append(list_item_table)
-        else: story.extend(line_flowables)
-    return story, document_title
-
-def generate_pdfs_api(files, ai_content, layouts, fonts, num_columns, header_text, footer_text, font_sizes, margins, use_svg_engine, progress=gr.Progress(track_tqdm=True)):
-    if not files and (not ai_content or "Golem awaits" in ai_content): raise gr.Error("Please conjure some content or upload a file before alchemizing!")
-    if not layouts: raise gr.Error("You must select a scroll (page layout)!")
-    if not fonts: raise gr.Error("A scribe needs a font! Please choose one.")
-    if not EMOJI_FONT_PATH: raise gr.Error("CRITICAL: Cannot generate PDFs. 'NotoColorEmoji-Regular.ttf' not found.")
+        # Simple Markdown parsing
+        if stripped_line.startswith('# '):
+            flowable = text_to_flowables(stripped_line[2:], style_h1)
+        elif stripped_line.startswith('## '):
+            flowable = text_to_flowables(stripped_line[2:], style_h2)
+        elif stripped_line:
+            flowable = text_to_flowables(stripped_line, style_body)
+        else:
+            flowable = Spacer(1, 0.2 * inch)
+            
+        if flowable:
+            story.append(flowable)
 
-    shutil.rmtree(OUTPUT_DIR, ignore_errors=True); OUTPUT_DIR.mkdir()
-    shutil.rmtree(PREVIEW_DIR, ignore_errors=True); PREVIEW_DIR.mkdir()
-    
-    image_files, pdf_files, txt_files = [], [], []
-    if files:
-        for f in files:
-            p = Path(f.name); ext = p.suffix.lower()
-            if ext in ['.png','.jpg','.jpeg','.gif','.bmp','.tiff']: image_files.append(p)
-            elif ext == '.pdf': pdf_files.append(p)
-            else: txt_files.append(p)
+    # Generate a unique filename and path for the output PDF
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H%M")
+    output_filename = f"{md_filepath.stem}_{timestamp}.pdf"
+    output_filepath = OUTPUT_DIR / output_filename
 
-    log, all_text = "", []
-    if ai_content and "Golem awaits" not in ai_content: all_text.append(ai_content)
-    # The uploaded text content is now part of ai_content, so we don't need to re-read it here.
-    # This was part of the original bug.
-    md_content = ai_content
+    # Build the PDF document
+    doc = SimpleDocTemplate(str(output_filepath), pagesize=letter)
+    try:
+        doc.build(story)
+        print(f"SUCCESS: Successfully created PDF: {output_filename}")
+        return output_filepath
+    except Exception as e:
+        print(f"ERROR: Failed to build PDF for {md_filepath.name}. Reason: {e}")
+        return None
+
+# --- Gradio UI and Logic ---
+def process_uploads(files):
+    """
+    Takes uploaded files, processes each one into a PDF, and returns a list of generated filepaths.
+    """
+    if not files:
+        raise gr.Error("Please upload at least one Markdown (.md) file.")
     
-    generated_pdfs = []
-    EMOJI_IMAGE_CACHE.clear(); EMOJI_SVG_CACHE.clear()
-
-    for layout in progress.tqdm(layouts, desc="brewing potions..."):
-        for font in progress.tqdm(fonts, desc=f"enchanting scrolls with {layout}..."):
-            merger = PdfWriter()
-            if md_content:
-                buffer, (story, title) = io.BytesIO(), markdown_to_story(md_content, font, font_sizes, use_svg_engine)
-                doc = BaseDocTemplate(buffer, pagesize=LAYOUTS[layout]["size"], leftMargin=margins[2]*inch, rightMargin=margins[3]*inch, topMargin=margins[0]*inch, bottomMargin=margins[1]*inch)
-                frame_w = (doc.width / num_columns) - (num_columns - 1)*0.1*inch
-                frames = [Frame(doc.leftMargin + i*(frame_w+0.2*inch), doc.bottomMargin, frame_w, doc.height, id=f'col_{i}') for i in range(num_columns)]
-                doc.addPageTemplates([PageTemplate(id='main', frames=frames, onPage=partial(_draw_header_footer, header_text=header_text, footer_text=footer_text, title=title))])
-                doc.build(story); buffer.seek(0); merger.append(fileobj=buffer)
-            
-            for p in image_files:
-                try:
-                    with Image.open(p) as img: w, h = img.size
-                    w_pt, h_pt = w * (inch/72), h * (inch/72)
-                    buffer = io.BytesIO()
-                    SimpleDocTemplate(buffer, pagesize=(w_pt, h_pt), leftMargin=0,rightMargin=0,topMargin=0,bottomMargin=0).build([ReportLabImage(p, width=w_pt, height=h_pt)])
-                    buffer.seek(0); merger.append(fileobj=buffer)
-                except Exception as e: log += f"⚠️ Failed to process image {p.name}: {e}\n"
-            for p in pdf_files:
-                try: merger.append(str(p))
-                except Exception as e: log += f"⚠️ Failed to merge PDF {p.name}: {e}\n"
-            
-            if len(merger.pages) > 0:
-                filename = f"Scroll_{layout.replace(' ','')}_{font}_x{num_columns}_{datetime.datetime.now().strftime('%H%M%S')}.pdf"
-                out_path = OUTPUT_DIR / filename
-                with open(out_path, "wb") as f: merger.write(f)
-                generated_pdfs.append(out_path); log += f"✅ Alchemized: {filename}\n"
+    # Clear caches and temp directories for a clean run
+    EMOJI_IMAGE_CACHE.clear()
+    shutil.rmtree(TEMP_DIR, ignore_errors=True); TEMP_DIR.mkdir(exist_ok=True)
     
-    previews = [p for p in [create_pdf_preview(pdf) for pdf in generated_pdfs] if p]
-    return previews, log if log else "✨ All scrolls alchemized successfully! ✨", [str(p) for p in generated_pdfs]
-
-# --- Gradio UI Definition ---
-AVAILABLE_FONTS = register_local_fonts()
-
-def get_theme():
-    """Dynamically selects a font for the theme to avoid warnings for missing fonts."""
-    desired = "MedievalSharp"
-    fallback = ("ui-sans-serif", "system-ui", "sans-serif")
-    font_family = fallback
-
-    # Check if the desired font is in the list of registered fonts
-    if any(desired in s for s in AVAILABLE_FONTS):
-        font_family = (gr.themes.GoogleFont(desired),) + fallback
-    elif AVAILABLE_FONTS:
-        # If desired font is not found, use the first available font as a better fallback
-        first_font = AVAILABLE_FONTS[0]
-        print(f"WARNING: '{desired}' font not found. Using '{first_font}' for UI theme instead.")
-        font_family = (gr.themes.GoogleFont(first_font),) + fallback
-    else:
-        # Absolute fallback if no custom fonts are found
-        print(f"WARNING: No custom fonts found. Using system default for UI.")
-
-    return gr.themes.Base(
-        primary_hue=gr.themes.colors.purple,
-        secondary_hue=gr.themes.colors.indigo,
-        neutral_hue=gr.themes.colors.gray,
-        font=font_family
-    ).set(
-        body_background_fill="#111827",
-        body_text_color="#d1d5db",
-        button_primary_background_fill="#a855f7",
-        button_primary_text_color="#ffffff",
-        button_secondary_background_fill="#6366f1",
-        button_secondary_text_color="#ffffff",
-        block_background_fill="#1f2937",
-        block_label_background_fill="#1f2937",
-        block_title_text_color="#a855f7",
-        input_background_fill="#374151"
-    )
-
-with gr.Blocks(theme=get_theme(), title="The PDF Alchemist") as demo:
-    gr.Markdown("# ✨ The PDF Alchemist ✨")
-    gr.Markdown("A single-page grimoire to turn your ideas into beautifully crafted PDF scrolls. Use the power of AI or upload your own treasures.")
-
-    with gr.Row(equal_height=False):
-        # --- LEFT COLUMN: INPUTS & CONTROLS ---
-        with gr.Column(scale=2):
-            with gr.Group():
-                with gr.Accordion("📜 Content Crucible (Your Ingredients)", open=True):
-                    gr.Markdown("### 🤖 Command Your Idea Golem")
-                    ai_prompt = gr.Textbox(label="Incantation (Prompt)", placeholder="e.g., 'A recipe for a dragon's breath chili...'")
-                    generate_ai_btn = gr.Button("🧠 Animate Golem!")
-                    ai_content_output = gr.Textbox(label="Golem's Manuscript (Editable)", lines=10, interactive=True, value="# The Golem awaits your command!\n\n")
-                    gr.Markdown("<hr style='border-color: #374151; margin-top: 20px; margin-bottom: 20px;'>")
-                    gr.Markdown("### 📤 Add Your Physical Treasures")
-                    uploaded_files = gr.File(label="Upload Files (TXT, MD, Code, Images, PDFs)", file_count="multiple", file_types=['text', '.md', 'image', '.pdf', '.py', '.js', '.html', '.css', '.json'])
-
-            with gr.Accordion("📐 Arcane Blueprints (Layout & Structure)", open=True):
-                selected_layouts = gr.CheckboxGroup(choices=list(LAYOUTS.keys()), label="Page Layouts", value=["A4 Portrait"])
-                num_columns_slider = gr.Slider(label="Number of Text Columns", minimum=1, maximum=4, step=1, value=1)
-                header_input = gr.Textbox(label="Header Inscription", value="[Title]", placeholder="e.g., Arcane Folio - [Page #]")
-                footer_input = gr.Textbox(label="Footer Inscription", value="Page [Page #] of [Total Pages]", placeholder="e.g., Top Secret - Page [Page #]")
+    log_messages = []
+    generated_pdf_paths = []
 
-            with gr.Accordion("💅 Stylist's Sanctum (Fonts & Margins)", open=True):
-                use_svg_engine_toggle = gr.Checkbox(label="Use SVG Emoji Engine (Vector Quality)", value=True, info="Toggle for higher quality, resolution-independent emojis. May be slower.")
-                selected_fonts = gr.CheckboxGroup(choices=AVAILABLE_FONTS, label="Fonts", value=[AVAILABLE_FONTS[0]] if AVAILABLE_FONTS else [])
-                with gr.Row():
-                    font_size_body_slider = gr.Slider(label="Body (pt)", minimum=8, maximum=16, step=1, value=10)
-                    font_size_h1_slider = gr.Slider(label="H1 (pt)", minimum=16, maximum=32, step=1, value=24)
-                with gr.Row():
-                    font_size_h2_slider = gr.Slider(label="H2 (pt)", minimum=14, maximum=28, step=1, value=18)
-                    font_size_h3_slider = gr.Slider(label="H3 (pt)", minimum=12, maximum=24, step=1, value=14)
-                with gr.Row():
-                    margin_top_slider = gr.Slider(label="Margin Top (in)", minimum=0.25, maximum=1.5, step=0.05, value=0.75)
-                    margin_bottom_slider = gr.Slider(label="Margin Bottom (in)", minimum=0.25, maximum=1.5, step=0.05, value=0.75)
-                with gr.Row():
-                    margin_left_slider = gr.Slider(label="Margin Left (in)", minimum=0.25, maximum=1.5, step=0.05, value=0.75)
-                    margin_right_slider = gr.Slider(label="Margin Right (in)", minimum=0.25, maximum=1.5, step=0.05, value=0.75)
-
-            generate_pdfs_btn = gr.Button("🔮 Alchemize PDF!", variant="primary", size="lg")
-
-        # --- RIGHT COLUMN: STAGING & OUTPUTS ---
-        with gr.Column(scale=3):
-            with gr.Group():
-                with gr.Accordion("🔍 Staging Area (Your Uploaded Treasures)", open=True):
-                    text_gallery = gr.Gallery(label="📜 Manuscripts & Code", show_label=True, columns=4, height=120, object_fit="contain")
-                    image_gallery = gr.Gallery(label="🖼️ Images & Glyphs", show_label=True, columns=4, height=120, object_fit="contain")
-                    pdf_gallery = gr.Gallery(label="📚 Imported Scrolls", show_label=True, columns=4, height=120, object_fit="contain")
-
-            with gr.Group():
-                gr.Markdown("### ⚗️ Transmuted Scrolls (Final PDFs)")
-                final_gallery_output = gr.Gallery(label="PDF Previews", show_label=False, elem_id="gallery", columns=2, height=400, object_fit="contain")
-                log_output = gr.Markdown(label="Alchemist's Log", value="Your log of successful transmutations will appear here...")
-                downloadable_files_output = gr.Files(label="Collect Your Scrolls")
+    for file_obj in files:
+        input_path = Path(file_obj.name)
+        log_messages.append(f"Processing '{input_path.name}'...")
+        
+        # Core PDF creation step
+        output_path = create_pdf_from_markdown(input_path)
+        
+        if output_path:
+            generated_pdf_paths.append(str(output_path))
+            log_messages.append(f"✅ Success! PDF saved to '{output_path.name}'.")
+        else:
+            log_messages.append(f"❌ Failed to process '{input_path.name}'. Check console for errors.")
             
-    # --- API Calls & Examples ---
-    font_size_inputs = [font_size_body_slider, font_size_h1_slider, font_size_h2_slider, font_size_h3_slider]
-    margin_inputs = [margin_top_slider, margin_bottom_slider, margin_left_slider, margin_right_slider]
-    
-    uploaded_files.upload(update_staging_and_manuscript, inputs=[uploaded_files, ai_content_output], outputs=[text_gallery, image_gallery, pdf_gallery, ai_content_output])
-    generate_ai_btn.click(generate_ai_content_api, inputs=[ai_prompt], outputs=[ai_content_output])
+    # After processing, get the full list of all PDFs in the output directory for the gallery
+    all_pdfs_in_gallery = sorted([str(p) for p in OUTPUT_DIR.glob("*.pdf")], reverse=True)
     
-    generate_pdfs_btn.click(generate_pdfs_api, 
-        inputs=[uploaded_files, ai_content_output, selected_layouts, selected_fonts, num_columns_slider, header_input, footer_input] + font_size_inputs + margin_inputs + [use_svg_engine_toggle], 
-        outputs=[final_gallery_output, log_output, downloadable_files_output])
+    return "\n".join(log_messages), all_pdfs_in_gallery
 
-    gr.Examples(examples=[["A technical summary of how alchemy works"],["A short poem about a grumpy gnome"]], inputs=[ai_prompt], outputs=[ai_content_output], fn=generate_ai_content_api, cache_examples=False)
+def refresh_gallery():
+    """Scans the output directory and returns a list of all PDFs found."""
+    return sorted([str(p) for p in OUTPUT_DIR.glob("*.pdf")], reverse=True)
 
+# Main execution block
 if __name__ == "__main__":
-    if not EMOJI_FONT_PATH:
-        print("\n" + "="*80 + "\nCRITICAL WARNING: 'NotoColorEmoji-Regular.ttf' not found.\nThe application will fail to generate PDFs with color emojis.\n" + "="*80 + "\n")
-    demo.launch(debug=True)
+    # This must run once at startup to check for the required font
+    try:
+        setup_fonts()
+    except FileNotFoundError as e:
+        # If the font is missing, we stop the app from launching.
+        print("\n" + "="*60)
+        print(e)
+        print("The application cannot start without this font file.")
+        print("Please add 'NotoColorEmoji-Regular.ttf' and 'DejaVuSans.ttf' to your project directory.")
+        print("="*60)
+        exit() # Stop the script
+
+    # Define the Gradio Interface
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Markdown-to-PDF Alchemist") as demo:
+        gr.Markdown("# 📜 Markdown-to-PDF Alchemist")
+        gr.Markdown("Upload one or more `.md` files. This tool will convert them into PDFs, preserving emojis by rendering them as high-quality images. All generated PDFs will appear in the library below.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                upload_button = gr.File(
+                    label="Upload Markdown Files (.md)",
+                    file_count="multiple",
+                    file_types=[".md"],
+                )
+                generate_button = gr.Button("🔮 Alchemize to PDF", variant="primary")
+                log_output = gr.Textbox(label="Alchemist's Log", lines=8, interactive=False)
+
+            with gr.Column(scale=2):
+                gr.Markdown("### 📚 Generated PDF Library")
+                # The gallery will show the first page of the PDF as a preview
+                pdf_gallery = gr.Gallery(
+                    label="Generated PDFs",
+                    show_label=False,
+                    elem_id="gallery",
+                    columns=3,
+                    object_fit="contain",
+                    height="auto"
+                )
+                # This button allows manual refreshing of the gallery
+                refresh_button = gr.Button("🔄 Refresh Library")
+
+        # Define the actions when buttons are clicked
+        generate_button.click(
+            fn=process_uploads,
+            inputs=[upload_button],
+            outputs=[log_output, pdf_gallery]
+        )
+        
+        refresh_button.click(
+            fn=refresh_gallery,
+            inputs=None,
+            outputs=[pdf_gallery]
+        )
+        
+        # Load the gallery with existing PDFs when the app starts
+        demo.load(refresh_gallery, None, pdf_gallery)
+
+    # Launch the application
+    demo.launch(debug=True)