Brewdoc:Md To Pdf

MIT License

Copyright (c) 2025-2026 Maxim Kochetkov (kochetkov-ma)
https://github.com/kochetkov-ma/claude-brewcode

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

#!/usr/bin/env bash
set -euo pipefail

# check_deps.sh — Dependency checker for md-to-pdf skill
# Usage: check_deps.sh <command> [engine]
#
# Commands:
#   check   <engine>   Check if engine dependencies are satisfied
#   install <engine>   Install missing dependencies for engine
#   status             Show dependency status for all engines
#
# Engines: reportlab, weasyprint
#
# Exit codes: 0 = OK, 1 = MISSING_*, 2 = bad usage

SCRIPT_NAME="$(basename "$0")"
MIN_PYTHON_MAJOR=3
MIN_PYTHON_MINOR=8

# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

usage() {
    cat <<EOF
Usage: $SCRIPT_NAME <command> [engine]

Commands:
  check   <engine>   Check dependencies (reportlab | weasyprint)
  install <engine>   Install missing dependencies (reportlab | weasyprint)
  status             Show all engines' dependency status

Engines:
  reportlab    Pure-Python PDF (pip: reportlab)
  weasyprint   HTML-based PDF (pip: weasyprint markdown pygments; brew: pango cairo gdk-pixbuf libffi)

Exit codes:
  0  OK — all dependencies present
  1  MISSING_PYTHON | MISSING_SYSTEM | MISSING_PIP
  2  Bad usage
EOF
}

die_usage() {
    echo "$1" >&2
    echo "Run '$SCRIPT_NAME help' for usage." >&2
    exit 2
}

is_macos() { [[ "$(uname -s)" == "Darwin" ]]; }

# ---------------------------------------------------------------------------
# Python version check (common to both engines)
# ---------------------------------------------------------------------------

check_python() {
    if ! command -v python3 &>/dev/null; then
        echo "MISSING_PYTHON"
        return 1
    fi

    local ver
    ver="$(python3 -c 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")')"
    local major minor
    major="${ver%%.*}"
    minor="${ver##*.}"

    if (( major < MIN_PYTHON_MAJOR )) || { (( major == MIN_PYTHON_MAJOR )) && (( minor < MIN_PYTHON_MINOR )); }; then
        echo "MISSING_PYTHON"
        return 1
    fi
    return 0
}

# ---------------------------------------------------------------------------
# Pip package checks
# ---------------------------------------------------------------------------

# check_pip_packages <pkg1> <pkg2> ...
# Prints comma-separated list of missing packages (empty if all present).
check_pip_packages() {
    local missing=()
    for pkg in "$@"; do
        if ! python3 -c "import $pkg" &>/dev/null; then
            missing+=("$pkg")
        fi
    done
    if (( ${#missing[@]} == 0 )); then
        echo ""
    else
        local IFS=','
        echo "${missing[*]}"
    fi
}

# ---------------------------------------------------------------------------
# Brew / system package checks (weasyprint only)
# ---------------------------------------------------------------------------

WEASYPRINT_BREW_PKGS=(pango cairo gdk-pixbuf libffi)

# On Linux, the equivalent apt packages differ:
#   libpango1.0-dev libcairo2-dev libgdk-pixbuf2.0-dev libffi-dev
# This script checks brew on macOS; on Linux it falls back to pkg-config.

check_system_packages() {
    local missing=()
    if is_macos; then
        for pkg in "${WEASYPRINT_BREW_PKGS[@]}"; do
            if ! brew list "$pkg" &>/dev/null; then
                missing+=("$pkg")
            fi
        done
    else
        # Linux: use pkg-config as a heuristic
        local -A linux_pc_names=(
            [pango]="pango"
            [cairo]="cairo"
            [gdk-pixbuf]="gdk-pixbuf-2.0"
            [libffi]="libffi"
        )
        for pkg in "${WEASYPRINT_BREW_PKGS[@]}"; do
            local pc="${linux_pc_names[$pkg]}"
            if ! pkg-config --exists "$pc" &>/dev/null 2>&1; then
                missing+=("$pkg")
            fi
        done
    fi
    if (( ${#missing[@]} == 0 )); then
        echo ""
    else
        local IFS=','
        echo "${missing[*]}"
    fi
}

# ---------------------------------------------------------------------------
# check command
# ---------------------------------------------------------------------------

cmd_check() {
    local engine="${1:-}"
    [[ -z "$engine" ]] && die_usage "Engine required. Use: reportlab | weasyprint"

    # Common: python3 >= 3.8
    local py_result
    py_result="$(check_python)" || { echo "$py_result"; exit 1; }

    case "$engine" in
        reportlab)
            local pip_missing
            pip_missing="$(check_pip_packages reportlab)"
            if [[ -n "$pip_missing" ]]; then
                echo "MISSING_PIP|$pip_missing"
                exit 1
            fi
            echo "OK"
            ;;
        weasyprint)
            local sys_missing pip_missing
            sys_missing="$(check_system_packages)"
            pip_missing="$(check_pip_packages weasyprint markdown pygments)"

            if [[ -n "$sys_missing" ]]; then
                echo "MISSING_SYSTEM|$sys_missing"
                exit 1
            fi
            if [[ -n "$pip_missing" ]]; then
                echo "MISSING_PIP|$pip_missing"
                exit 1
            fi
            echo "OK"
            ;;
        *)
            die_usage "Unknown engine: $engine. Use: reportlab | weasyprint"
            ;;
    esac
}

# ---------------------------------------------------------------------------
# install command
# ---------------------------------------------------------------------------

cmd_install() {
    local engine="${1:-}"
    [[ -z "$engine" ]] && die_usage "Engine required. Use: reportlab | weasyprint"

    # Ensure python3 exists first
    if ! command -v python3 &>/dev/null; then
        echo "python3 not found. Install Python >= $MIN_PYTHON_MAJOR.$MIN_PYTHON_MINOR first." >&2
        exit 1
    fi

    case "$engine" in
        reportlab)
            local pip_missing
            pip_missing="$(check_pip_packages reportlab)"
            if [[ -z "$pip_missing" ]]; then
                echo "OK"
                return
            fi
            echo "Installing pip packages: $pip_missing" >&2
            IFS=',' read -ra pkgs <<< "$pip_missing"
            pip3 install "${pkgs[@]}"
            echo "OK"
            ;;
        weasyprint)
            local sys_missing pip_missing

            sys_missing="$(check_system_packages)"
            if [[ -n "$sys_missing" ]]; then
                if is_macos; then
                    echo "Installing brew packages: $sys_missing" >&2
                    IFS=',' read -ra pkgs <<< "$sys_missing"
                    brew install "${pkgs[@]}"
                else
                    echo "Missing system packages: $sys_missing" >&2
                    echo "On Debian/Ubuntu: sudo apt-get install libpango1.0-dev libcairo2-dev libgdk-pixbuf2.0-dev libffi-dev" >&2
                    exit 1
                fi
            fi

            pip_missing="$(check_pip_packages weasyprint markdown pygments)"
            if [[ -n "$pip_missing" ]]; then
                echo "Installing pip packages: $pip_missing" >&2
                IFS=',' read -ra pkgs <<< "$pip_missing"
                pip3 install "${pkgs[@]}"
            fi
            echo "OK"
            ;;
        *)
            die_usage "Unknown engine: $engine. Use: reportlab | weasyprint"
            ;;
    esac
}

