script.py

import argparse
import json
import shutil
import subprocess
import sys
from datetime import datetime
from pathlib import Path
import re
import hashlib
import tempfile
import os
import urllib.request
import urllib.parse

def get_root() -> Path:
    if getattr(sys, 'frozen', False):
        return Path(sys._MEIPASS)
    return Path(__file__).parent.resolve()

ROOT = get_root()

PLACEHOLDERS = [
    "@@TITLE@@",
    "@@SUBTITLE@@",
    "@@SUBMITTEDTO@@",
    "@@AUTHORS@@",
    "@@DATE@@",
    "@@INPUT_FILE@@",
    "@@TITLE_TEMPLATE@@",
    "@@ENABLE_CONTENT_PAGE@@",
    "@@TOC_DEPTH@@",
    "@@ENABLE_PAGE_CREDITS@@",
    "@@ENABLE_FOOTNOTES_AT_END@@",
    "@@ENABLE_FOOTNOTES_AS_COMMENTS@@",
    "@@ENABLE_THATS_ALL_PAGE@@",
    "@@HEADING_NUMBERING@@",
    "@@UNIVERSITY@@",
    "@@DEPARTMENT@@",
]
IMAGE_EXTS = {
    ".png",
    ".jpg",
    ".jpeg",
    ".gif",
    ".pdf",
    ".svg",
    ".eps",
    ".bmp",
    ".webp",
}

LATEX_LOG_LEVEL = "SILENT"


class BuildError(Exception):
    pass


class Logger:
    """Colored console logging utility with single-line overwriting."""

    COLORS = {
        "INFO": "\033[94m",
        "SUCCESS": "\033[92m",
        "WARNING": "\033[93m",
        "ERROR": "\033[91m",
        "RESET": "\033[0m",
    }
    _last_length = 0

    @classmethod
    def _print(cls, msg: str, persist: bool = False):
        """Print message, optionally overwriting previous line."""
        padding = max(0, cls._last_length - len(msg))
        padded_msg = msg + " " * padding
        cls._last_length = len(msg)

        if persist:
            print(f"\r{padded_msg}")
            cls._last_length = 0
        else:
            print(f"\r{padded_msg}", end="", flush=True)

    @classmethod
    def info(cls, msg: str, persist: bool = False):
        cls._print(f"{cls.COLORS['INFO']}[INFO]{cls.COLORS['RESET']} {msg}", persist)

    @classmethod
    def success(cls, msg: str, persist: bool = True):
        cls._print(f"{cls.COLORS['SUCCESS']}[SUCCESS]{cls.COLORS['RESET']} {msg}", persist)

    @classmethod
    def warning(cls, msg: str, persist: bool = True):
        cls._print(f"{cls.COLORS['WARNING']}[WARNING]{cls.COLORS['RESET']} {msg}", persist)

    @classmethod
    def error(cls, msg: str, persist: bool = True):
        cls._print(f"{cls.COLORS['ERROR']}[ERROR]{cls.COLORS['RESET']} {msg}", persist)


def load_or_create_metadata(md_dir: Path, md_base: str) -> dict:
    def is_similar_json(s1: dict, s2: dict, except_keys: set) -> bool:
        """Check if two JSON objects have the same keys with matching data types."""
        s1_filtered = {k: v for k, v in s1.items() if k not in except_keys}
        s2_filtered = {k: v for k, v in s2.items() if k not in except_keys}

        if s1_filtered.keys() != s2_filtered.keys():
            return False
        for key in s1_filtered.keys():
            if type(s1_filtered[key]) != type(s2_filtered[key]):
                return False
        return True

    def load_json_file(path: Path) -> dict:
        """Safely load JSON from file."""
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)

    def get_current_date() -> str:
        """Get current date in the required format."""
        return datetime.now().strftime("%B %d, %Y")

    def write_metadata_with_date(data: dict, path: Path) -> None:
        """Write metadata JSON file with current date."""
        data["date"] = get_current_date()
        path.write_text(json.dumps(data, indent=2), encoding="utf-8")

    def update_compatible_fields(target: dict, source: dict | None) -> None:
        """Update target dict with compatible fields from source."""
        if source is not None:
            target.update({k: v for k, v in source.items() if k in target and type(v) == type(target[k])})

    """Load metadata JSON file, creating default if missing."""
    meta_path = md_dir / f"{md_base}.json"
    json_file = load_json_file(ROOT / "default.json")

    if not meta_path.exists():

        parent_default_path = ROOT.parent / "default.json"
        if parent_default_path.exists():
            try:
                modified_default = load_json_file(parent_default_path)
            except json.JSONDecodeError:
                Logger.error(f"Invalid JSON in {parent_default_path}. Using default.")
                modified_default = None
            if is_similar_json(json_file, modified_default, except_keys={"date"}):
                json_file = modified_default
            else:
                update_compatible_fields(json_file, modified_default)
                with open(parent_default_path, "w", encoding="utf-8") as f:
                    json.dump(json_file, f, indent=2)

        write_metadata_with_date(json_file, meta_path)
        Logger.warning(f"Created {md_base}.json")
    else:
        try:
            json_file_in_dir = load_json_file(meta_path)
        except json.JSONDecodeError:
            Logger.error(f"Invalid JSON in {md_base}.json. Recreating from default.")
            write_metadata_with_date(json_file, meta_path)
            return json_file

        if not is_similar_json(json_file, json_file_in_dir, except_keys={"date"}):
            update_compatible_fields(json_file, json_file_in_dir)
            write_metadata_with_date(json_file, meta_path)
            Logger.warning(f"Updated {md_base}.json to match expected structure")

    return load_json_file(meta_path)


def build_authors(meta: dict) -> str:
    """Build LaTeX table rows for authors from metadata."""
    authors = meta.get("submittedby") or []
    if not isinstance(authors, list):
        return ""
    lines: list[str] = []
    for i, a in enumerate(authors):
        name = str(a.get("name", ""))
        roll = str(a.get("roll", ""))
        if i > 0:
            lines.append(r"\noalign{\vspace{0.3cm}}")
        lines.append(f"Name: & {name} \\\\")
        lines.append(f"Reg\\#: & {roll} \\\\")
    if not lines:
        return ""
    return "\n".join(lines)


