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

# --- Configuration & Setup ---
# Guidance on emojis :  https://jamanetwork.com/journals/jamanetworkopen/fullarticle/2805970
# Interpreting Emoji: A Medical Tune! 🎶
emojistory='''
* **A Study We Must Cite, Shining a Guiding Light** 💡
    * In texts that docs send, to colleague and friend 👨‍⚕️
        * They add feelings, you see, with such simple glee! 🥰
        * To start or to end, a message to send! 👋
* **A Language of Care, Beyond Just a Stare** 👀
    * From Words to a Sign, A Method so Fine ✍️
        * A sad face, a knife, might just save a life 🔪
        * Three hearts beat as one, a new code's begun 🫀
    * The Thumbs-Up We See, Means More Than "OK" to Me 👍
        * "I approve," it can say, "let's get on our way!" ✅
        * A symbol so new, for the legal crew! ⚖️
    * For Those Who Can't Speak, A Future We Seek 🤫
        * With a point and a tap, they'll close the gap 👆
* **The Future is Bright, with Symbols of Light** ✨
    * From Paper to Screen, A New Painful Scene 🖥️
        * The Wong-Baker scale, tells its digital tale 😀
        * From sad face to cry, the pain doesn't lie 😭
    * We Need More Anatomy, for You and for Me! 🧍
        * A heart and a lung, a new song is sung 🫁
        * But where is the gut, or the kidney, but... 🤷
        * Societies must agree, on a new emoji! 🤝
    * Let a Smart Brain Decide, with Naught Left to Hide 🧠
        * With lightning and thought, a lesson is taught ⚡
        * Machine learning is key, for the patient and thee 🔑
* **So Let's All Embrace, This New Smiley Face** 😊
    * A Universal Tongue, For Old and for Young 🌍
        * To help doctors connect, and earn our respect 🙏
        * So patients can share, their every last care ❤️
    * A Picture's a Word, That Must Now Be Heard 🗣️
        * Improving the art, of healing the heart 💖
        * The future is clear, let's all give a cheer! 🎉
'''
st.markdown(emojistory)

# 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()