# ---------------------------------------------------------------------------
# status command
# ---------------------------------------------------------------------------

label_status() {
    # $1 = check result (OK or MISSING_*)
    if [[ "$1" == "OK" ]]; then
        echo "installed"
    else
        echo "missing"
    fi
}

cmd_status() {
    echo "| Component       | Status    | Detail                     |"
    echo "|-----------------|-----------|----------------------------|"

    # Python
    local py_result py_status py_detail
    set +e
    py_result="$(check_python)"
    local py_rc=$?
    set -e

    if (( py_rc == 0 )); then
        py_status="installed"
        py_detail="$(python3 --version 2>&1)"
    else
        py_status="missing"
        py_detail="Require >= $MIN_PYTHON_MAJOR.$MIN_PYTHON_MINOR"
    fi
    printf "| %-15s | %-9s | %-26s |\n" "python3" "$py_status" "$py_detail"

    # reportlab pip
    local rl_missing rl_status rl_detail
    if (( py_rc == 0 )); then
        rl_missing="$(check_pip_packages reportlab)"
        if [[ -z "$rl_missing" ]]; then
            rl_status="installed"
            rl_detail="reportlab"
        else
            rl_status="missing"
            rl_detail="pip: $rl_missing"
        fi
    else
        rl_status="unknown"
        rl_detail="python3 required"
    fi
    printf "| %-15s | %-9s | %-26s |\n" "reportlab" "$rl_status" "$rl_detail"

    # weasyprint system deps
    local ws_sys_missing ws_sys_status ws_sys_detail
    ws_sys_missing="$(check_system_packages)"
    if [[ -z "$ws_sys_missing" ]]; then
        ws_sys_status="installed"
        ws_sys_detail="pango cairo gdk-pixbuf libffi"
    else
        ws_sys_status="missing"
        ws_sys_detail="brew: $ws_sys_missing"
    fi
    printf "| %-15s | %-9s | %-26s |\n" "weasy-system" "$ws_sys_status" "$ws_sys_detail"

    # weasyprint pip deps
    local wp_missing wp_status wp_detail
    if (( py_rc == 0 )); then
        wp_missing="$(check_pip_packages weasyprint markdown pygments)"
        if [[ -z "$wp_missing" ]]; then
            wp_status="installed"
            wp_detail="weasyprint markdown pygments"
        else
            wp_status="missing"
            wp_detail="pip: $wp_missing"
        fi
    else
        wp_status="unknown"
        wp_detail="python3 required"
    fi
    printf "| %-15s | %-9s | %-26s |\n" "weasy-pip" "$wp_status" "$wp_detail"
}

# ---------------------------------------------------------------------------
# Main dispatch
# ---------------------------------------------------------------------------

CMD="${1:-help}"
shift 2>/dev/null || true

case "$CMD" in
    check)   cmd_check "$@" ;;
    install) cmd_install "$@" ;;
    status)  cmd_status ;;
    help|-h|--help) usage ;;
    *)       die_usage "Unknown command: $CMD" ;;
esac

#!/usr/bin/env python3
"""
Universal Markdown to PDF converter with dual engine support.

Engines:
  - reportlab  (default) -- pure Python, no system deps
  - weasyprint           -- HTML/CSS pipeline, better fidelity

Usage:
    python3 md_to_pdf.py <input.md> [output.pdf] [options]
    python3 md_to_pdf.py input.md --engine weasyprint --style custom.css
    python3 md_to_pdf.py input.md output.pdf --config my_config.json --quiet

Dependencies:
    reportlab engine:   pip install reportlab
    weasyprint engine:  pip install weasyprint markdown pygments
"""

import json
import os
import re
import sys
import argparse
import platform
from copy import deepcopy
from pathlib import Path

SCRIPT_DIR = Path(__file__).resolve().parent
DEFAULT_CONFIG_PATH = SCRIPT_DIR / ".." / "styles" / "default.json"
DEFAULT_CSS_PATH = SCRIPT_DIR / ".." / "styles" / "default.css"


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------