def replace_placeholders(md_path: Path, tex_path: Path, meta: dict):
    """Replace template placeholders with metadata values."""
    content = tex_path.read_text(encoding="utf-8")
    authors_block = build_authors(meta)
    to_value = meta.get("submittedto", "")

    # Map string template names to numeric values for LaTeX
    title_template_map = {
        "no-title": 0,
        "university-title": 1,
        "header-title": 2,
        "separate-page-title": 3,
    }

    title_template_value = meta.get("titleTemplate", "no-title")

    # Support both old numeric format and new string format for backward compatibility
    if isinstance(title_template_value, int):
        title_template = title_template_value
        if title_template < 0 or title_template > 3:
            title_template = 0
    else:
        title_template = title_template_map.get(title_template_value, 0)

    title_template_cmd = f"\\renewcommand{{\\titleTemplate}}{{{title_template}}}"
    enable_content = bool(meta.get("enableContentPage"))
    content_page_toggle = "\\enablecontentpagetrue" if enable_content else "\\enablecontentpagefalse"

    toc_depth = int(meta.get("tocDepth", 3))
    if toc_depth < 1 or toc_depth > 6:
        toc_depth = 3
    toc_depth_cmd = f"\\setcounter{{tocdepth}}{{{toc_depth}}}"

    enable_credits = bool(meta.get("enablePageCredits", False))
    page_credits_toggle = "\\enablepagecreditstrue" if enable_credits else "\\enablepagecreditsfalse"

    enable_footnotes_at_end = bool(meta.get("moveFootnotesToEnd"))
    footnotes_at_end_toggle = "\\enablefootnotesatendtrue" if enable_footnotes_at_end else "\\enablefootnotesatendfalse"

    enable_footnotes_as_comments = bool(meta.get("footnotesAsComments"))
    footnotes_as_comments_toggle = "\\enablefootnotesascommentstrue" if enable_footnotes_as_comments else "\\enablefootnotesascommentsfalse"

    enable_thats_all = bool(meta.get("enableThatsAllPage"))
    thats_all_toggle = "\\enablethatsalltrue" if enable_thats_all else "\\enablethatsallfalse"

    heading_numbering = bool(meta.get("headingNumbering", False))
    heading_numbering_toggle = "" if heading_numbering else "\\suppressnumbering"

    mapping = {
        "@@TITLE@@": meta.get("title", ""),
        "@@SUBTITLE@@": meta.get("subtitle", ""),
        "@@SUBMITTEDTO@@": to_value,
        "@@AUTHORS@@": authors_block,
        "@@DATE@@": meta.get("date", ""),
        "@@INPUT_FILE@@": md_path.name,
        "@@TITLE_TEMPLATE@@": title_template_cmd,
        "@@ENABLE_CONTENT_PAGE@@": content_page_toggle,
        "@@TOC_DEPTH@@": toc_depth_cmd,
        "@@ENABLE_PAGE_CREDITS@@": page_credits_toggle,
        "@@ENABLE_FOOTNOTES_AT_END@@": footnotes_at_end_toggle,
        "@@ENABLE_FOOTNOTES_AS_COMMENTS@@": footnotes_as_comments_toggle,
        "@@ENABLE_THATS_ALL_PAGE@@": thats_all_toggle,
        "@@HEADING_NUMBERING@@": heading_numbering_toggle,
        "@@UNIVERSITY@@": meta.get("university", ""),
        "@@DEPARTMENT@@": meta.get("department", ""),
    }

    for ph in PLACEHOLDERS:
        val = mapping.get(ph, "")
        content = content.replace(ph, val)
    tex_path.write_text(content, encoding="utf-8")


def run_lualatex(build_dir: Path):
    env = os.environ.copy()
    texmf = ROOT / "texmf"
    if texmf.exists():
        env["TEXMFHOME"] = str(texmf)

    cmd = [
        "lualatex",
        "--shell-escape",
        "-synctex=1",
        "-interaction=nonstopmode",
        "-file-line-error",
        "template.tex",
    ]

    try:
        Logger.info(f"Compiling into PDF...", persist=False)
        proc = subprocess.run(
            cmd,
            cwd=build_dir,
            env=env,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
            encoding="utf-8",
            check=False,
        )
    except FileNotFoundError as e:
        raise BuildError("lualatex not found") from e
    final_returncode = proc.returncode
    output = proc.stdout

    if LATEX_LOG_LEVEL == "DEBUG":
        print(output)

    pdf_path = build_dir / "template.pdf"
    produced = pdf_path.exists()
    return final_returncode, produced, pdf_path


def find_markdown_images(md_path: Path) -> list[Path]:
    text = md_path.read_text(encoding="utf-8", errors="ignore")
    candidates: set[str] = set()

    for m in re.finditer(r"!\[[^\]]*\]\(([^)]+)\)", text):
        # ![alt text](path)
        raw = m.group(1).strip()
        if raw.startswith("<") and raw.endswith(">"):
            raw = raw[1:-1]
        if (raw.startswith('"') and raw.endswith('"')) or (raw.startswith("'") and raw.endswith("'")):
            raw = raw[1:-1]
        if " " in raw and not any(raw.startswith(q) for q in ('"', "'")):
            raw = raw.split(" ")[0]
        candidates.add(raw)

    for m in re.finditer(r'<img[^>]*?src=["\']([^"\']+)["\']', text, re.IGNORECASE):
        # <img src="path" ...>
        candidates.add(m.group(1).strip())

    for m in re.finditer(r"^\s*\[[^\]]+\]:\s*(\S+)", text, re.MULTILINE):
        # [label]: path
        target = m.group(1).strip()
        candidates.add(target)

    paths: list[Path] = []
    for c in candidates:
        if not c or "://" in c or c.startswith("data:") or c.startswith("#"):
            continue
        p = (md_path.parent / c).resolve()
        if p.exists() and p.suffix.lower() in IMAGE_EXTS:
            paths.append(p)
    return paths


def download_remote_images_from_markdown(md_content: str, build_dir: Path) -> str:
    """Download remote images referenced in markdown and replace URLs with local paths."""

    images_dir = build_dir / "images"
    images_dir.mkdir(exist_ok=True)

    def download_and_replace_url(match):
        url = match.group(2).strip()

        if not ("http://" in url or "https://" in url):
            return match.group(0)

        try:
            clean_url = url.split("?")[0] if "?" in url else url
            filename = Path(urllib.parse.urlparse(clean_url).path).name

            if not filename or "." not in filename:
                filename = "image_" + hashlib.md5(url.encode()).hexdigest()[:8] + ".jpg"

            local_path = images_dir / filename

            if not local_path.exists():
                Logger.info(f"Downloading: {filename}", persist=False)
                urllib.request.urlretrieve(url, local_path)

            relative_path = f"images/{filename}"
            return f"![{match.group(1)}]({relative_path})"

        except Exception as e:
            Logger.warning(f"Failed to download image: {e}")
            return match.group(0)

    return re.sub(r"!\[([^\]]*)\]\(([^)]+)\)", download_and_replace_url, md_content)


