Update app.py

app.py

@@ -5,7 +5,7 @@ import re
 import os
 import shutil
 import fitz  # PyMuPDF
-from PIL import Image
+from PIL import Image, ImageDraw, ImageFont
 from collections import defaultdict
 import io
 from pypdf import PdfWriter
@@ -26,6 +26,7 @@ from functools import partial
 
 # --- Configuration & Setup ---
 CWD = Path.cwd()
+TEMP_DIR = CWD / "temp_icons"
 LAYOUTS = {
     "A4 Portrait": {"size": A4},
     "A4 Landscape": {"size": landscape(A4)},
@@ -41,192 +42,148 @@ 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)
 
 
 # --- Font & Emoji Handling ---
-
-# Global cache for rendered emoji images to avoid re-rendering the same emoji
-EMOJI_IMAGE_CACHE = {}
-EMOJI_SVG_CACHE = {} # New cache for the SVG engine
-EMOJI_FONT_PATH = None # Will be set in register_local_fonts
+EMOJI_IMAGE_CACHE, EMOJI_SVG_CACHE = {}, {}
+EMOJI_FONT_PATH, UI_FONT_PATH = None, None
 
 def register_local_fonts():
     """Finds and registers all .ttf files from the application's base directory."""
-    global EMOJI_FONT_PATH
+    global EMOJI_FONT_PATH, UI_FONT_PATH
     print("--- Font Registration Process Starting ---")
     text_font_names = []
-    emoji_font_name = None
     
     noto_emoji_path = FONT_DIR / "NotoColorEmoji-Regular.ttf"
-    if not noto_emoji_path.exists():
-        print(f"CRITICAL: Color Emoji font not found at {noto_emoji_path}.")
-        print("Please download 'NotoColorEmoji-Regular.ttf' and place it in the application directory for color emojis to work.")
-    else:
+    if noto_emoji_path.exists():
         EMOJI_FONT_PATH = str(noto_emoji_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"))
-    print(f"Found {len(font_files)} .ttf files: {[f.name for f in font_files]}")
-
+    
     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.registerFont(TTFont(f"{font_name}-Bold", str(font_path)))
-            pdfmetrics.registerFont(TTFont(f"{font_name}-Italic", str(font_path)))
-            pdfmetrics.registerFont(TTFont(f"{font_name}-BoldItalic", str(font_path)))
-            pdfmetrics.registerFontFamily(font_name, normal=font_name, bold=f"{font_name}-Bold", italic=f"{font_name}-Italic", boldItalic=f"{font_name}-BoldItalic")
-
-            if "notocoloremoji-regular" in font_name.lower():
-                emoji_font_name = font_name
-            elif "notoemoji" not in font_name.lower():
+            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:
-        print("WARNING: No text fonts found. Adding 'Helvetica' as a default.")
         text_font_names.append('Helvetica')
-
     print(f"Successfully registered user-selectable fonts: {text_font_names}")
-    print(f"Emoji font set to: {emoji_font_name}")
-    print("--- Font Registration Process Finished ---")
-    return sorted(text_font_names), emoji_font_name
+    return sorted(text_font_names)
 
 def render_emoji_as_image(emoji_char, size_pt):
-    """
-    Renders a single emoji character as a transparent PNG image in memory using PyMuPDF.
-    This is the original raster image engine.
-    """
     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 = fitz.Rect(0, 0, size_pt * 1.5, size_pt * 1.5)
-        doc = fitz.open()
+        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 = page.get_pixmap(alpha=True, dpi=300)
-        doc.close()
-        img_buffer = io.BytesIO(pix.tobytes("png"))
-        img_buffer.seek(0)
+        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
+    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):
-    """
-    Renders a single emoji character as an SVG drawing object.
-    This is the new vector graphics engine.
-    """
     if not EMOJI_FONT_PATH: return None
     if (emoji_char, size_pt) in EMOJI_SVG_CACHE: return EMOJI_SVG_CACHE[(emoji_char, size_pt)]
-
     try:
-        doc = fitz.open()
-        page = doc.new_page(width=1000, height=1000) # Large canvas
+        doc = fitz.open(); page = doc.new_page(width=1000, height=1000)
         page.insert_font(fontname="emoji", fontfile=EMOJI_FONT_PATH)
-        
-        # Get the SVG image for the character
         svg_image = page.get_svg_image(page.rect, text=emoji_char, fontname="emoji")
         doc.close()