def parse_args(argv=None):
    p = argparse.ArgumentParser(
        description="Convert Markdown to PDF (reportlab or weasyprint).",
    )
    p.add_argument("input", help="Path to the Markdown file")
    p.add_argument("output", nargs="?", default=None, help="Output PDF path (default: <input>.pdf)")
    p.add_argument("--engine", choices=["reportlab", "weasyprint"], default="reportlab",
                   help="Rendering engine (default: reportlab)")
    p.add_argument("--config", default=None, help="JSON style config overrides")
    p.add_argument("--style", default=None, help="CSS file (weasyprint only)")
    p.add_argument("--pygments-theme", default="github", help="Code theme (weasyprint only, default: github)")
    p.add_argument("--quiet", action="store_true", help="Suppress progress output")
    args = p.parse_args(argv)
    if args.output is None:
        args.output = str(Path(args.input).with_suffix(".pdf"))
    return args


# ---------------------------------------------------------------------------
# Config loading (deep merge)
# ---------------------------------------------------------------------------

def _deep_merge(base: dict, override: dict) -> dict:
    result = deepcopy(base)
    for key, val in override.items():
        if key in result and isinstance(result[key], dict) and isinstance(val, dict):
            result[key] = _deep_merge(result[key], val)
        else:
            result[key] = deepcopy(val)
    return result


def load_config(config_path=None) -> dict:
    """Load config from JSON, falling back to defaults."""
    defaults = {}
    if DEFAULT_CONFIG_PATH.exists():
        defaults = json.loads(DEFAULT_CONFIG_PATH.read_text(encoding="utf-8"))
    if config_path:
        user_cfg = json.loads(Path(config_path).read_text(encoding="utf-8"))
        return _deep_merge(defaults, user_cfg)
    return defaults


# ---------------------------------------------------------------------------
# Cross-platform font detection (reportlab)
# ---------------------------------------------------------------------------

_FONT_SEARCH = {
    "Darwin": [
        ("/System/Library/Fonts/Supplemental/PTSans.ttc", {
            "body": ("PTSans", 0), "bold": ("PTSans-Bold", 7),
            "italic": ("PTSans-Italic", 1), "boldItalic": ("PTSans-BoldItalic", 6),
        }),
        ("/System/Library/Fonts/Supplemental/Arial.ttf", {
            "body": ("Arial", None), "bold": ("Arial-Bold", None),
            "italic": ("Arial-Italic", None), "boldItalic": ("Arial-BoldItalic", None),
        }),
    ],
    "Linux": [
        ("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", {
            "body": ("DejaVuSans", None), "bold": ("DejaVuSans-Bold", None),
            "italic": ("DejaVuSans-Oblique", None), "boldItalic": ("DejaVuSans-BoldOblique", None),
        }),
    ],
}

# Linux bold/italic companion files
_LINUX_COMPANIONS = {
    "bold": "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
    "italic": "/usr/share/fonts/truetype/dejavu/DejaVuSans-Oblique.ttf",
    "boldItalic": "/usr/share/fonts/truetype/dejavu/DejaVuSans-BoldOblique.ttf",
}


def detect_fonts() -> dict:
    """Detect available fonts, return name mapping dict.

    Returns:
        {"body": "FontName", "bold": "FontName-Bold",
         "italic": "FontName-Italic", "boldItalic": "FontName-BoldItalic",
         "family": "FontName", "_source": "path_or_builtin",
         "_entries": [(name, path, subfontIndex|None), ...]}
    """
    system = platform.system()
    candidates = _FONT_SEARCH.get(system, []) + _FONT_SEARCH.get("Linux", [])

    for font_path, mapping in candidates:
        if not os.path.exists(font_path):
            continue

        entries = []
        names = {}
        for role, (name, idx) in mapping.items():
            if system == "Linux" and role != "body":
                companion = _LINUX_COMPANIONS.get(role)
                if companion and os.path.exists(companion):
                    entries.append((name, companion, None))
                else:
                    entries.append((name, font_path, idx))
            else:
                entries.append((name, font_path, idx))
            names[role] = name

        names["family"] = names["body"]
        names["_source"] = font_path
        names["_entries"] = entries
        return names

    return {
        "body": "Helvetica", "bold": "Helvetica-Bold",
        "italic": "Helvetica-Oblique", "boldItalic": "Helvetica-BoldOblique",
        "family": "Helvetica", "_source": "builtin", "_entries": [],
    }


def register_detected_fonts(font_info: dict):
    """Register detected fonts with reportlab (lazy import)."""
    from reportlab.pdfbase import pdfmetrics
    from reportlab.pdfbase.ttfonts import TTFont

    for name, path, idx in font_info.get("_entries", []):
        kwargs = {"subfontIndex": idx} if idx is not None else {}
        pdfmetrics.registerFont(TTFont(name, path, **kwargs))

    if font_info["_entries"]:
        pdfmetrics.registerFontFamily(
            font_info["family"],
            normal=font_info["body"],
            bold=font_info["bold"],
            italic=font_info["italic"],
            boldItalic=font_info["boldItalic"],
        )


# ---------------------------------------------------------------------------
# Structured output
# ---------------------------------------------------------------------------

def print_status(output_path: str, page_count: int, engine: str, quiet: bool):
    size_bytes = Path(output_path).stat().st_size
    size_kb = f"{size_bytes / 1024:.0f}KB"
    lines = [
        f"STATUS=OK",
        f"OUTPUT={output_path}",
        f"PAGES={page_count}",
        f"SIZE={size_kb}",
        f"ENGINE={engine}",
    ]
    if not quiet:
        for ln in lines:
            print(ln)


def print_failure(message: str):
    print("STATUS=FAILED", file=sys.stdout)
    print(message, file=sys.stderr)


# ---------------------------------------------------------------------------
# WeasyPrint engine
# ---------------------------------------------------------------------------