def convert_markdown_footnotes_to_latex(content: str, use_comments: bool = False) -> str:
    content, protected_blocks = protect_code_and_math_blocks(content)
    footnote_defs = {}

    def extract_definition(match):
        label = match.group(1)
        content = match.group(2).strip()
        footnote_defs[label] = content
        return ""

    content = re.sub(r"^\[(\^[^\]]+)\]:\s*(.+?)(?=\n\s*\n|\n\s*\[|\Z)", extract_definition, content, flags=re.MULTILINE | re.DOTALL)

    if use_comments:

        def replace_inline(match):
            footnote_content = match.group(1)
            return f"\\todoComment{{{footnote_content}}}"

        content = re.sub(r"\^\[([^\]]+)\]", replace_inline, content)

        def replace_reference(match):
            label = match.group(1)
            if label in footnote_defs:
                footnote_content = footnote_defs[label]
                return f"\\todoComment{{{footnote_content}}}"
            return match.group(0)

        content = re.sub(r"\[(\^[^\]]+)\]", replace_reference, content)
    else:

        def replace_inline(match):
            footnote_content = match.group(1)
            return f"\\footnote{{{footnote_content}}}"

        content = re.sub(r"\^\[([^\]]+)\]", replace_inline, content)

        def replace_reference(match):
            label = match.group(1)
            if label in footnote_defs:
                footnote_content = footnote_defs[label]
                return f"\\footnote{{{footnote_content}}}"
            return match.group(0)

        content = re.sub(r"\[(\^[^\]]+)\]", replace_reference, content)

    content = restore_protected_blocks(content, protected_blocks)
    return content


def escape_latex_url(url: str) -> str:
    """Escapes characters in a URL for LaTeX."""
    # The hyperref package is smart, but & and % are still issues.
    # It's generally safer to escape them.
    return url.replace("&", r"\&").replace("%", r"\%")


def escape_signs(content: str, to_escape: list[str]) -> str:
    """Escape special characters while protecting code blocks, raw latex blocks, and URLs."""
    protected_blocks = []

    def protect_and_store(match):
        placeholder = f"__PROTECTED_BLOCK_{len(protected_blocks)}__"
        protected_blocks.append(match.group(0))
        return placeholder

    # Protect blocks where no escaping should happen
    content = re.sub(r"````+.*?````+", protect_and_store, content, flags=re.DOTALL)
    content = re.sub(r"```.*?```", protect_and_store, content, flags=re.DOTALL)
    content = re.sub(r"`[^`\n]+`", protect_and_store, content)
    content = re.sub(r"\$\$.*?\$\$", protect_and_store, content, flags=re.DOTALL)
    content = re.sub(r"\$[^$\n]+\$", protect_and_store, content)

    # For markdown links, escape the URL part separately
    def protect_and_escape_link_url(match):
        link_text = match.group(1)
        url = match.group(2)
        escaped_url = escape_latex_url(url)
        placeholder = f"__PROTECTED_BLOCK_{len(protected_blocks)}__"
        protected_blocks.append(escaped_url)
        return f"[{link_text}]({placeholder})"

    content = re.sub(r"\[([^\]]*)\]\(([^)]+)\)", protect_and_escape_link_url, content)

    # Protect raw URLs that are not in markdown links
    def protect_and_escape_raw_url(match):
        url = match.group(1)
        escaped_url = escape_latex_url(url)
        placeholder = f"__PROTECTED_BLOCK_{len(protected_blocks)}__"
        protected_blocks.append(escaped_url)
        return placeholder

    content = re.sub(r"\b(https?://[^\s<>\"')]+)", protect_and_escape_raw_url, content)

    # Now, escape the characters in the rest of the content
    for sign in to_escape:
        content = content.replace(sign, f"\\{sign}")

    # Restore all protected blocks
    for i, block in enumerate(protected_blocks):
        content = content.replace(f"__PROTECTED_BLOCK_{i}__", block, 1)

    return content


def normalize_language_identifiers(content: str) -> str:
    lang_map = {
        "jsonc": "json",
        "tsx": "typescript",
        "jsx": "javascript",
        "vue": "html",
        "svelte": "html",
        "astro": "html",
    }

    for unsupported, supported in lang_map.items():
        content = re.sub(rf"```{unsupported}\b", f"```{supported}", content)

    return content


def process_code_blocks(content: str, build_dir: Path) -> str:
    lines = content.split("\n")
    processed_lines = []
    in_code_block = False
    code_block_lines = []
    header = ""
    opening_fence = ""

    for line in lines:
        if not in_code_block:
            match = re.match(r"^(\s*)(`{3,})(.*)", line)
            if match:
                in_code_block = True
                opening_fence = match.group(2)
                header = match.group(3).strip()
            else:
                processed_lines.append(line)
        else:
            if line.strip().startswith(opening_fence) and len(line.strip()) >= len(opening_fence):
                in_code_block = False
                code_content = "\n".join(code_block_lines)

                lang_match = re.match(r"(\w+)", header)
                lang = lang_match.group(1) if lang_match else "text"

                if lang == "mermaid":
                    original_block = f"{opening_fence}{header}\n{code_content}\n{line.strip()}"
                    processed_lines.append(original_block)
                else:
                    clean_code_content = code_content
                    code_hash = hashlib.md5(clean_code_content.encode("utf-8")).hexdigest()
                    code_dir = build_dir / "_code_build"
                    code_dir.mkdir(exist_ok=True)
                    code_filepath = code_dir / code_hash
                    code_filepath.write_text(clean_code_content, encoding="utf-8")

                    highlight_match = re.search(r"\.highlightlines=([\d,-]+)", header)
                    if highlight_match:
                        line_spec = highlight_match.group(1)
                        minted_options = f"breaklines,breakanywhere,linenos=false,highlightcolor=codeHighlightBg,highlightlines={{{line_spec}}}"
                    else:
                        minted_options = "breaklines,breakanywhere,linenos=false,highlightcolor=codeHighlightBg"

                    pygments_lang = lang
                    if lang == "text" or not lang:
                        top_padding = "5pt"
                        show_label = "false"
                    else:
                        top_padding = "20pt"
                        show_label = "true"

                    latex_command = f"""
\\begin{{tcolorbox}}[
enhanced, colback=black!3, colframe=black!10, boxrule=0.5pt, arc=3pt,
left=5pt, right=5pt, top={top_padding}, bottom=5pt, breakable,
overlay={{\\ifstrequal{{{show_label}}}{{true}}{{\\node[anchor=north east, font=\\scriptsize\\ttfamily, text=black!50, fill=black!7, rounded corners=1pt] at ([xshift=-5pt,yshift=-5pt]frame.north east) {{{lang}}};}}{{}} }}
]
\\inputminted[{minted_options}]{{{pygments_lang if pygments_lang else 'text'}}}{{_code_build/{code_hash}}}
\\end{{tcolorbox}}"""
                    raw_latex_block = f"```{{=latex}}\n{latex_command}\n```"
                    processed_lines.append(raw_latex_block)

                code_block_lines = []
                header = ""
                opening_fence = ""
            else:
                code_block_lines.append(line)

    if in_code_block:
        processed_lines.append(opening_fence + header)
        processed_lines.extend(code_block_lines)

    return "\n".join(processed_lines)


