app.py

import streamlit as st
from pathlib import Path
import base64
import datetime
import re
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.pagesizes import letter, A4, legal, landscape
from reportlab.lib.units import inch
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.lib import colors

# Define layouts using reportlab's pagesizes
LAYOUTS = {
    "A4 Portrait": {"size": A4, "icon": "📄"},
    "A4 Landscape": {"size": landscape(A4), "icon": "📄"},
    "Letter Portrait": {"size": letter, "icon": "📄"},
    "Letter Landscape": {"size": landscape(letter), "icon": "📄"},
    "Legal Portrait": {"size": legal, "icon": "📄"},
    "Legal Landscape": {"size": landscape(legal), "icon": "📄"},
}

# Directory to save the generated PDFs
OUTPUT_DIR = Path("generated_pdfs")
OUTPUT_DIR.mkdir(exist_ok=True)

# ⚠️ UPDATED: Path for the required NON-COLOR emoji font file.
EMOJI_FONT_PATH = Path("NotoEmoji-Regular.ttf")

# Regex to find and wrap emojis for ReportLab
EMOJI_PATTERN = re.compile(
    "["
    "\U0001F600-\U0001F64F"  # emoticons
    "\U0001F300-\U0001F5FF"  # symbols & pictographs
    "\U0001F680-\U0001F6FF"  # transport & map symbols
    "\U0001F700-\U0001F77F"  # alchemical symbols
    "\U0001F780-\U0001F7FF"  # Geometric Shapes Extended
    "\U0001F800-\U0001F8FF"  # Supplemental Arrows-C
    "\U0001F900-\U0001F9FF"  # Supplemental Symbols and Pictographs
    "\U0001FA00-\U0001FA6F"  # Chess Symbols
    "\U0001FA70-\U0001FAFF"  # Symbols and Pictographs Extended-A
    "\U00002702-\U000027B0"  # Dingbats
    "\U000024C2-\U0001F251"
    "]+",
    flags=re.UNICODE,
)

# --- Core PDF Generation Class ---

class PDFGenerator:
    """
    Handles font registration, markdown parsing, and PDF creation.
    """
    def __init__(self, font_path: Path):
        """
        ✨ To start the PDF show, a font we must know.
        Initializes the generator and registers the necessary emoji font.
        """
        self.emoji_font_name = "NotoEmoji"
        self._register_emoji_font(font_path)

    def _register_emoji_font(self, font_path: Path):
        """
        ✍️ Before new fonts can grace the page, first they must be set on stage.
        Registers the TTF font file with ReportLab if the file exists.
        """
        if font_path.exists():
            pdfmetrics.registerFont(TTFont(self.emoji_font_name, str(font_path)))
        else:
            st.error(f"Emoji font not found at '{font_path}'. Emojis will not be rendered. Please download it.")
            self.emoji_font_name = "Helvetica" # Fallback to a standard font

    def _wrap_emojis_for_reportlab(self, text: str) -> str:
        """
        😀 To make emojis appear so grand, wrap them with a font command.
        Finds all emojis and wraps them in ReportLab <font> tags.
        """
        if self.emoji_font_name != "NotoEmoji":
            return text
        return EMOJI_PATTERN.sub(lambda m: f'<font name="{self.emoji_font_name}">{m.group(0)}</font>', text)

    def _markdown_to_story(self, markdown_text: str) -> list:
        """
        📜 From markdown text, a simple scrawl, this story builder answers the call.
        Converts a markdown string 📝 into a list of ReportLab Flowables (a 'story').
        """
        styles = getSampleStyleSheet()
        style_normal = styles['BodyText']
        style_h1 = styles['h1']
        style_h2 = styles['h2']
        style_h3 = styles['h3']
        style_code = ParagraphStyle('Code', parent=styles['Normal'], fontName='Courier', textColor=colors.darkred)

        story = []
        lines = markdown_text.split('\n')
        in_code_block = False
        code_block_text = ""

        for line in lines:
            if line.strip().startswith("```"):
                if in_code_block:
                    story.append(Paragraph(code_block_text, style_code))
                    in_code_block = False
                    code_block_text = ""
                else:
                    in_code_block = True
                continue

            if in_code_block:
                escaped_line = line.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
                code_block_text += escaped_line + '<br/>'
                continue

            # Process the line for markdown syntax first
            if line.startswith("# "):
                final_text = self._wrap_emojis_for_reportlab(line[2:])
                story.append(Paragraph(final_text, style_h1))
            elif line.startswith("## "):
                final_text = self._wrap_emojis_for_reportlab(line[3:])
                story.append(Paragraph(final_text, style_h2))
            elif line.startswith("### "):
                final_text = self._wrap_emojis_for_reportlab(line[4:])
                story.append(Paragraph(final_text, style_h3))
            elif line.strip().startswith(("* ", "- ")):
                final_text = self._wrap_emojis_for_reportlab(line.strip()[2:])
                story.append(Paragraph(f"• {final_text}", style_normal))
            elif re.match(r'^\d+\.\s', line.strip()):
                final_text = self._wrap_emojis_for_reportlab(line.strip())
                story.append(Paragraph(final_text, style_normal))
            elif line.strip() == "":
                story.append(Spacer(1, 0.2 * inch))
            else:
                # Handle bold/italics, then wrap emojis in the final string
                formatted_line = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', line)
                formatted_line = re.sub(r'_(.*?)_', r'<i>\1</i>', formatted_line)
                final_text = self._wrap_emojis_for_reportlab(formatted_line)
                story.append(Paragraph(final_text, style_normal))

        return story

    def create_pdf(self, md_asset: Path, layout_name: str, layout_properties: dict):
        """
        📄 With content and a layout's grace, this function builds the PDF space.
        Creates a single PDF file 📄 from a given markdown file 📝.
        """
        try:
            md_content = md_asset.read_text(encoding="utf-8")
            date_str = datetime.datetime.now().strftime("%Y-%m-%d")
            output_filename = f"{md_asset.stem}_{layout_name.replace(' ', '-')}_{date_str}.pdf"
            output_path = OUTPUT_DIR / output_filename

            doc = SimpleDocTemplate(
                str(output_path),
                pagesize=layout_properties.get("size", A4),
                rightMargin=inch, leftMargin=inch,
                topMargin=inch, bottomMargin=inch
            )
            story = self._markdown_to_story(md_content)
            doc.build(story)
        except Exception as e:
            st.error(f"Failed to process {md_asset.name} with ReportLab: {e}")