def convert_weasyprint(input_path: str, output_path: str, config: dict,
                       css_path=None, pygments_theme="github", quiet=False):
    """Convert MD -> HTML -> CSS -> PDF via weasyprint."""
    try:
        import markdown
        import weasyprint
        from pygments.formatters import HtmlFormatter
    except ImportError as exc:
        print_failure(f"Missing dependency for weasyprint engine: {exc}\n"
                      f"Install with: pip install weasyprint markdown pygments")
        sys.exit(1)

    md_text = Path(input_path).read_text(encoding="utf-8")

    extensions = [
        "tables", "fenced_code", "codehilite", "footnotes",
        "toc", "attr_list", "def_list", "admonition", "sane_lists", "smarty",
    ]
    extension_configs = {
        "codehilite": {"css_class": "highlight", "guess_lang": True},
    }
    html_body = markdown.markdown(md_text, extensions=extensions,
                                  extension_configs=extension_configs)

    # Resolve CSS
    css_file = Path(css_path) if css_path else DEFAULT_CSS_PATH
    css_link = ""
    if css_file.exists():
        css_link = f'<link rel="stylesheet" href="file://{css_file.resolve()}">'

    # Pygments inline CSS
    try:
        pygments_css = HtmlFormatter(style=pygments_theme).get_style_defs(".highlight")
    except Exception:
        pygments_css = HtmlFormatter(style="default").get_style_defs(".highlight")

    html_doc = f"""<!DOCTYPE html>
<html><head>
<meta charset="utf-8">
{css_link}
<style>{pygments_css}</style>
</head><body>
{html_body}
</body></html>"""

    doc = weasyprint.HTML(string=html_doc, base_url=str(Path(input_path).parent)).render()
    doc.write_pdf(output_path)

    page_count = len(doc.pages)
    print_status(output_path, page_count, "weasyprint", quiet)


# ---------------------------------------------------------------------------
# Reportlab engine -- helpers
# ---------------------------------------------------------------------------

def _rl_colors(config: dict):
    """Build reportlab color objects from config."""
    from reportlab.lib import colors as rlc
    c = config.get("colors", {})
    return {
        "primary": rlc.HexColor(c.get("primary", "#1a3a5c")),
        "secondary": rlc.HexColor(c.get("secondary", "#2c5282")),
        "text": rlc.HexColor(c.get("text", "#1a1a1a")),
        "code_bg": rlc.HexColor(c.get("code_bg", "#f0f0f0")),
        "header_bg": rlc.HexColor(c.get("header_bg", "#1a3a5c")),
        "header_fg": rlc.HexColor(c.get("header_fg", "#ffffff")),
        "quote_bg": rlc.HexColor(c.get("quote_bg", "#f5f5f5")),
        "border": rlc.HexColor(c.get("border", "#3182ce")),
        "light_bg": rlc.HexColor(c.get("light_bg", "#f0f4f8")),
        "white": rlc.white,
    }


def safe_xml(text: str, code_font: str = "Courier-Bold") -> str:
    """Escape XML-unsafe chars, apply inline Markdown markup.

    Handles: **bold**, *italic*, ***bold italic***, `inline code`, [links](url).
    Args:
        code_font: font face for inline `code` spans (default: Courier-Bold).
    """
    text = text.replace("&", "&amp;")
    text = text.replace("<", "&lt;").replace(">", "&gt;")

    # Links [text](url) -- must come before bold/italic to avoid mangling
    # Internal anchors (#...) become plain bold text; external URLs become <a> tags
    def _link_repl(m):
        link_text, url = m.group(1), m.group(2)
        if url.startswith("#"):
            return f"<b>{link_text}</b>"
        return f'<a href="{url}" color="blue"><u>{link_text}</u></a>'

    text = re.sub(r"\[([^\]]+?)\]\(([^)]+?)\)", _link_repl, text)

    # Bold+italic (***), then bold (**), then italic (*)
    text = re.sub(r"\*\*\*(.+?)\*\*\*", r"<b><i>\1</i></b>", text)
    text = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", text)
    text = re.sub(r"\*(.+?)\*", r"<i>\1</i>", text)

    # Inline code -- monospace bold in red
    text = re.sub(r"`(.+?)`", rf'<font face="{code_font}" color="#c53030">\1</font>', text)

    return text


def parse_md_table(lines: list) -> list:
    """Parse markdown table lines into a list of rows (list of cell strings)."""
    rows = []
    for line in lines:
        line = line.strip()
        if not line.startswith("|"):
            continue
        cells = [c.strip() for c in line.split("|")]
        if cells and cells[0] == "":
            cells = cells[1:]
        if cells and cells[-1] == "":
            cells = cells[:-1]
        if all(re.match(r"^[-:]+$", c) for c in cells):
            continue
        rows.append(cells)
    return rows


# ---------------------------------------------------------------------------
# Reportlab engine -- styles
# ---------------------------------------------------------------------------