def find_mmdc_command():
    """Return path to mermaid-cli (mmdc) if available in PATH."""
    candidates = ["mmdc"]
    if os.name == "nt":
        candidates.insert(0, "mmdc.cmd")

    for cmd in candidates:
        found = shutil.which(cmd)
        if found:
            return found

    return None


def process_mermaid_diagrams(content: str, build_dir: Path) -> str:
    if "```mermaid" not in content:
        return content

    protected_blocks = []

    def store_non_mermaid_block(match):
        protected_blocks.append(match.group(0))
        return f"__PROTECTED_CODE_BLOCK_{len(protected_blocks)-1}__"

    content = re.sub(r"````+.*?````+", store_non_mermaid_block, content, flags=re.DOTALL)

    mmdc_cmd = find_mmdc_command()
    if mmdc_cmd is None:
        Logger.warning("Mermaid-cli not found. Install with: npm install -g @mermaid-js/mermaid-cli")

        def mermaid_to_text(match):
            mermaid_code = match.group(1).strip()
            return f"```text\n{mermaid_code}\n```"

        pattern = r"```mermaid\n(.*?)\n```"
        content = re.sub(pattern, mermaid_to_text, content, flags=re.DOTALL)

        for i, block in enumerate(protected_blocks):
            content = content.replace(f"__PROTECTED_CODE_BLOCK_{i}__", block)

        return content

    total_diagrams = len(re.findall(r"```mermaid\n(.*?)\n```", content, flags=re.DOTALL))
    if total_diagrams > 0:
        Logger.info(f"Processing {total_diagrams} Mermaid diagram(s)...", persist=False)

    diagram_counter = 0

    def replace_mermaid_block(match):
        nonlocal diagram_counter
        diagram_counter += 1

        mermaid_code = match.group(1).strip()
        diagram_hash = hashlib.md5(mermaid_code.encode("utf-8")).hexdigest()[:12]
        image_name = f"mermaid_{diagram_hash}.pdf"
        image_path = build_dir / image_name
        if not image_path.exists():
            try:
                with tempfile.NamedTemporaryFile(mode="w", suffix=".mmd", delete=False, encoding="utf-8") as temp_file:
                    temp_file.write(mermaid_code)
                    temp_mmd_path = Path(temp_file.name)

                config_content = {"theme": "neutral", "themeVariables": {"background": "#ffffff", "primaryColor": "#ffffff"}}

                with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False, encoding="utf-8") as config_file:
                    json.dump(config_content, config_file, indent=2)
                    temp_config_path = Path(config_file.name)

                cmd = [
                    mmdc_cmd,
                    "-i",
                    str(temp_mmd_path),
                    "-o",
                    str(image_path),
                    "-t",
                    "neutral",
                    "-b",
                    "white",
                    "-c",
                    str(temp_config_path),
                    "--pdfFit",
                ]

                result = subprocess.run(cmd, capture_output=True, text=True, check=False)

                temp_mmd_path.unlink()
                temp_config_path.unlink()
                if result.returncode != 0 or not image_path.exists():
                    Logger.warning(f"Failed {diagram_counter}/{total_diagrams}")
                    return f"```text\n{mermaid_code}\n```"
                else:
                    Logger.info(f"Generated {diagram_counter}/{total_diagrams}", persist=False)

            except Exception:
                Logger.warning(f"Error {diagram_counter}/{total_diagrams}")
                return f"```text\n{mermaid_code}\n```"
        else:
            Logger.info(f"Cached {diagram_counter}/{total_diagrams}", persist=False)
        return f"![Mermaid Diagram]({image_name})"

    pattern = r"```mermaid\n(.*?)\n```"
    processed_content = re.sub(pattern, replace_mermaid_block, content, flags=re.DOTALL)

    for i, block in enumerate(protected_blocks):
        processed_content = processed_content.replace(f"__PROTECTED_CODE_BLOCK_{i}__", block)

    return processed_content


def process_keyboard_shortcuts(content: str) -> str:
    """Convert [[KEY]] and [[KEY1] + [KEY2]] syntax to LaTeX keyboard shortcut commands."""
    content, protected_blocks = protect_code_and_math_blocks(content)

    def convert_shortcut(match):
        captured = match.group(1)
        shortcut_content = "[" + captured + "]"
        parts = re.findall(r"\[([^\]]+)\]|(\s*\+\s*)", shortcut_content)

        latex_parts = []
        for key, separator in parts:
            if key:
                latex_parts.append(f"\\kbdkey{{{key}}}")
            elif separator:
                latex_parts.append("\\kbdplus")

        joined_latex = "".join(latex_parts)
        return f"\\kbdshortcut{{{joined_latex}}}"

    content = re.sub(r"\[\[(.*?)\]\]", convert_shortcut, content)

    content = restore_protected_blocks(content, protected_blocks)
    return content


def process_container_blocks(content: str) -> str:
    """Convert container-style blocks (alerts, alignment, boxes) to LaTeX environments with proper nesting support."""
    content, protected_blocks = protect_code_and_math_blocks(content)

    container_types = {
        "note": "mdalertnote",
        "tip": "mdalerttip",
        "important": "mdalertimportant",
        "warning": "mdalertwarning",
        "caution": "mdalertcaution",
        "center": "mdcenter",
        "right": "mdright",
        "box": "mdbox",
    }

    lines = content.split("\n")
    processed_lines = []
    i = 0
    alert_counter = 0

    while i < len(lines):
        line = lines[i]

        match = re.match(r"^(\s*):::\s*(note|tip|important|warning|caution|center|right|box)\s*$", line, re.IGNORECASE)
        if match:
            indent = match.group(1)
            alert_type = match.group(2).lower()
            latex_env = container_types[alert_type]
            alert_id = alert_counter
            alert_counter += 1

            alert_lines = []
            i += 1

            nesting_level = 1
            while i < len(lines) and nesting_level > 0:
                current_line = lines[i]

                if re.match(r"^(\s*):::\s*(note|tip|important|warning|caution|center|right|box)\s*$", current_line, re.IGNORECASE):
                    nesting_level += 1
                    if current_line.startswith(indent) and len(current_line) > len(indent):
                        clean_line = current_line[len(indent) :]
                    elif current_line.strip() == "":
                        clean_line = ""
                    else:
                        clean_line = current_line
                    alert_lines.append(clean_line)
                elif re.match(r"^(\s*):::\s*$", current_line):
                    nesting_level -= 1
                    if nesting_level > 0:
                        if current_line.startswith(indent) and len(current_line) > len(indent):
                            clean_line = current_line[len(indent) :]
                        elif current_line.strip() == "":
                            clean_line = ""
                        else:
                            clean_line = current_line
                        alert_lines.append(clean_line)
                else:
                    if current_line.startswith(indent) and len(current_line) > len(indent):
                        clean_line = current_line[len(indent) :]
                    elif current_line.strip() == "":
                        clean_line = ""
                    else:
                        clean_line = current_line
                    alert_lines.append(clean_line)

                i += 1

            while alert_lines and alert_lines[-1].strip() == "":
                alert_lines.pop()

            alert_content = "\n".join(alert_lines)
            processed_alert_content = process_container_blocks(alert_content)  # Recursive call
            processed_alert_lines = processed_alert_content.split("\n") if processed_alert_content else []

            processed_lines.append(f"{indent}__ALERT_BEGIN_{alert_id}_{latex_env}__")
            processed_lines.append("")

            for alert_line in processed_alert_lines:
                processed_lines.append(f"{indent}{alert_line}")

            processed_lines.append("")
            processed_lines.append(f"{indent}__ALERT_END_{alert_id}_{latex_env}__")
        else:
            processed_lines.append(line)
            i += 1

    result = "\n".join(processed_lines)
    result = restore_protected_blocks(result, protected_blocks)
    return result