-
-        # Convert the SVG XML string to a ReportLab Graphic
         drawing = svg2rlg(io.BytesIO(svg_image.encode('utf-8')))
-        
-        # Scale the drawing to match the font size
         scale_factor = (size_pt * 1.2) / drawing.height
-        drawing.width *= scale_factor
-        drawing.height *= scale_factor
+        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
-
-
-# --- AI Content Generation (Simulation) ---
-
-def generate_ai_content_api(prompt):
-    """
-    Simulates a call to an LLM to generate markdown content.
-    """
-    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.
-
-### The Journey Begins
-Elara's journey was fraught with peril. She navigated enchanted forests and crossed treacherous chasms.
-
-| Trial            | Location          | Challenge                              |
-|------------------|-------------------|----------------------------------------|
-| The Whispering   | The Gloomwood     | Resist maddening whispers of despair   |
-| The Riddle of    | Sphinx Gate       | Answer three impossible questions      |
-| The Fiery Path   | The Magma Caverns | Walk barefoot across burning embers    |
-
-Finally, she reached the heart of the mountain. There, resting on a pedestal, was the dim Sunstone. Pouring her own hope and courage into it, the stone blazed with renewed life, banishing the shadows from Aerthos forever. The people rejoiced, and Elara became a legend.
-"""
-    return f"# Golem's Vision for: '{prompt}'\n\n{sample_story}"
-
-
-# --- PDF Generation & Handling ---
-
-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()
+    except Exception as e: print(f"Could not render emoji {emoji_char} as SVG: {e}"); return None
+
+# --- UI & File Handling ---
+FILE_ICONS = defaultdict(lambda: '❓', {
+    '.md': '📜', '.txt': '📄', '.py': '🐍', '.js': '⚡', '.html': '🌐', '.css': '🎨', '.json': '🔮',
+    '.png': '🖼️', '.jpg': '🖼️', '.jpeg': '🖼️', '.gif': '🖼️', '.bmp': '🖼️', '.tiff': '🖼️',
+    '.pdf': '📚'
+})
+
+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()
+        
+    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")
     
-    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)
+    out_path = TEMP_DIR / f"{file_path.stem}_{file_path.suffix[1:]}.png"
+    img.save(out_path)
+    return out_path
 
-    canvas.restoreState()
-
-def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str, font_size_body: int, font_size_h1: int, font_size_h2: int, font_size_h3: int, use_svg_engine: bool):
-    """Converts markdown to a ReportLab story, with a switch for emoji rendering engines."""
-    styles = getSampleStyleSheet()
+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 = []
     
-    leading_body = font_size_body * 1.4
-    style_normal = ParagraphStyle('BodyText', fontName=font_name, fontSize=font_size_body, leading=leading_body, spaceAfter=6)
+    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()
+        
+        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
+            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}")
+
+    # Update manuscript
+    updated_manuscript = current_manuscript
+    if "Golem awaits" in updated_manuscript:
+        updated_manuscript = "" # Clear placeholder if it exists
+
+    if text_content_to_add:
+        separator = "\n\n---\n\n"
+        if not updated_manuscript.strip(): separator = "" # Don't add separator if manuscript is empty
+        updated_manuscript += separator + "\n\n".join(text_content_to_add)
+
+    return text_gallery, image_gallery, pdf_gallery, updated_manuscript
+
+# --- Main PDF Generation Logic (heavily adapted from before) ---
+def markdown_to_story(markdown_text, font_name, font_sizes, use_svg_engine):
+    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=f"{font_name}-Bold" if font_name != 'Helvetica' else 'Helvetica-Bold')
+    style_table_header = ParagraphStyle('TableHeader', parent=style_normal, fontName=font_name) # Bold is handled in text
 
     emoji_pattern = re.compile(f"([{re.escape(''.join(map(chr, range(0x1f600, 0x1f650))))}"
                                f"{re.escape(''.join(map(chr, range(0x1f300, 0x1f5ff))))}"
@@ -235,303 +192,133 @@ def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str, font_
                                f"{re.escape(''.join(map(chr, range(0x2700, 0x27bf))))}]+)")
 
     def create_flowables_for_line(text, style):
-        """Splits a line of text into text and emoji flowables, returning a list."""
-        parts = emoji_pattern.split(text)
-        flowables = []
+        parts, flowables = emoji_pattern.split(text), []
         for part in parts:
             if not part: continue
             if emoji_pattern.match(part):
                 for emoji_char in part:
-                    emoji_flowable = None
-                    if use_svg_engine:
-                        emoji_flowable = render_emoji_as_svg(emoji_char, style.fontSize)
-                    else:
-                        img_buffer = render_emoji_as_image(emoji_char, style.fontSize)
-                        if img_buffer:
-                            emoji_flowable = ReportLabImage(img_buffer, height=style.fontSize * 1.2, width=style.fontSize * 1.2)
-                    
-                    if emoji_flowable:
-                        flowables.append(emoji_flowable)
+                    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)
             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 = False, False
+    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 = "", []
-    first_heading = True
-    document_title = "Untitled Document"
 
     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.append(Paragraph(escaped_code.replace('\n', '<br/>'), style_code))
-                story.append(Spacer(1, 0.1 * inch))
+                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 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
-            cells = [cell.strip() for cell in stripped_line.strip('|').split('|')]
-            table_data.append(cells)
+            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]
-                header_row = [create_flowables_for_line(cell, style_table_header)[0] for cell in table_data[0]]
-                final_table_data = [header_row] + processed_table_data[1:]
-
-                table = Table(final_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.append(table); story.append(Spacer(1, 0.2 * inch))
+                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 = stripped_line.lstrip('# '), style_h1
-            if first_heading: document_title = content
-            first_heading = False
+            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 = stripped_line[2:]
-            bullet_text = '• '
+        elif stripped_line.startswith(("- ", "* ")): content, bullet_text = stripped_line[2:], '• '
         
         line_flowables = create_flowables_for_line(content, style)
-
         if bullet_text:
-            bullet_p = Paragraph(bullet_text, style)
-            # Adjust colWidths to give bullet a fixed space
-            list_item_table = Table([[bullet_p] + line_flowables], colWidths=[style.fontSize*1.5] + [None]*len(line_flowables))
+            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)
-        
+        else: story.extend(line_flowables)
     return story, document_title
 
-def create_pdf_preview(pdf_path: Path):
-    """Generates a PNG preview of the first page of a PDF."""
-    preview_path = PREVIEW_DIR / f"{pdf_path.stem}.png"
-    try:
-        doc = fitz.open(pdf_path)
-        page = doc.load_page(0)
-        pix = page.get_pixmap(dpi=150)
-        pix.save(str(preview_path))
-        doc.close()
-        return str(preview_path)
-    except Exception as e:
-        print(f"Could not create preview for {pdf_path.name}: {e}")
-        try:
-            img = Image.new('RGB', (400, 500), color = '#111827')
-            img.save(str(preview_path))
-            return str(preview_path)
-        except: return None
-
-# --- Main API Function ---
-def generate_pdfs_api(files, ai_content, layouts, fonts, num_columns, header_text, footer_text, font_size_body, font_size_h1, font_size_h2, font_size_h3, margin_top, margin_bottom, margin_left, margin_right, use_svg_engine, progress=gr.Progress(track_tqdm=True)):
+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. Please add it to the app directory.")
-
-    shutil.rmtree(OUTPUT_DIR, ignore_errors=True); shutil.rmtree(PREVIEW_DIR, ignore_errors=True)
-    OUTPUT_DIR.mkdir(); PREVIEW_DIR.mkdir()
+    if not EMOJI_FONT_PATH: raise gr.Error("CRITICAL: Cannot generate PDFs. 'NotoColorEmoji-Regular.ttf' not found.")
 
+    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:
-            file_path = Path(f.name)
-            ext = file_path.suffix.lower()
-            if ext in ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff']: image_files.append(file_path)
-            elif ext == '.pdf': pdf_files.append(file_path)
-            elif ext == '.txt': txt_files.append(file_path)
-
-    log_updates = ""
-    all_text_content = []
-    if ai_content and "Golem awaits" not in ai_content: all_text_content.append(ai_content)
-
-    for txt_path in txt_files:
-        try:
-            all_text_content.append(txt_path.read_text(encoding='utf-8'))
-        except Exception as e:
-            log_updates += f"⚠️ Failed to read text file {txt_path.name}: {e}\n"
-    
-    md_content = "\n\n---\n\n".join(all_text_content)
-    
-    generated_pdf_paths = []
+            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)
+
+    log, all_text = "", []
+    if ai_content and "Golem awaits" not in ai_content: all_text.append(ai_content)
+    for p in txt_files:
+        try: all_text.append(p.read_text(encoding='utf-8'))
+        except Exception as e: log += f"⚠️ Failed to read {p.name}: {e}\n"
+    md_content = "\n\n---\n\n".join(all_text)
     
+    generated_pdfs = []
     EMOJI_IMAGE_CACHE.clear(); EMOJI_SVG_CACHE.clear()
 
-    for layout_name in progress.tqdm(layouts, desc=" brewing potions..."):
-        for font_name in progress.tqdm(fonts, desc=f" enchanting scrolls with {layout_name}..."):
+    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:
-                md_buffer = io.BytesIO()
-                story, title = markdown_to_story(md_content, font_name, EMOJI_FONT_NAME, font_size_body, font_size_h1, font_size_h2, font_size_h3, use_svg_engine)
-                pagesize = LAYOUTS[layout_name]["size"]
-                
-                doc = BaseDocTemplate(md_buffer, pagesize=pagesize, leftMargin=margin_left*inch, rightMargin=margin_right*inch, topMargin=margin_top*inch, bottomMargin=margin_bottom*inch)
-                
-                frame_width = (doc.width / num_columns) - (num_columns - 1) * 0.1*inch
-                frames = [Frame(doc.leftMargin + i * (frame_width + 0.2*inch), doc.bottomMargin, frame_width, doc.height, id=f'col_{i}') for i in range(num_columns)]
-                
-                header_footer_callback = partial(_draw_header_footer, header_text=header_text, footer_text=footer_text, title=title)
-                page_template = PageTemplate(id='main_template', frames=frames, onPage=header_footer_callback)
-                doc.addPageTemplates([page_template])
-
-                doc.build(story)
-                md_buffer.seek(0)
-                merger.append(fileobj=md_buffer)
-
-            for img_path in image_files:
-                try:
-                    with Image.open(img_path) as img: img_width_px, img_height_px = img.size
-                    img_width_pt, img_height_pt = img_width_px * (inch / 72), img_height_px * (inch / 72)
-                    img_buffer = io.BytesIO()
-                    img_doc = SimpleDocTemplate(img_buffer, pagesize=(img_width_pt, img_height_pt), leftMargin=0, rightMargin=0, topMargin=0, bottomMargin=0)
-                    img_doc.build([ReportLabImage(img_path, width=img_width_pt, height=img_height_pt)])
-                    img_buffer.seek(0)
-                    merger.append(fileobj=img_buffer)
-                except Exception as e: log_updates += f"⚠️ Failed to process image {img_path.name}: {e}\n"
-
-            for pdf_path in pdf_files:
+                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:
-                    merger.append(str(pdf_path))
-                except Exception as e: log_updates += f"⚠️ Failed to merge PDF {pdf_path.name}: {e}\n"
-
+                    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:
-                time_str = datetime.datetime.now().strftime('%H%M%S')
-                clean_layout = layout_name.replace(' ', '')
-                filename = f"Scroll_{clean_layout}_{font_name}_x{num_columns}_{time_str}.pdf"
-                output_path = OUTPUT_DIR / filename
-                with open(output_path, "wb") as f: merger.write(f)
-                generated_pdf_paths.append(output_path)
-                log_updates += f"✅ Successfully alchemized: {filename}\n"
-
-    gallery_previews = [create_pdf_preview(p) for p in generated_pdf_paths]
-    final_gallery = [g for g in gallery_previews if g is not None]
+                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"
     
-    return final_gallery, log_updates if log_updates else "✨ All scrolls alchemized successfully! ✨", [str(p) for p in generated_pdf_paths]
+    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, EMOJI_FONT_NAME = register_local_fonts()
+AVAILABLE_FONTS = register_local_fonts()
 
 def get_theme():
-    """Dynamically selects a font for the theme to avoid warnings for missing fonts."""
-    desired_font = "MedievalSharp"
-    font_family = None
-    if any(desired_font in s for s in AVAILABLE_FONTS):
-        font_family = (gr.themes.GoogleFont(desired_font), "ui-sans-serif", "system-ui", "sans-serif")
-    elif AVAILABLE_FONTS:
-        first_font = AVAILABLE_FONTS[0]
-        print(f"WARNING: '{desired_font}' font not found. Using '{first_font}' for UI theme instead.")
-        font_family = (gr.themes.GoogleFont(first_font), "ui-sans-serif", "system-ui", "sans-serif")
-    else:
-        print(f"WARNING: '{desired_font}' font not found and no other fonts available. Using system default.")
-        font_family = ("ui-sans-serif", "system-ui", "sans-serif")
-        
-    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):
-        with gr.Column(scale=2):
-            # --- Accordion Groups for Inputs ---
-            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 (Images, PDFs, TXT)", file_count="multiple", file_types=['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff', '.pdf', '.txt'])
-            
-            with gr.Accordion("📐 Arcane Blueprints (Layout & Structure)", open=True):
-                gr.Markdown("### Page & Column Spells")
-                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)
-                gr.Markdown("<hr style='border-color: #374151; margin-top: 20px; margin-bottom: 20px;'>")
-                gr.Markdown("### Header & Footer Runes")
-                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 #]")
-
-            with gr.Accordion("💅 Stylist's Sanctum (Fonts & Margins)", open=True):
-                gr.Markdown("### ⚙️ Alternative Emoji Engine")
-                use_svg_engine_toggle = gr.Checkbox(label="Use SVG Emoji Engine (Vector Quality)", value=True)
-                gr.Markdown("*<p style='font-size:0.8rem; color: #9ca3af;'>Toggle for higher quality, resolution-independent emojis. May be slower.</p>*")
-                gr.Markdown("<hr style='border-color: #374151; margin-top: 20px; margin-bottom: 20px;'>")
-                gr.Markdown("### 🔤 Master the Glyphs")
-                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)
-                gr.Markdown("<hr style='border-color: #374151; margin-top: 20px; margin-bottom: 20px;'>")
-                gr.Markdown("### 📏 Set Your Boundaries (inches)")
-                with gr.Row():
-                    margin_top_slider = gr.Slider(label="Top", minimum=0.25, maximum=1.5, step=0.05, value=0.75)
-                    margin_bottom_slider = gr.Slider(label="Bottom", minimum=0.25, maximum=1.5, step=0.05, value=0.75)
-                with gr.Row():
-                    margin_left_slider = gr.Slider(label="Left", minimum=0.25, maximum=1.5, step=0.05, value=0.75)
-                    margin_right_slider = gr.Slider(label="Right", minimum=0.25, maximum=1.5, step=0.05, value=0.75)
-
-            generate_pdfs_btn = gr.Button("🔮 Alchemize PDF!", variant="primary", size="lg")
-
-        with gr.Column(scale=3):
-            gr.Markdown("### 🖼️ The Scrying Pool (Previews)")
-            gallery_output = gr.Gallery(label="Generated PDF Previews", show_label=False, elem_id="gallery", columns=2, height=700, 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")
-            
-    # --- API Calls & Examples ---
-    generate_ai_btn.click(fn=generate_ai_content_api, inputs=[ai_prompt], outputs=[ai_content_output])
-    
-    inputs_list = [uploaded_files, ai_content_output, selected_layouts, selected_fonts, num_columns_slider, header_input, footer_input, font_size_body_slider, font_size_h1_slider, font_size_h2_slider, font_size_h3_slider, margin_top_slider, margin_bottom_slider, margin_left_slider, margin_right_slider, use_svg_engine_toggle]
-    outputs_list = [gallery_output, log_output, downloadable_files_output]
-    generate_pdfs_btn.click(fn=generate_pdfs_api, inputs=inputs_list, outputs=outputs_list)
-
-    gr.Examples(examples=[["A technical summary of how alchemy works"], ["A short poem about a grumpy gnome"],["A sample agenda for a wizard's council meeting"]], inputs=[ai_prompt], outputs=[ai_content_output], fn=generate_ai_content_api, cache_examples=False)
-
-if __name__ == "__main__":
-    if not (FONT_DIR / "NotoColorEmoji-Regular.ttf").exists():
-        print("\n" + "="*80)
-        print("CRITICAL WARNING: 'NotoColorEmoji-Regular.ttf' not found.")
-        print("The application will fail to generate PDFs without it.")
-        print("="*80 + "\n")
-    
-    demo.launch(debug=True)
+    desired, fallback = "MedievalSharp", ("ui-sans-serif", "system-ui", "sans-serif")
+    font_family = fallback
+    if any(desired in s for s in AVAILABLE_FONTS):
+        font_family = (gr.themes.GoogleFont(desired