def build_styles(font_info: dict, config: dict):
    from reportlab.lib.enums import TA_CENTER, TA_LEFT
    from reportlab.lib.styles import ParagraphStyle, StyleSheet1

    clr = _rl_colors(config)
    typo = config.get("typography", {})
    body_sz = typo.get("body_size", 9)
    f = font_info

    ss = StyleSheet1()

    ss.add(ParagraphStyle(
        name="Normal", fontName=f["body"], fontSize=body_sz,
        leading=body_sz * 1.35, textColor=clr["text"], spaceAfter=4,
    ))
    ss.add(ParagraphStyle(
        name="H1", fontName=f["bold"], fontSize=typo.get("h1_size", 18),
        leading=22, textColor=clr["primary"], alignment=TA_CENTER,
        spaceAfter=6, spaceBefore=0,
    ))
    ss.add(ParagraphStyle(
        name="H2", fontName=f["bold"], fontSize=typo.get("h2_size", 14),
        leading=18, textColor=clr["primary"], alignment=TA_LEFT,
        spaceAfter=6, spaceBefore=14,
    ))
    ss.add(ParagraphStyle(
        name="H3", fontName=f["bold"], fontSize=typo.get("h3_size", 12),
        leading=15, textColor=clr["secondary"], alignment=TA_LEFT,
        spaceAfter=4, spaceBefore=10,
    ))
    ss.add(ParagraphStyle(
        name="H4", fontName=f["bold"], fontSize=typo.get("h4_size", 10),
        leading=13, textColor=clr["primary"], alignment=TA_LEFT,
        spaceAfter=4, spaceBefore=8,
    ))
    ss.add(ParagraphStyle(
        name="Blockquote", fontName=f["italic"], fontSize=body_sz - 0.5,
        leading=11, textColor=clr["text"], leftIndent=14,
        spaceAfter=4, spaceBefore=2, backColor=clr["quote_bg"],
        borderPadding=(4, 6, 4, 6),
    ))
    ss.add(ParagraphStyle(
        name="TableCell", fontName=f["body"], fontSize=8,
        leading=10, textColor=clr["text"],
    ))
    ss.add(ParagraphStyle(
        name="TableCellBold", fontName=f["bold"], fontSize=8,
        leading=10, textColor=clr["text"],
    ))
    ss.add(ParagraphStyle(
        name="TableHeaderCell", fontName=f["bold"], fontSize=8,
        leading=10, textColor=clr["header_fg"],
    ))
    ss.add(ParagraphStyle(
        name="Subtitle", fontName=f["italic"], fontSize=10,
        leading=13, textColor=clr["text"], alignment=TA_CENTER, spaceAfter=10,
    ))
    ss.add(ParagraphStyle(
        name="BulletItem", fontName=f["body"], fontSize=body_sz,
        leading=body_sz * 1.35, textColor=clr["text"],
        leftIndent=16, bulletIndent=6, spaceAfter=3,
    ))
    ss.add(ParagraphStyle(
        name="NumberedItem", fontName=f["body"], fontSize=body_sz,
        leading=body_sz * 1.35, textColor=clr["text"],
        leftIndent=20, firstLineIndent=-14, spaceAfter=3,
    ))
    ss.add(ParagraphStyle(
        name="CodeBlock", fontName="Courier", fontSize=config.get("code", {}).get("font_size", 7.5),
        leading=10, textColor=clr["text"], leftIndent=6,
        spaceAfter=2, spaceBefore=2,
    ))

    return ss


# ---------------------------------------------------------------------------
# Reportlab engine -- table builder
# ---------------------------------------------------------------------------

def build_table(rows: list, styles, font_info: dict, clr: dict, available_width: float):
    """Build a reportlab Table from parsed MD rows with auto column widths."""
    from reportlab.lib import colors as rlc
    from reportlab.platypus import Table, TableStyle, Paragraph

    if not rows:
        return None

    num_cols = max(len(r) for r in rows)
    for row in rows:
        while len(row) < num_cols:
            row.append("")

    header_style = styles["TableHeaderCell"]
    cell_style = styles["TableCell"]

    data = []
    for ri, row in enumerate(rows):
        prow = []
        for cell in row:
            cell_text = safe_xml(cell)
            st = header_style if ri == 0 else cell_style
            prow.append(Paragraph(cell_text, st))
        data.append(prow)

    # Auto column widths based on content length
    col_weights = [0.0] * num_cols
    for row in rows:
        for ci, cell in enumerate(row):
            col_weights[ci] = max(col_weights[ci], len(cell))

    total_weight = sum(col_weights) or 1
    col_ratios = [max(min(w / total_weight, 0.60), 0.05) for w in col_weights]
    ratio_sum = sum(col_ratios)
    col_widths = [(r / ratio_sum) * available_width for r in col_ratios]

    table = Table(data, colWidths=col_widths, repeatRows=1)
    table.setStyle(TableStyle([
        ("BACKGROUND", (0, 0), (-1, 0), clr["header_bg"]),
        ("TEXTCOLOR", (0, 0), (-1, 0), clr["header_fg"]),
        ("FONTNAME", (0, 0), (-1, 0), font_info["bold"]),
        ("FONTSIZE", (0, 0), (-1, 0), 8),
        ("VALIGN", (0, 0), (-1, -1), "TOP"),
        ("TOPPADDING", (0, 0), (-1, -1), 3),
        ("BOTTOMPADDING", (0, 0), (-1, -1), 3),
        ("LEFTPADDING", (0, 0), (-1, -1), 4),
        ("RIGHTPADDING", (0, 0), (-1, -1), 4),
        ("GRID", (0, 0), (-1, -1), 0.5, rlc.HexColor("#c0c0c0")),
        ("ROWBACKGROUNDS", (0, 1), (-1, -1), [rlc.white, clr["light_bg"]]),
    ]))
    return table


# ---------------------------------------------------------------------------
# Reportlab engine -- blockquote builder
# ---------------------------------------------------------------------------

def build_blockquote(text: str, styles, font_info: dict, clr: dict, available_width: float):
    """Build a blockquote as a table with a left blue border."""
    from reportlab.platypus import Table, TableStyle, Paragraph

    cell_text = safe_xml(text)
    para = Paragraph(cell_text, styles["Blockquote"])

    data = [[" ", para]]
    col_widths = [3, available_width - 10]
    t = Table(data, colWidths=col_widths)
    t.setStyle(TableStyle([
        ("BACKGROUND", (0, 0), (0, 0), clr["border"]),
        ("BACKGROUND", (1, 0), (1, 0), clr["quote_bg"]),
        ("TOPPADDING", (0, 0), (-1, -1), 4),
        ("BOTTOMPADDING", (0, 0), (-1, -1), 4),
        ("LEFTPADDING", (0, 0), (0, 0), 0),
        ("RIGHTPADDING", (0, 0), (0, 0), 0),
        ("LEFTPADDING", (1, 0), (1, 0), 6),
        ("VALIGN", (0, 0), (-1, -1), "TOP"),
    ]))
    return t