def post_process_alerts(content: str) -> str:
    """Convert alert placeholders to raw LaTeX blocks after markdown processing."""
    content, protected_blocks = protect_code_and_math_blocks(content)

    def replace_begin(match):
        env_name = match.group(1)
        return f"\\begin{{{env_name}}}"

    def replace_end(match):
        env_name = match.group(1)
        return f"\\end{{{env_name}}}"

    content = re.sub(r"__ALERT_BEGIN_\d+_([a-z]+)__", replace_begin, content)
    content = re.sub(r"__ALERT_END_\d+_([a-z]+)__", replace_end, content)

    content = restore_protected_blocks(content, protected_blocks)
    return content


def protect_code_and_math_blocks(content: str) -> tuple[str, list[str]]:
    """Temporarily replace code blocks and math blocks with placeholders."""
    protected_blocks = []

    def store_protected_block(match):
        protected_blocks.append(match.group(0))
        return f"__PROTECTED_PLACEHOLDER_{len(protected_blocks)-1}__"

    content = re.sub(r"````+.*?````+", store_protected_block, content, flags=re.DOTALL)
    content = re.sub(r"```.*?```", store_protected_block, content, flags=re.DOTALL)
    content = re.sub(r"`[^`\n]*`", store_protected_block, content)
    content = re.sub(r"\$\$.*?\$\$", store_protected_block, content, flags=re.DOTALL)
    content = re.sub(r"\$[^$\n]*\$", store_protected_block, content)

    return content, protected_blocks


def restore_protected_blocks(content: str, protected_blocks: list[str]) -> str:
    """Restore protected blocks from placeholders."""
    for i, protected_block in enumerate(protected_blocks):
        content = content.replace(f"__PROTECTED_PLACEHOLDER_{i}__", protected_block)
    return content


def process_emojis(content: str) -> str:
    """Convert emoji characters in content to LaTeX \\emoji{shortcode} using emoji-table.def mapping."""

    content, protected_blocks = protect_code_and_math_blocks(content)

    if not hasattr(process_emojis, "_emoji_map"):
        emoji_map = {}
        emoji_table_path = subprocess.check_output(["kpsewhich", "emoji-table.def"], text=True).strip()
        if emoji_table_path and os.path.exists(emoji_table_path):
            with open(emoji_table_path, encoding="utf-8") as f:
                data = f.read()
            pattern = r"\\__emoji_def:nnnnn\s*{([^}]*)}\s*{([^}]*)}"
            for m in re.findall(pattern, data):
                hex_seq, shortcode = m
                chars = []
                for cp in re.findall(r"\^+([0-9a-fA-F]+)", hex_seq):
                    chars.append(chr(int(cp, 16)))
                emoji = "".join(chars)
                emoji_map[emoji] = shortcode
        process_emojis._emoji_map = emoji_map
    else:
        emoji_map = process_emojis._emoji_map

    def replace_emoji(match):
        emoji = match.group(0)
        shortcode = emoji_map.get(emoji)
        if shortcode:
            return f"\\emoji{{{shortcode}}}"
        return emoji

    if emoji_map:
        emoji_regex = re.compile("|".join(re.escape(e) for e in sorted(emoji_map, key=len, reverse=True)))
        content = emoji_regex.sub(replace_emoji, content)

    content = restore_protected_blocks(content, protected_blocks)

    return content


def apply_markdown_formatting_math_safe(content: str) -> str:
    """Apply markdown formatting while protecting LaTeX math blocks and code blocks."""
    content, protected_blocks = protect_code_and_math_blocks(content)

    content = re.sub(r"(?<=\s)==([^=]+)==(?=\s|[.,!?:;\'\"\)\]\}]|\Z)", r"\\mdhighlight{\1}", content)
    content = re.sub(r"(?<=\s)~~([^~]+)~~(?=\s|[.,!?:;\'\"\)\]\}]|\Z)", r"\\mdstrikethrough{\1}", content)
    content = re.sub(r"(?<=\s)--([^-]+)--(?=\s|[.,!?:;\'\"\)\]\}]|\Z)", r"\\underline{\1}", content)
    content = re.sub(r"(?<=\s)\^\^([^\^]+)\^\^(?=\s|[.,!?:;\'\"\)\]\}]|\Z)", r"\\textsc{\1}", content)
    content = re.sub(r"\^([^\^]+)\^", r"\\textsuperscript{\1}", content)
    content = re.sub(r"~([^~]+)~", r"\\textsubscript{\1}", content)

    content = restore_protected_blocks(content, protected_blocks)
    return content


def convert_svg_to_pdf(svg_path: Path, pdf_path: Path) -> bool:
    """Convert an SVG file to PDF using svglib+reportlab. Returns True on success."""
    try:
        from svglib.svglib import svg2rlg
        from reportlab.graphics import renderPDF

        drawing = svg2rlg(str(svg_path))
        if drawing is None:
            Logger.warning(f"svglib could not parse {svg_path}")
            return False
        renderPDF.drawToFile(drawing, str(pdf_path), fmt="PDF")
        return True
    except ImportError:
        Logger.warning("svglib/reportlab not installed – SVG images will not render. " "Install with: pip install svglib reportlab")
        return False
    except Exception as e:
        Logger.warning(f"SVG-to-PDF conversion failed for {svg_path}: {e}")
        return False


def rewrite_svg_refs_to_pdf(md_content: str) -> str:
    """Replace .svg image references with .pdf so LaTeX can include them."""
    md_content = re.sub(
        r'(!\[[^\]]*\]\([^)]*)\.svg(\s*(?:"[^"]*")?\s*\))',
        r"\1.pdf\2",
        md_content,
    )
    md_content = re.sub(
        r'(<img[^>]*?src=["\'])([^"\']*)(\.svg)(["\'])',
        r"\1\2.pdf\4",
        md_content,
        flags=re.IGNORECASE,
    )
    return md_content