# --- Streamlit UI and File Handling ---

def get_file_download_link(file_path: Path) -> str:
    """
    🔗 To grab your file and not delay, a special link is paved today.
    """
    with open(file_path, "rb") as f:
        data = base64.b64encode(f.read()).decode()
    return f'<a href="data:application/octet-stream;base64,{data}" download="{file_path.name}">Download</a>'

def display_file_explorer():
    """
    📂 To see your files, both old and new, this handy explorer gives a view.
    """
    st.header("📂 File Explorer")
    st.subheader("Source Markdown Files (.md)")
    md_files = list(Path(".").glob("*.md"))
    if not md_files:
        st.info("No Markdown files found. A `sample.md` has been created for you.")
    else:
        for md_file in md_files:
            col1, col2 = st.columns([0.8, 0.2])
            with col1:
                st.write(f"📝 `{md_file.name}`")
            with col2:
                st.markdown(get_file_download_link(md_file), unsafe_allow_html=True)

    st.subheader("Generated PDF Files")
    pdf_files = sorted(list(OUTPUT_DIR.glob("*.pdf")), key=lambda p: p.stat().st_mtime, reverse=True)
    if not pdf_files:
        st.info("No PDFs generated yet. Click the button above to start.")
    else:
        for pdf_file in pdf_files:
            col1, col2 = st.columns([0.8, 0.2])
            with col1:
                st.write(f"📄 `{pdf_file.name}`")
            with col2:
                st.markdown(get_file_download_link(pdf_file), unsafe_allow_html=True)

# --- Main App Execution ---

def main():
    """
    🚀 To run the app and make it go, call this main function, you know!
    """
    st.set_page_config(layout="wide", page_title="PDF Generator")
    st.title("📄 Markdown to PDF Generator")
    st.markdown("This tool converts all `.md` files in this directory to PDF. It now supports emojis! 👍")

    if not any(Path(".").glob("*.md")):
        with open("sample.md", "w", encoding="utf-8") as f:
            f.write("# Sample Document 👍\n\nThis is a sample markdown file. **ReportLab** is creating the PDF. Emojis like 🚀 and 💡 should now appear correctly.\n\n### Features\n- Item 1\n- Item 2\n\n```\ndef hello_world():\n    print(\"Hello, PDF! 👋\")\n```\n")
        st.rerun()

    pdf_generator = PDFGenerator(EMOJI_FONT_PATH)

    if st.button("🚀 Generate PDFs from all Markdown Files", type="primary"):
        markdown_files = list(Path(".").glob("*.md"))
        if not markdown_files:
            st.warning("No `.md` files found. Please add a markdown file to the directory.")
        else:
            total_pdfs = len(markdown_files) * len(LAYOUTS)
            progress_bar = st.progress(0, text="Starting PDF generation...")
            pdf_count = 0
            with st.spinner("Generating PDFs... Please wait."):
                for md_file in markdown_files:
                    st.info(f"Processing: **{md_file.name}**")
                    for name, properties in LAYOUTS.items():
                        pdf_generator.create_pdf(md_file, name, properties)
                        pdf_count += 1
                        progress_bar.progress(pdf_count / total_pdfs, f"Generated {pdf_count}/{total_pdfs} PDFs...")
            st.success("✅ PDF generation complete!")
            st.balloons()
            st.rerun()

    display_file_explorer()

if __name__ == "__main__":
    main()