# ---------------------------------------------------------------------------
# Reportlab engine -- code block builder
# ---------------------------------------------------------------------------

def build_code_block(text: str, styles, clr: dict, available_width: float):
    """Build a code block with gray background."""
    from reportlab.lib import colors as rlc
    from reportlab.platypus import Table, TableStyle, Paragraph

    text = text.replace("&", "&amp;")
    text = text.replace("<", "&lt;").replace(">", "&gt;")
    text = text.replace("\n", "<br/>")
    para = Paragraph(text, styles["CodeBlock"])

    data = [[para]]
    t = Table(data, colWidths=[available_width])
    t.setStyle(TableStyle([
        ("BACKGROUND", (0, 0), (0, 0), clr["code_bg"]),
        ("TOPPADDING", (0, 0), (-1, -1), 6),
        ("BOTTOMPADDING", (0, 0), (-1, -1), 6),
        ("LEFTPADDING", (0, 0), (-1, -1), 8),
        ("RIGHTPADDING", (0, 0), (-1, -1), 8),
        ("BOX", (0, 0), (-1, -1), 0.5, rlc.HexColor("#d0d0d0")),
    ]))
    return t


# ---------------------------------------------------------------------------
# Reportlab engine -- image support
# ---------------------------------------------------------------------------

def _try_build_image(alt: str, src: str, available_width: float):
    """Attempt to build a reportlab Image flowable. Returns None if not possible."""
    from reportlab.platypus import Image

    if src.startswith("http://") or src.startswith("https://"):
        return None
    img_path = Path(src)
    if not img_path.exists():
        return None
    try:
        img = Image(str(img_path))
        iw, ih = img.drawWidth, img.drawHeight
        if iw > available_width:
            ratio = available_width / iw
            img.drawWidth = available_width
            img.drawHeight = ih * ratio
        return img
    except Exception:
        return None


# ---------------------------------------------------------------------------
# Reportlab engine -- numbered canvas
# ---------------------------------------------------------------------------

def _make_numbered_canvas_class(font_name: str, footer_fmt: str):
    """Create a NumberedCanvas class bound to the given font and format string."""
    from reportlab.lib import colors as rlc
    from reportlab.lib.pagesizes import A4
    from reportlab.pdfgen.canvas import Canvas

    class NumberedCanvas(Canvas):
        def __init__(self, *args, **kwargs):
            Canvas.__init__(self, *args, **kwargs)
            self._saved_page_states = []

        def showPage(self):
            self._saved_page_states.append(dict(self.__dict__))
            self._startPage()

        def save(self):
            num_pages = len(self._saved_page_states)
            for state in self._saved_page_states:
                self.__dict__.update(state)
                self._draw_footer(num_pages)
                Canvas.showPage(self)
            Canvas.save(self)

        def _draw_footer(self, page_count):
            self.saveState()
            fn = font_name if font_name != "Helvetica" else "Helvetica"
            self.setFont(fn, 8)
            self.setFillColor(rlc.HexColor("#888888"))
            text = footer_fmt.format(page=self._pageNumber, total=page_count)
            self.drawCentredString(A4[0] / 2, 25, text)
            self.restoreState()

    return NumberedCanvas


# ---------------------------------------------------------------------------
# Reportlab engine -- markdown to story (flowables)
# ---------------------------------------------------------------------------