def copy_image_assets(md_path: Path, build_dir: Path, root_md_dir: Path):
    images = find_markdown_images(md_path)
    if not images:
        return
    for img in images:
        try:
            rel = img.relative_to(root_md_dir)
        except ValueError:
            rel = Path(img.name)

        # Convert SVGs to PDF for LaTeX compatibility
        if img.suffix.lower() == ".svg":
            pdf_rel = rel.with_suffix(".pdf")
            dest = build_dir / pdf_rel
            dest.parent.mkdir(parents=True, exist_ok=True)
            if not dest.exists():
                if not convert_svg_to_pdf(img, dest):
                    Logger.error(f"Failed to convert SVG {img}")
        else:
            dest = build_dir / rel
            dest.parent.mkdir(parents=True, exist_ok=True)
            if not dest.exists():
                try:
                    shutil.copy(img, dest)
                except Exception as e:
                    Logger.error(f"Failed to copy image {img}: {e}")


def process_executable_blocks(content: str, build_dir: Path, source_dir: Path = None) -> str:
    """Execute code blocks with property-based control for multiple languages.

    Syntax: ```lang {.execute .show-code .show-output .no-cache .format=png}

    Properties:
    - .execute: Marks the block for execution.
    - .show-code: Displays the source code.
    - .hide-code: Hides the source code.
    - .show-output: Displays the execution output.
    - .hide-output: Hides the execution output.
    - .cache / .no-cache: Controls caching of execution results.
    - .format=png|pdf: Sets plot output format (default: pdf, Python only).
    """
    EXECUTION_CONFIG = {
        "python": {
            "command": ["python"],
            "extension": "py",
            "plot_check": lambda code: ("plt.show()" in code or "plt.subplots(" in code or "plt.plot(" in code or "plt.bar(" in code or "plt.scatter(" in code or "plt.hist(" in code or "plt.figure(" in code),
            "plot_code": "\nimport matplotlib.pyplot as plt\nplt.savefig(r'{plot_path}', format='{format}', bbox_inches='tight'{dpi_param})\nplt.close()",
            "plot_formats": ["pdf", "png"],
            "default_format": "pdf",
            "persistent": True,  # Enable persistent state for Python
        },
        "javascript": {"command": ["node"], "extension": "js"},
        "powershell": {"command": ["powershell", "-File"], "extension": "ps1"},
        "bash": {"command": ["bash"], "extension": "sh"},
    }

    # Try to use IPython for persistent Python execution
    python_namespace = {}  # Shared namespace for Python blocks
    try:
        from IPython.terminal.embed import InteractiveShellEmbed

        python_shell = InteractiveShellEmbed()
        python_shell.run_cell("import sys; import io", silent=True)
    except ImportError:
        python_shell = None  # Use simple exec-based persistence

    supported_langs = "|".join(EXECUTION_CONFIG.keys())
    pattern = rf"```({supported_langs})\s+{{([^}}]+)}}\n(.*?)\n```"

    protected_blocks = []

    def store_protected_block(match):
        protected_blocks.append(match.group(0))
        return f"__PROTECTED_EXEC_BLOCK_{len(protected_blocks)-1}__"

    content = re.sub(r"````+.*?````+", store_protected_block, content, flags=re.DOTALL)

    total_blocks = len(re.findall(pattern, content, flags=re.DOTALL))
    if total_blocks == 0:
        for i, block in enumerate(protected_blocks):
            content = content.replace(f"__PROTECTED_EXEC_BLOCK_{i}__", block)
        return content

    Logger.info(f"Processing {total_blocks} executable block(s)...", persist=False)
    block_counter = 0

    def execute_block(match):
        nonlocal block_counter
        block_counter += 1

        lang, properties_str, code = match.groups()
        properties = {prop.strip() for prop in properties_str.split() if prop.strip()}

        if ".execute" not in properties:
            return match.group(0)

        config = EXECUTION_CONFIG[lang]
        code_hash = hashlib.md5(code.encode("utf-8")).hexdigest()[:12]

        show_code = ".show-code" in properties and ".hide-code" not in properties
        show_output = ".hide-output" not in properties
        use_cache = ".no-cache" not in properties

        # Extract plot format
        plot_format = config.get("default_format", "pdf")
        for prop in properties:
            if prop.startswith(".format="):
                requested_format = prop.split("=", 1)[1].lower()
                if requested_format in config.get("plot_formats", ["pdf"]):
                    plot_format = requested_format
                else:
                    Logger.warning(f"Unsupported format '{requested_format}', using '{plot_format}'")
                break

        known_props_prefixes = [".execute", ".show-code", ".hide-code", ".show-output", ".hide-output", ".cache", ".no-cache", ".format="]
        all_props_list = [p.strip() for p in properties_str.split() if p.strip()]
        remaining_props = []
        for p in all_props_list:
            is_known = False
            for prefix in known_props_prefixes:
                if p.startswith(prefix):
                    is_known = True
                    break
            if not is_known:
                remaining_props.append(p)

        new_props = []
        if show_code:
            new_props.append(".show-code")
        new_props.extend(remaining_props)
        new_props_str = " ".join(new_props)

        parts = []
        if show_code:
            parts.append(f"```{lang} {{{new_props_str}}}\n{code}\n```")

        try:
            # Handle plotting for Python
            if lang == "python" and config.get("plot_check", lambda c: False)(code):
                plot_filename = f"{lang}_plot_{code_hash}.{plot_format}"
                plot_path = build_dir / plot_filename

                if use_cache and plot_path.exists():
                    Logger.info(f"Cached plot {block_counter}/{total_blocks}", persist=False)
                    if show_output:
                        parts.append(f"![Python Plot]({plot_filename})")
                    return "\n\n".join(parts)

                # Use persistent state for Python
                if config.get("persistent", False):
                    dpi_param = ", dpi=300" if plot_format == "png" else ""
                    wrapped_code = code.replace("plt.show()", "") + config["plot_code"].format(plot_path=plot_path, format=plot_format, dpi_param=dpi_param)

                    # Simple exec-based persistent execution
                    from io import StringIO
                    import sys
                    import os

                    # Capture output and change working directory
                    old_stdout = sys.stdout
                    old_stderr = sys.stderr
                    old_cwd = os.getcwd()
                    sys.stdout = captured_stdout = StringIO()
                    sys.stderr = captured_stderr = StringIO()
                    os.chdir(source_dir if source_dir else build_dir)

                    try:
                        exec(wrapped_code, python_namespace, python_namespace)
                        result_returncode = 0
                        result_stdout = captured_stdout.getvalue()
                        result_stderr = ""
                    except Exception as e:
                        import traceback

                        result_returncode = 1
                        result_stdout = captured_stdout.getvalue()
                        result_stderr = captured_stderr.getvalue() + traceback.format_exc()
                    finally:
                        sys.stdout = old_stdout
                        sys.stderr = old_stderr
                        os.chdir(old_cwd)

                    # Create a mock result object
                    class MockResult:
                        def __init__(self, returncode, stdout, stderr):
                            self.returncode = returncode
                            self.stdout = stdout
                            self.stderr = stderr

                    result = MockResult(result_returncode, result_stdout, result_stderr)
                else:
                    dpi_param = ", dpi=300" if plot_format == "png" else ""
                    wrapped_code = code.replace("plt.show()", "") + config["plot_code"].format(plot_path=plot_path, format=plot_format, dpi_param=dpi_param)
                    result = subprocess.run(config["command"] + ["-c", wrapped_code], capture_output=True, text=True, timeout=30, check=False)

                if result.returncode == 0 and plot_path.exists():
                    Logger.info(f"Generated plot {block_counter}/{total_blocks}", persist=False)
                    if show_output:
                        parts.append(f"![Python Plot]({plot_filename})")
                else:
                    Logger.warning(f"Failed to generate plot {block_counter}/{total_blocks}")
                    error_msg = result.stderr.strip() if result.stderr else "Unknown error"
                    if show_output:
                        parts.append(f"```output\nError executing code:\n{error_msg}\n```")
                return "\n\n".join(parts)

            # Handle general code execution with persistent state support
            output_filename = f"{lang}_output_{code_hash}.txt"
            output_path = build_dir / output_filename

            if use_cache and output_path.exists():
                Logger.info(f"Cached output {block_counter}/{total_blocks}", persist=False)
                if show_output:
                    output = output_path.read_text(encoding="utf-8")
                    parts.append(f"```output\n{output if output.strip() else '(No output)'}\n```")
                return "\n\n".join(parts)

            # Use persistent state for supported languages
            if config.get("persistent", False) and lang == "python":
                # Simple exec-based persistent execution
                from io import StringIO
                import sys
                import os

                # Capture output and change working directory
                old_stdout = sys.stdout
                old_stderr = sys.stderr
                old_cwd = os.getcwd()
                sys.stdout = captured_stdout = StringIO()
                sys.stderr = captured_stderr = StringIO()
                os.chdir(source_dir if source_dir else build_dir)

                try:
                    exec(code, python_namespace, python_namespace)
                    result_returncode = 0
                    result_stdout = captured_stdout.getvalue()
                    result_stderr = ""
                except Exception as e:
                    import traceback

                    result_returncode = 1
                    result_stdout = captured_stdout.getvalue()
                    result_stderr = captured_stderr.getvalue() + traceback.format_exc()
                finally:
                    sys.stdout = old_stdout
                    sys.stderr = old_stderr
                    os.chdir(old_cwd)

                # Create a mock result object
                class MockResult:
                    def __init__(self, returncode, stdout, stderr):
                        self.returncode = returncode
                        self.stdout = stdout
                        self.stderr = stderr

                result = MockResult(result_returncode, result_stdout, result_stderr)
            else:
                # Non-persistent execution (original behavior)
                temp_file_path = build_dir / f"temp_{code_hash}.{config['extension']}"
                temp_file_path.write_text(code, encoding="utf-8")

                command = config["command"] + [str(temp_file_path)]
                result = subprocess.run(command, capture_output=True, text=True, timeout=30, check=False)
                temp_file_path.unlink()

            if result.returncode == 0:
                output = result.stdout.strip()
                if use_cache:
                    output_path.write_text(output, encoding="utf-8")
                Logger.info(f"Executed {lang} block {block_counter}/{total_blocks}", persist=False)
                if show_output:
                    parts.append(f"```output\n{output if output.strip() else '(No output)'}\n```")
            else:
                error_msg = result.stderr.strip() if result.stderr else "Unknown error"
                Logger.warning(f"Failed to execute {lang} block {block_counter}/{total_blocks}")
                if show_output:
                    parts.append(f"```output\nError executing code:\n{error_msg}\n```")
            return "\n\n".join(parts)

        except subprocess.TimeoutExpired:
            msg = f"{lang} block {block_counter}/{total_blocks} timed out (30s limit)"
            Logger.warning(msg)
            if show_output:
                parts.append(f"```output\n{msg}\n```")
        except Exception as e:
            msg = f"Error executing {lang} block {block_counter}/{total_blocks}: {e}"
            Logger.warning(msg)
            if show_output:
                parts.append(f"```output\n{msg}\n```")

        return "\n\n".join(parts)

    processed_content = re.sub(pattern, execute_block, content, flags=re.DOTALL)

    for i, block in enumerate(protected_blocks):
        processed_content = processed_content.replace(f"__PROTECTED_EXEC_BLOCK_{i}__", block)

    if total_blocks > 0:
        Logger.info(f"Completed {total_blocks} executable block(s)", persist=True)

    return processed_content


def substitute_variables(content: str, meta: dict) -> str:
    """Substitute variables from metadata into markdown content.

    Variables in markdown are in the format {{variable_name}}.
    Variables are defined in the metadata JSON under the "variables" key.

    Args:
        content: Markdown content
        meta: Metadata dictionary containing variables

    Returns:
        Content with variables substituted
    """
    variables = meta.get("variables", {})

    all_variables = re.findall(r"\{\{[^}]+\}\}", content)
    if not all_variables:
        return content

    Logger.info(f"Substituting {len(all_variables)} variable(s)...", persist=False)
    content, protected_blocks = protect_code_and_math_blocks(content)
    substituted_variables = set()
    for var_name, var_value in variables.items():
        pattern = r"\{\{\s*" + re.escape(var_name) + r"\s*\}\}"
        if re.search(pattern, content):
            escaped_value = str(var_value).replace("\\", "\\\\").replace("%", "\\%").replace("&", "\\&").replace("$", "\\$").replace("#", "\\#").replace("^", "\\^").replace("_", "\\_").replace("{", "\\{").replace("}", "\\}")
            content = re.sub(pattern, escaped_value, content)
            substituted_variables.add(var_name)
    unresolved_pattern = r"\{\{([^}]+)\}\}"
    unresolved_matches = re.findall(unresolved_pattern, content)
    if unresolved_matches:
        unique_unresolved = list(set(match.strip() for match in unresolved_matches))
        Logger.warning(f"Unresolved variables: {', '.join(unique_unresolved)}")

        def replace_unresolved_variable(match):
            var_name = match.group(1).strip()
            return f"[UNDEFINED: {var_name}]"

        content = re.sub(unresolved_pattern, replace_unresolved_variable, content)

    if len(all_variables) > 0:
        Logger.info(f"Resolved {len(substituted_variables)} unique variable(s)", persist=True)
    content = restore_protected_blocks(content, protected_blocks)
    return content


def open_pdf_file(pdf_path: Path):
    """Open PDF file using the default system application."""
    try:
        if os.name == "nt":
            os.startfile(str(pdf_path))
        elif os.name == "posix":
            if sys.platform == "darwin":
                subprocess.run(["open", str(pdf_path)], check=False)
            else:
                subprocess.run(["xdg-open", str(pdf_path)], check=False)
        else:
            Logger.warning(f"Cannot open PDF on this platform: {os.name}")
            return False
        return True
    except Exception as e:
        Logger.warning(f"Failed to open PDF: {e}")
        return False