def md_to_story(md_text: str, styles, font_info: dict, clr: dict,
                available_width: float) -> list:
    """Parse markdown text and return a list of reportlab flowables."""
    from reportlab.lib import colors as rlc
    from reportlab.platypus import Paragraph, Spacer
    from reportlab.platypus.flowables import HRFlowable

    lines = md_text.split("\n")
    story = []
    i = 0

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

        if not stripped:
            i += 1
            continue

        # Fenced code block
        if stripped.startswith("```"):
            code_lines = []
            i += 1
            while i < len(lines):
                if lines[i].strip().startswith("```"):
                    i += 1
                    break
                code_lines.append(lines[i].rstrip())
                i += 1
            story.append(build_code_block("\n".join(code_lines), styles, clr, available_width))
            story.append(Spacer(1, 4))
            continue

        # Image ![alt](path)
        img_match = re.match(r"^!\[([^\]]*)\]\(([^)]+)\)$", stripped)
        if img_match:
            alt, src = img_match.group(1), img_match.group(2)
            img = _try_build_image(alt, src, available_width)
            if img:
                story.append(Spacer(1, 4))
                story.append(img)
                story.append(Spacer(1, 4))
            i += 1
            continue

        # Horizontal rule
        if stripped in ("---", "***", "___"):
            story.append(Spacer(1, 4))
            story.append(HRFlowable(
                width="100%", thickness=0.5,
                color=rlc.HexColor("#cccccc"), spaceAfter=4, spaceBefore=4,
            ))
            i += 1
            continue

        # H1
        if stripped.startswith("# ") and not stripped.startswith("## "):
            story.append(Spacer(1, 20))
            story.append(Paragraph(safe_xml(stripped[2:].strip()), styles["H1"]))
            i += 1
            continue

        # H2
        if stripped.startswith("## ") and not stripped.startswith("### "):
            story.append(Paragraph(safe_xml(stripped[3:].strip()), styles["H2"]))
            story.append(HRFlowable(
                width="100%", thickness=0.8,
                color=clr["primary"], spaceAfter=6, spaceBefore=1,
            ))
            i += 1
            continue

        # H3
        if stripped.startswith("### ") and not stripped.startswith("#### "):
            story.append(Paragraph(safe_xml(stripped[4:].strip()), styles["H3"]))
            i += 1
            continue

        # H4
        if stripped.startswith("#### "):
            story.append(Paragraph(safe_xml(stripped[5:].strip()), styles["H4"]))
            i += 1
            continue

        # Blockquote
        if stripped.startswith("> ") or stripped == ">":
            quote_lines = []
            while i < len(lines):
                s = lines[i].strip()
                if s.startswith("> "):
                    quote_lines.append(s[2:])
                elif s == ">":
                    quote_lines.append("")
                else:
                    break
                i += 1
            story.append(build_blockquote(" ".join(quote_lines), styles, font_info, clr, available_width))
            story.append(Spacer(1, 4))
            continue

        # Table
        if stripped.startswith("|"):
            table_lines = []
            while i < len(lines):
                s = lines[i].strip()
                if s.startswith("|"):
                    table_lines.append(s)
                    i += 1
                else:
                    break
            rows = parse_md_table(table_lines)
            if rows:
                t = build_table(rows, styles, font_info, clr, available_width)
                if t:
                    story.append(t)
                    story.append(Spacer(1, 6))
            continue

        # Checkbox items
        if stripped.startswith("- [ ] ") or stripped.startswith("- [x] ") or stripped.startswith("- [X] "):
            text = stripped[6:].strip()
            marker = "\u2610 " if stripped.startswith("- [ ]") else "\u2611 "
            story.append(Paragraph(marker + safe_xml(text), styles["BulletItem"]))
            i += 1
            continue

        # Numbered list
        m_num = re.match(r"^(\d+)\.\s+(.+)$", stripped)
        if m_num:
            story.append(Paragraph(
                f"<b>{m_num.group(1)}.</b> " + safe_xml(m_num.group(2)),
                styles["NumberedItem"],
            ))
            i += 1
            continue

        # Bullet list
        if stripped.startswith("- ") or stripped.startswith("* "):
            story.append(Paragraph(
                "\u2022 " + safe_xml(stripped[2:].strip()),
                styles["BulletItem"],
            ))
            i += 1
            continue

        # Bold-colon lines (**Label:** value) -- render with bold styling
        if stripped.startswith("**") and ":" in stripped:
            text = safe_xml(stripped)
            story.append(Paragraph(text, styles["Normal"]))
            i += 1
            continue

        # Plain text
        story.append(Paragraph(safe_xml(stripped), styles["Normal"]))
        i += 1

    return story


# ---------------------------------------------------------------------------
# Reportlab engine -- document builder
# ---------------------------------------------------------------------------

def build_document(output_path: str, config: dict):
    from reportlab.lib.pagesizes import A4
    from reportlab.lib.units import mm
    from reportlab.platypus import BaseDocTemplate, Frame, PageTemplate

    page_width, page_height = A4
    margins = config.get("page", {}).get("margins", {})
    left = margins.get("left", 25) * mm
    right = margins.get("right", 20) * mm
    top = margins.get("top", 25) * mm
    bottom = margins.get("bottom", 25) * mm

    doc = BaseDocTemplate(
        output_path, pagesize=A4,
        leftMargin=left, rightMargin=right,
        topMargin=top, bottomMargin=bottom,
    )

    frame = Frame(
        left, bottom,
        page_width - left - right,
        page_height - top - bottom,
        id="main_frame",
    )

    page_template = PageTemplate(
        id="main", frames=[frame],
        onPage=lambda canvas, doc: None,
    )
    doc.addPageTemplates([page_template])

    available_width = page_width - left - right
    return doc, available_width


# ---------------------------------------------------------------------------
# Reportlab engine -- main conversion
# ---------------------------------------------------------------------------

def convert_reportlab(input_path: str, output_path: str, config: dict, quiet=False):
    """Convert MD -> PDF via reportlab."""
    try:
        from reportlab.platypus import Paragraph  # noqa: verify import
    except ImportError:
        print_failure("reportlab is not installed.\nInstall with: pip install reportlab")
        sys.exit(1)

    font_info = detect_fonts()
    register_detected_fonts(font_info)

    clr = _rl_colors(config)
    styles = build_styles(font_info, config)
    doc, available_width = build_document(output_path, config)

    md_text = Path(input_path).read_text(encoding="utf-8")
    story = md_to_story(md_text, styles, font_info, clr, available_width)

    footer_cfg = config.get("footer", {})
    footer_fmt = footer_cfg.get("format", "Page {page} of {total}")
    canvas_cls = _make_numbered_canvas_class(font_info["body"], footer_fmt)

    if footer_cfg.get("enabled", True):
        doc.build(story, canvasmaker=canvas_cls)
    else:
        doc.build(story)

    page_count = canvas_cls.__dict__.get("_page_count", 0)
    # Fallback: read page count from built doc
    if page_count == 0:
        try:
            page_count = doc.page
        except Exception:
            page_count = 0

    print_status(output_path, page_count, "reportlab", quiet)


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def main():
    args = parse_args()

    if not os.path.isfile(args.input):
        print_failure(f"File not found: {args.input}")
        sys.exit(1)

    config = load_config(args.config)

    try:
        if args.engine == "weasyprint":
            convert_weasyprint(args.input, args.output, config,
                               css_path=args.style,
                               pygments_theme=args.pygments_theme,
                               quiet=args.quiet)
        else:
            convert_reportlab(args.input, args.output, config, quiet=args.quiet)
    except Exception as exc:
        print_failure(str(exc))
        sys.exit(1)


if __name__ == "__main__":
    main()