def main():
    parser = argparse.ArgumentParser(
        description="Build PDF from a markdown file using template.tex template with JSON metadata.",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Steps:
1. Validate markdown path.
2. Ensure metadata.json exists (create default if missing).
3. Create build directory _build_<basename> next to markdown.
4. Copy template (template.tex), fonts/, uni-logo.pdf, markdown file, metadata.json into build dir.
5. Replace placeholders in template.tex: @@TITLE@@, @@SUBTITLE@@, @@SUBMITTEDTO@@, @@AUTHORS@@, @@DATE@@.
6. Run: lualatex --shell-escape -synctex=1 -interaction=nonstopmode -file-line-error template.tex
7. Move template.pdf to <basename>.pdf next to markdown.
        """,
    )
    parser.add_argument("markdown_file", help="Path to the markdown file to process")
    parser.add_argument("--show", action="store_true", help="Open the generated PDF file after successful build")
    parser.add_argument("--debug", "-d", action="store_true", help="Enable debug mode")

    parser.add_argument("--titleTemplate", type=str, choices=["no-title", "university-title", "header-title", "separate-page-title"])
    parser.add_argument("--enableContentPage", type=str, choices=["true", "false"])
    parser.add_argument("--tocDepth", type=int, choices=[1, 2, 3, 4, 5, 6])
    parser.add_argument("--enablePageCredits", type=str, choices=["true", "false"])
    parser.add_argument("--moveFootnotesToEnd", type=str, choices=["true", "false"])
    parser.add_argument("--footnotesAsComments", type=str, choices=["true", "false"])
    parser.add_argument("--enableThatsAllPage", type=str, choices=["true", "false"])
    parser.add_argument("--headingNumbering", type=str, choices=["true", "false"])

    args = parser.parse_args()

    def apply_cli_overrides(meta, args):
        """Override metadata fields only if user provided CLI args."""
        if args.titleTemplate is not None:
            meta["titleTemplate"] = args.titleTemplate

        if args.enableContentPage is not None:
            meta["enableContentPage"] = args.enableContentPage.lower() == "true"

        if args.tocDepth is not None:
            meta["tocDepth"] = args.tocDepth

        if args.enablePageCredits is not None:
            meta["enablePageCredits"] = args.enablePageCredits.lower() == "true"

        if args.moveFootnotesToEnd is not None:
            meta["moveFootnotesToEnd"] = args.moveFootnotesToEnd.lower() == "true"

        if args.footnotesAsComments is not None:
            meta["footnotesAsComments"] = args.footnotesAsComments.lower() == "true"

        if args.enableThatsAllPage is not None:
            meta["enableThatsAllPage"] = args.enableThatsAllPage.lower() == "true"

        if args.headingNumbering is not None:
            meta["headingNumbering"] = args.headingNumbering.lower() == "true"

        return meta

    if args.debug:
        global LATEX_LOG_LEVEL
        LATEX_LOG_LEVEL = "DEBUG"

    md_path = Path(args.markdown_file).expanduser().resolve()
    if not md_path.exists():
        Logger.error(f"Markdown file not found: {md_path}")
        sys.exit(1)
    if md_path.suffix.lower() != ".md":
        Logger.error("Provided file must have .md extension.")
        sys.exit(1)

    md_dir = md_path.parent
    md_base = md_path.stem

    meta = load_or_create_metadata(md_dir, md_base)
    meta = apply_cli_overrides(meta, args)

    template_tex = ROOT / "template.tex"
    if not template_tex.exists():
        Logger.error(f"Template template.tex not found at {template_tex}")
        sys.exit(1)
    logo = ROOT / "uni-logo.pdf"
    credit_sign = ROOT / "credit-sign.pdf"
    fonts_dir = ROOT / "fonts"
    build_dir = md_dir / f"_build_{md_base}"
    if not build_dir.exists():
        build_dir.mkdir()

    for stale in [build_dir / "template.tex", build_dir / md_path.name, build_dir / f"{md_base}.json"]:
        if stale.exists():
            try:
                stale.unlink()
            except Exception:
                pass
    shutil.copy(template_tex, build_dir / "template.tex")
    md_content = md_path.read_text(encoding="utf-8", errors="ignore")
    md_content = process_executable_blocks(md_content, build_dir, md_path.parent)
    md_content = substitute_variables(md_content, meta)
    md_content = process_code_blocks(md_content, build_dir)
    md_content = convert_markdown_footnotes_to_latex(md_content, use_comments=meta.get("footnotesAsComments"))
    md_content = process_mermaid_diagrams(md_content, build_dir)
    md_content = normalize_language_identifiers(md_content)
    md_content = process_keyboard_shortcuts(md_content)
    md_content = process_container_blocks(md_content)
    md_content = apply_markdown_formatting_math_safe(md_content)
    md_content = process_emojis(md_content)
    md_content = post_process_alerts(md_content)
    md_content = download_remote_images_from_markdown(md_content, build_dir)
    md_content = rewrite_svg_refs_to_pdf(md_content)
    md_content = escape_signs(md_content, ["%", "&"])

    (build_dir / md_path.name).write_text(md_content, encoding="utf-8")
    shutil.copy(md_dir / f"{md_base}.json", build_dir / f"{md_base}.json")
    if logo.exists():
        shutil.copy(logo, build_dir / logo.name)
    if credit_sign.exists():
        shutil.copy(credit_sign, build_dir / credit_sign.name)
    if fonts_dir.exists() and not (build_dir / "fonts").exists():
        shutil.copytree(fonts_dir, build_dir / "fonts")

    copy_image_assets(md_path, build_dir, md_dir)
    replace_placeholders(md_path, build_dir / "template.tex", meta)
    try:
        rc, produced, pdf_path = run_lualatex(build_dir)

        if meta.get("enableContentPage") or meta.get("footnotesAsComments"):
            Logger.info("Rerunning LuaLaTeX for table of contents/footnotes...", persist=True)
            rc, produced, pdf_path = run_lualatex(build_dir)
    except BuildError as e:
        Logger.error(str(e))
        sys.exit(1)

    target_pdf = md_dir / f"{md_base}.pdf"
    if produced:
        if target_pdf.exists():
            try:
                target_pdf.unlink()
            except Exception:
                pass
        shutil.move(str(pdf_path), target_pdf)
        if rc != 0:
            Logger.warning(f"Exit {rc}, PDF: {target_pdf}")
        else:
            Logger.success(f"PDF: {target_pdf}")

        if args.show:
            Logger.info("Opening PDF file...")
            if open_pdf_file(target_pdf):
                Logger.success("PDF opened successfully")
            else:
                Logger.warning("Could not open PDF automatically")

        sys.exit(0)
    else:
        Logger.error(f"LuaLaTeX failed (exit code {rc}) and no PDF produced.")
        sys.exit(1)


if __name__ == "__main__":
    main()