/* === Page Setup === */
@page {
  size: A4;
  margin: 25mm 20mm 25mm 25mm;
  @bottom-center {
    content: "Page " counter(page) " of " counter(pages);
    font-size: 7pt;
    color: #888888;
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Noto Sans", sans-serif;
  }
}

/* === Base Typography === */
body {
  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Noto Sans", "Noto Sans CJK SC", sans-serif;
  font-size: 9pt;
  line-height: 1.4;
  color: #1a1a1a;
}

/* === Headings === */
h1, h2, h3, h4, h5, h6 { margin-top: 12pt; margin-bottom: 4pt; page-break-after: avoid; }
h1 { font-size: 20pt; color: #1a3a5c; text-align: center; margin-top: 18pt; margin-bottom: 10pt; }
h2 { font-size: 15pt; color: #1a3a5c; border-bottom: 1px solid #c0c0c0; padding-bottom: 3pt; }
h3 { font-size: 12pt; color: #2c5282; }
h4 { font-size: 10pt; color: #2c5282; }
h5 { font-size: 9pt; color: #4a6fa5; }
h6 { font-size: 9pt; color: #6b8cba; font-style: italic; }

/* === Paragraphs & Links === */
p { margin: 4pt 0; }
a { color: #2b6cb0; text-decoration: underline; }
@media print { a { text-decoration: none; } }

/* === Tables === */
table {
  width: 100%;
  border-collapse: collapse;
  margin: 8pt 0;
  font-size: 8.5pt;
  page-break-inside: avoid;
}
th, td { border: 0.5px solid #c0c0c0; padding: 3px 4px; text-align: left; }
th { background-color: #1a3a5c; color: #ffffff; font-weight: bold; }
tr:nth-child(even) { background-color: #f0f4f8; }
tr:nth-child(odd) { background-color: #ffffff; }

/* === Code Blocks === */
pre { page-break-inside: avoid; margin: 6pt 0; }
pre code {
  display: block;
  background: #f0f0f0;
  padding: 6px 8px;
  border: 0.5px solid #d0d0d0;
  border-radius: 2px;
  font-family: "SFMono-Regular", "Cascadia Code", "Fira Code", Menlo, Consolas, monospace;
  font-size: 8pt;
  line-height: 1.35;
  white-space: pre-wrap;
  word-wrap: break-word;
  color: inherit;
  font-weight: normal;
}

/* === Inline Code === */
code {
  background: #f0f0f0;
  padding: 1px 3px;
  border-radius: 2px;
  font-family: "SFMono-Regular", Menlo, Consolas, monospace;
  font-size: 8.5pt;
  color: #c53030;
  font-weight: bold;
}

/* === Blockquotes === */
blockquote {
  border-left: 3px solid #3182ce;
  background: #f5f5f5;
  padding: 6px 10px;
  margin: 6pt 0;
  font-style: italic;
  color: #4a4a4a;
  page-break-inside: avoid;
}
blockquote p { margin: 2pt 0; }

/* === Lists === */
ul, ol { margin: 4pt 0; padding-left: 18pt; }
ul ul, ol ol, ul ol, ol ul { padding-left: 14pt; }
ul ul ul, ol ol ol, ul ul ol, ol ol ul,
ul ol ul, ol ul ol, ul ol ol, ol ul ul { padding-left: 12pt; }
li { margin-bottom: 2pt; }

/* === Task Lists === */
li input[type="checkbox"] { margin-right: 4px; vertical-align: middle; }
li.task-list-item { list-style-type: none; margin-left: -18pt; }

/* === Horizontal Rules === */
hr { border: none; border-top: 0.5px solid #cccccc; margin: 10pt 0; }

/* === Images === */
img { max-width: 100%; height: auto; }

/* === Pygments Syntax Highlighting === */
.highlight .k, .highlight .kn, .highlight .kd,
.highlight .kc, .highlight .kr, .highlight .kt { color: #d73a49; font-weight: bold; }

.highlight .s, .highlight .s1, .highlight .s2, .highlight .sb,
.highlight .sc, .highlight .sd, .highlight .se, .highlight .sh,
.highlight .sx, .highlight .si, .highlight .sr { color: #032f62; }

.highlight .n, .highlight .na, .highlight .nc, .highlight .nd,
.highlight .ne, .highlight .ni, .highlight .nl, .highlight .nn,
.highlight .nt, .highlight .nv, .highlight .p { color: #24292e; }

.highlight .c, .highlight .c1, .highlight .cm, .highlight .ch,
.highlight .cs, .highlight .cp, .highlight .cpf { color: #6a737d; font-style: italic; }

.highlight .o, .highlight .ow { color: #d73a49; }
.highlight .nb, .highlight .bp { color: #005cc5; }
.highlight .nf, .highlight .fm { color: #6f42c1; }

.highlight .mi, .highlight .mf, .highlight .mh,
.highlight .mo, .highlight .mb, .highlight .il { color: #005cc5; }

.highlight .w { color: transparent; }

{
  "page": {
    "size": "A4",
    "margins": { "top": 25, "right": 20, "bottom": 25, "left": 25 }
  },
  "fonts": {
    "body": "auto",
    "heading": "auto",
    "code": "monospace"
  },
  "colors": {
    "primary": "#1a3a5c",
    "secondary": "#2c5282",
    "text": "#1a1a1a",
    "code_bg": "#f0f0f0",
    "header_bg": "#1a3a5c",
    "header_fg": "#ffffff",
    "quote_bg": "#f5f5f5",
    "border": "#3182ce",
    "light_bg": "#f0f4f8"
  },
  "footer": {
    "enabled": true,
    "format": "Page {page} of {total}"
  },
  "code": {
    "theme": "github",
    "font_size": 8
  },
  "typography": {
    "body_size": 9,
    "h1_size": 18,
    "h2_size": 14,
    "h3_size": 12,
    "h4_size": 10,
    "line_height": 1.4
  }
}