#!/usr/bin/env bash
# make.sh — minimax-pdf unified CLI
# Usage: bash make.sh <command> [options]
#
# Commands:
#   check                          Verify all dependencies
#   fix                            Auto-install missing dependencies
#   run   --title T --type TYPE    Full pipeline → output.pdf
#         --out FILE               Output path (default: output.pdf)
#         --author A --date D
#         --subtitle S
#         --abstract A             Optional abstract text for cover
#         --cover-image URL        Optional cover image URL/path
#         --content FILE           Path to content.json (optional)
#   demo                           Build a full-featured demo to demo.pdf
#
# Document types:
#   report proposal resume portfolio academic general
#   minimal stripe diagonal frame editorial
#   magazine darkroom terminal poster
#
# Content block types:
#   h1 h2 h3 body bullet numbered callout table
#   image figure code math chart flowchart bibliography
#   divider caption pagebreak spacer
#
# Exit codes: 0 success, 1 usage error, 2 dep missing, 3 runtime error

set -euo pipefail
SCRIPTS="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
NODE="node"

# ── Auto-detect Python (cross-platform) ────────────────────────────────────────
detect_python() {
  local candidate

  # 1. PATH 中的 python3 / python（排除 Windows Store 空壳）
  for candidate in python3 python; do
    if command -v "$candidate" &>/dev/null \
       && "$candidate" -c "import sys; assert sys.version_info >= (3,9)" 2>/dev/null; then
      echo "$candidate"; return
    fi
  done

  # 2. Windows 常见安装路径（官方安装器 / Chocolatey / Scoop / Anaconda / Miniconda）
  local win_candidates=()
  # 官方安装器 — 当前用户
  for d in "/c/Users/$USER/AppData/Local/Programs/Python"/Python3*/; do
    [[ -x "${d}python.exe" ]] && win_candidates+=("${d}python.exe")
  done
  # 官方安装器 — 全局
  for d in "/c/Python3"*/ "/c/Program Files/Python3"*/; do
    [[ -x "${d}python.exe" ]] && win_candidates+=("${d}python.exe")
  done
  # Chocolatey
  [[ -x "/c/ProgramData/chocolatey/bin/python.exe" ]] && \
    win_candidates+=("/c/ProgramData/chocolatey/bin/python.exe")
  # Scoop
  [[ -x "/c/Users/$USER/scoop/apps/python/current/python.exe" ]] && \
    win_candidates+=("/c/Users/$USER/scoop/apps/python/current/python.exe")
  # Anaconda / Miniconda
  for d in "/c/Users/$USER/anaconda3" "/c/Users/$USER/miniconda3" \
           "/c/ProgramData/anaconda3" "/c/ProgramData/miniconda3"; do
    [[ -x "$d/python.exe" ]] && win_candidates+=("$d/python.exe")
  done

  for candidate in "${win_candidates[@]}"; do
    if "$candidate" -c "import sys; assert sys.version_info >= (3,9)" 2>/dev/null; then
      echo "$candidate"; return
    fi
  done

  # 3. macOS Homebrew
  for candidate in /opt/homebrew/bin/python3 /usr/local/bin/python3; do
    if [[ -x "$candidate" ]] \
       && "$candidate" -c "import sys; assert sys.version_info >= (3,9)" 2>/dev/null; then
      echo "$candidate"; return
    fi
  done

  # 未找到 — 返回空字符串，由调用方处理
  echo ""
}

PY="$(detect_python)"

# ── Interactive prompt helper ──────────────────────────────────────────────────
# 询问用户选择：自动安装 or 手动安装
# Usage: ask_install "Python" → sets REPLY to "auto" or "manual" or "skip"
ask_install() {
  local dep_name="$1"
  echo ""
  bold  "  $dep_name is not installed. What would you like to do?"
  echo  "    [1] Auto-install (let this script install it for you)"
  echo  "    [2] Manual install (show me the instructions, I'll do it myself)"
  echo  "    [3] Skip (continue without it)"
  echo  ""
  read -rp "  Choose [1/2/3]: " choice
  case "$choice" in
    1) REPLY="auto" ;;
    2) REPLY="manual" ;;
    *) REPLY="skip" ;;
  esac
}

# ── Auto-install helpers ───────────────────────────────────────────────────────
install_python_auto() {
  bold "  Attempting to install Python..."
  if command -v winget &>/dev/null; then
    echo "  Using: winget install Python.Python.3.12"
    winget install Python.Python.3.12 --accept-package-agreements --accept-source-agreements 2>&1 | tail -5
  elif command -v choco &>/dev/null; then
    echo "  Using: choco install python3"
    choco install python3 -y 2>&1 | tail -5
  elif command -v scoop &>/dev/null; then
    echo "  Using: scoop install python"
    scoop install python 2>&1 | tail -5
  elif command -v brew &>/dev/null; then
    echo "  Using: brew install python3"
    brew install python3 2>&1 | tail -5
  elif command -v apt-get &>/dev/null; then
    echo "  Using: sudo apt-get install python3 python3-pip"
    sudo apt-get install -y python3 python3-pip 2>&1 | tail -5
  elif command -v dnf &>/dev/null; then
    echo "  Using: sudo dnf install python3 python3-pip"
    sudo dnf install -y python3 python3-pip 2>&1 | tail -5
  else
    red "  No supported package manager found. Please install manually."
    show_python_manual_instructions
    return 1
  fi
  echo ""
  green "  Python installed. Please restart your terminal and re-run this script."
  echo  "  (New PATH entries require a terminal restart to take effect)"
  return 0
}

show_python_manual_instructions() {
  echo ""
  bold  "  Install Python 3.9+ manually:"
  echo  "    Windows:  winget install Python.Python.3.12"
  echo  "              or https://www.python.org/downloads/"
  echo  "              (IMPORTANT: check 'Add Python to PATH' during install)"
  echo  "    macOS:    brew install python3"
  echo  "    Linux:    sudo apt install python3 python3-pip  (Debian/Ubuntu)"
  echo  "              sudo dnf install python3 python3-pip  (Fedora)"
  echo ""
}

install_node_auto() {
  bold "  Attempting to install Node.js..."
  if command -v winget &>/dev/null; then
    echo "  Using: winget install OpenJS.NodeJS.LTS"
    winget install OpenJS.NodeJS.LTS --accept-package-agreements --accept-source-agreements 2>&1 | tail -5
  elif command -v choco &>/dev/null; then
    echo "  Using: choco install nodejs-lts"
    choco install nodejs-lts -y 2>&1 | tail -5
  elif command -v scoop &>/dev/null; then
    echo "  Using: scoop install nodejs-lts"
    scoop install nodejs-lts 2>&1 | tail -5
  elif command -v brew &>/dev/null; then
    echo "  Using: brew install node"
    brew install node 2>&1 | tail -5
  elif command -v apt-get &>/dev/null; then
    echo "  Using: sudo apt-get install nodejs npm"
    sudo apt-get install -y nodejs npm 2>&1 | tail -5
  else
    red "  No supported package manager found. Please install manually."
    show_node_manual_instructions
    return 1
  fi
  echo ""
  green "  Node.js installed. Please restart your terminal and re-run this script."
  return 0
}

show_node_manual_instructions() {
  echo ""
  bold  "  Install Node.js 18+ manually:"
  echo  "    Windows:  winget install OpenJS.NodeJS.LTS"
  echo  "              or https://nodejs.org/en/download/"
  echo  "    macOS:    brew install node"
  echo  "    Linux:    sudo apt install nodejs npm  (Debian/Ubuntu)"
  echo  "              or https://nodejs.org/en/download/"
  echo ""
}

# ── Colour helpers ─────────────────────────────────────────────────────────────
red()    { printf '\033[0;31m%s\033[0m\n' "$*"; }
green()  { printf '\033[0;32m%s\033[0m\n' "$*"; }
yellow() { printf '\033[0;33m%s\033[0m\n' "$*"; }
bold()   { printf '\033[1m%s\033[0m\n' "$*"; }

# ── check ──────────────────────────────────────────────────────────────────────
cmd_check() {
  local ok=true
  bold "Checking dependencies..."

  # Python
  if [[ -n "$PY" ]] && $PY -c "import sys" 2>/dev/null; then
    green "  ✓ python ($PY) $($PY --version 2>&1 | awk '{print $2}')"
  else
    red   "  ✗ Python 3.9+ not found"
    ask_install "Python"
    case "$REPLY" in
      auto)   install_python_auto; exit $? ;;
      manual) show_python_manual_instructions; exit 2 ;;
      *)      yellow "  Skipped Python — PDF generation will not work without it." ;;
    esac
    ok=false
  fi

  # reportlab
  if [[ -n "$PY" ]] && $PY -c "import reportlab" 2>/dev/null; then
    green "  ✓ reportlab"
  else
    yellow "  ⚠ reportlab not installed  (run: make.sh fix)"
    ok=false
  fi

  # pypdf
  if [[ -n "$PY" ]] && $PY -c "import pypdf" 2>/dev/null; then
    green "  ✓ pypdf"
  else
    yellow "  ⚠ pypdf not installed  (run: make.sh fix)"
    ok=false
  fi

  # Node.js
  if command -v node &>/dev/null; then
    green "  ✓ node $(node --version)"
  else
    red   "  ✗ Node.js not found"
    ask_install "Node.js"
    case "$REPLY" in
      auto)   install_node_auto; exit $? ;;
      manual) show_node_manual_instructions; exit 2 ;;
      *)      yellow "  Skipped Node.js — cover rendering will not work without it." ;;
    esac
    ok=false
  fi

  # Playwright + Browser (prefer local Chrome/Edge)
  local browser_found=false
  if node -e "
    const pw = (() => { try { return require('playwright'); } catch(_) {
      const {execSync} = require('child_process');
      try { return require(execSync('npm root -g').toString().trim()+'/playwright'); } catch(_) { return null; }
    }})();
    if (!pw) process.exit(1);
    (async () => {
      for (const ch of ['chrome','msedge','chromium']) {
        try { const b = await pw.chromium.launch({channel:ch}); await b.close(); console.log(ch); process.exit(0); } catch(_) {}
      }
      try { const b = await pw.chromium.launch(); await b.close(); console.log('bundled-chromium'); process.exit(0); } catch(_) {}
      process.exit(1);
    })();
  " 2>/dev/null; then
    green "  ✓ playwright + browser detected"
    browser_found=true
  fi
  if ! $browser_found; then
    yellow "  ⚠ playwright or browser not found  (run: make.sh fix)"
    ok=false
  fi

  # matplotlib (optional)
  if [[ -n "$PY" ]] && $PY -c "import matplotlib" 2>/dev/null; then
    green "  ✓ matplotlib (math, chart, flowchart blocks enabled)"
  else
    yellow "  ⚠ matplotlib not installed — math/chart/flowchart blocks degrade to text  (run: make.sh fix)"
  fi

  if $ok; then
    green "\nAll dependencies satisfied."
    exit 0
  else
    yellow "\nSome dependencies missing. Run: bash make.sh fix"
    exit 2
  fi
}

# ── fix ────────────────────────────────────────────────────────────────────────
cmd_fix() {
  bold "Installing missing dependencies..."
  local rc=0

  # Python
  if [[ -n "$PY" ]] && $PY -c "import sys" 2>/dev/null; then
    green "  ✓ Python found ($PY)"
  else
    red   "  ✗ Python 3.9+ not found"
    ask_install "Python"
    case "$REPLY" in
      auto)
        install_python_auto || rc=2
        if [[ $rc -ne 0 ]]; then
          yellow "  Auto-install may have failed. Please restart terminal and re-run."
          exit $rc
        fi
        # Re-detect after install
        PY="$(detect_python)"
        if [[ -z "$PY" ]]; then
          yellow "  Python still not detected. Please restart terminal and re-run: bash make.sh fix"
          exit 2
        fi
        ;;
      manual)
        show_python_manual_instructions
        echo "  After installing Python, re-run: bash make.sh fix"
        exit 2
        ;;
      *)
        yellow "  Skipped Python — cannot install Python packages."
        rc=2
        ;;
    esac
  fi

  # Python packages
  if [[ -n "$PY" ]] && $PY -c "import sys" 2>/dev/null; then
    $PY -m pip install --break-system-packages -q reportlab pypdf matplotlib 2>/dev/null \
      || $PY -m pip install -q reportlab pypdf matplotlib 2>/dev/null \
      || { yellow "  pip install failed — try: $PY -m pip install reportlab pypdf matplotlib"; rc=3; }
    green "  ✓ Python packages installed (reportlab, pypdf, matplotlib)"
  fi

  # Node.js
  if ! command -v node &>/dev/null; then
    red   "  ✗ Node.js not found"
    ask_install "Node.js"
    case "$REPLY" in
      auto)
        install_node_auto || rc=2
        if [[ $rc -ne 0 ]]; then
          yellow "  Auto-install may have failed. Please restart terminal and re-run."
          exit $rc
        fi
        ;;
      manual)
        show_node_manual_instructions
        echo "  After installing Node.js, re-run: bash make.sh fix"
        exit 2
        ;;
      *)
        yellow "  Skipped Node.js — cover rendering will not work."
        rc=2
        ;;
    esac
  fi

  # Playwright + Browser: prefer local Chrome/Edge, only download Chromium as last resort
  if command -v node &>/dev/null && command -v npm &>/dev/null; then
    # Ensure playwright is installed
    if ! node -e "require('playwright')" 2>/dev/null && \
       ! node -e "require(require('child_process').execSync('npm root -g').toString().trim()+'/playwright')" 2>/dev/null; then
      npm install -g playwright --silent 2>/dev/null || { yellow "  playwright npm install failed"; rc=3; }
    fi

    # Check if local Chrome or Edge is available — skip Chromium download if so
    local has_local_browser=false
    for ch in chrome msedge; do
      if node -e "
        const pw = (() => { try { return require('playwright'); } catch(_) {
          try { return require(require('child_process').execSync('npm root -g').toString().trim()+'/playwright'); } catch(_) { return null; }
        }})();
        if (!pw) process.exit(1);
        pw.chromium.launch({channel:'$ch'}).then(b => b.close().then(() => process.exit(0))).catch(() => process.exit(1));
      " 2>/dev/null; then
        green "  ✓ Local browser detected ($ch) — skipping Chromium download"
        has_local_browser=true
        break
      fi
    done

    if ! $has_local_browser; then
      yellow "  No local Chrome/Edge found — downloading Chromium..."
      npx playwright install chromium --silent 2>/dev/null && \
        green "  ✓ Playwright Chromium installed" || \
        { yellow "  Chromium install failed — install Chrome or Edge manually"; rc=3; }
    fi
  else
    yellow "  npm not found — cannot install Playwright automatically"
    rc=2
  fi

  if [[ $rc -eq 0 ]]; then
    green "\nAll dependencies installed. Run: bash make.sh check"
  fi
  exit $rc
}

# ── run ────────────────────────────────────────────────────────────────────────
cmd_run() {
  # Pre-flight: ensure critical deps exist before doing any work
  if [[ -z "$PY" ]] || ! $PY -c "import sys" 2>/dev/null; then
    red "Error: Python 3.9+ is required but not found."
    echo "Run: bash make.sh check   (to diagnose and install)"
    exit 2
  fi
  if ! command -v node &>/dev/null; then
    red "Error: Node.js is required but not found."
    echo "Run: bash make.sh check   (to diagnose and install)"
    exit 2
  fi

  local title="Untitled Document"
  local type="general"
  local author=""
  local date=""
  local subtitle=""
  local abstract=""
  local cover_image=""
  local accent=""
  local cover_bg=""
  local content_file=""
  local out="output.pdf"
  local workdir
  workdir="$(mktemp -d)"

  # Parse options
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --title)        title="$2";        shift 2 ;;
      --type)         type="$2";         shift 2 ;;
      --author)       author="$2";       shift 2 ;;
      --date)         date="$2";         shift 2 ;;
      --subtitle)     subtitle="$2";     shift 2 ;;
      --abstract)     abstract="$2";     shift 2 ;;
      --cover-image)  cover_image="$2";  shift 2 ;;
      --accent)       accent="$2";       shift 2 ;;
      --cover-bg)     cover_bg="$2";     shift 2 ;;
      --content)      content_file="$2"; shift 2 ;;
      --out)          out="$2";          shift 2 ;;
      *) echo "Unknown option: $1"; exit 1 ;;
    esac
  done

  bold "Building: $title"
  echo "  Type    : $type"
  echo "  Output  : $out"

  # Step 1: tokens
  echo ""
  bold "Step 1/4  Generating design tokens..."
  local accent_args=()
  [[ -n "$accent"   ]] && accent_args+=(--accent   "$accent")
  [[ -n "$cover_bg" ]] && accent_args+=(--cover-bg "$cover_bg")
  $PY "$SCRIPTS/palette.py" \
    --title "$title" --type "$type" \
    --author "$author" --date "$date" \
    --out "$workdir/tokens.json" \
    "${accent_args[@]+"${accent_args[@]}"}"

  # Inject optional cover fields into tokens.json
  if [[ -n "$abstract" || -n "$cover_image" ]]; then
    PDF_ABSTRACT="$abstract" PDF_COVER_IMAGE="$cover_image" PDF_TOKENS="$workdir/tokens.json" \
    $PY - <<'PYEOF'
import json, os
with open(os.environ["PDF_TOKENS"]) as f:
    t = json.load(f)
abstract = os.environ.get("PDF_ABSTRACT", "")
cover_image = os.environ.get("PDF_COVER_IMAGE", "")
if abstract:
    t["abstract"] = abstract
if cover_image:
    t["cover_image"] = cover_image
with open(os.environ["PDF_TOKENS"], "w") as f:
    json.dump(t, f, indent=2)
PYEOF
  fi

  cat "$workdir/tokens.json" | $PY -c "
import json,sys
t=json.load(sys.stdin)
print(f'  Mood    : {t[\"mood\"]}')
print(f'  Pattern : {t[\"cover_pattern\"]}')
print(f'  Fonts   : {t[\"font_display\"]} / {t[\"font_body\"]}')"

  # Step 2: cover HTML + render
  echo ""
  bold "Step 2/4  Rendering cover..."
  local subtitle_args=()
  [[ -n "$subtitle" ]] && subtitle_args=(--subtitle "$subtitle")
  $PY "$SCRIPTS/cover.py" \
    --tokens "$workdir/tokens.json" \
    --out "$workdir/cover.html" \
    "${subtitle_args[@]+"${subtitle_args[@]}"}"

  $NODE "$SCRIPTS/render_cover.js" \
    --input "$workdir/cover.html" \
    --out   "$workdir/cover.pdf"
  green "  ✓ Cover rendered"

  # Step 3: body
  echo ""
  bold "Step 3/4  Rendering body pages..."
  if [[ -z "$content_file" ]]; then
    # Generate a minimal placeholder body
    cat > "$workdir/content.json" <<'JSON'
[
  {"type":"h1",   "text":"Document Body"},
  {"type":"body", "text":"Replace this with your content.json file using --content path/to/content.json"},
  {"type":"body", "text":"See the content.json schema in the skill README for the full list of supported block types: h1, h2, h3, body, bullet, callout, table, pagebreak, spacer."}
]
JSON
    content_file="$workdir/content.json"
    yellow "  No content file provided — using placeholder body."
  fi

  # Validate content.json before rendering
  if ! $PY -c "
import json, sys
try:
    with open(sys.argv[1], encoding='utf-8') as f:
        data = json.load(f)
    blocks = data if isinstance(data, list) else data.get('blocks', data.get('content', []))
    if not isinstance(blocks, list) or len(blocks) == 0:
        print('Error: content.json must contain a non-empty array of blocks', file=sys.stderr)
        sys.exit(1)
    print(f'  content.json validated: {len(blocks)} blocks')
except json.JSONDecodeError as e:
    print(f'Error: content.json is not valid JSON — {e}', file=sys.stderr)
    print(f'Hint: For long documents, write Markdown and use: make.sh reformat --input doc.md ...', file=sys.stderr)
    sys.exit(1)
" "$content_file"; then
    red "  ✗ content.json validation failed"
    exit 3
  fi

  $PY "$SCRIPTS/render_body.py" \
    --tokens  "$workdir/tokens.json" \
    --content "$content_file" \
    --out     "$workdir/body.pdf"
  green "  ✓ Body rendered"

  # Step 4: merge
  echo ""
  bold "Step 4/4  Merging and QA..."
  $PY "$SCRIPTS/merge.py" \
    --cover "$workdir/cover.pdf" \
    --body  "$workdir/body.pdf" \
    --out   "$out" \
    --title "$title"

  # Cleanup
  rm -rf "$workdir"
}

# ── fill ──────────────────────────────────────────────────────────────────────
cmd_fill() {
  local input="" out="" values="" data_file="" inspect_only=false

  while [[ $# -gt 0 ]]; do
    case "$1" in
      --input)   input="$2";     shift 2 ;;
      --out)     out="$2";       shift 2 ;;
      --values)  values="$2";    shift 2 ;;
      --data)    data_file="$2"; shift 2 ;;
      --inspect) inspect_only=true; shift ;;
      *) echo "Unknown option: $1"; exit 1 ;;
    esac
  done

  if [[ -z "$input" ]]; then
    echo "Usage: make.sh fill --input form.pdf [--out filled.pdf] [--values '{...}'] [--data values.json] [--inspect]"
    exit 1
  fi

  if $inspect_only || [[ -z "$out" && -z "$values" && -z "$data_file" ]]; then
    bold "Inspecting form fields in: $input"
    $PY "$SCRIPTS/fill_inspect.py" --input "$input"
    return
  fi

  bold "Filling form: $input → $out"

  local val_args=""
  if [[ -n "$values" ]];    then val_args="--values $values"; fi
  if [[ -n "$data_file" ]]; then val_args="--data $data_file"; fi

  $PY "$SCRIPTS/fill_write.py" --input "$input" --out "$out" $val_args
}

# ── reformat ───────────────────────────────────────────────────────────────────
cmd_reformat() {
  local input="" title="Reformatted Document" type="general"
  local author="" date="" out="output.pdf" subtitle=""
  local tmpdir
  tmpdir="$(mktemp -d)"

  while [[ $# -gt 0 ]]; do
    case "$1" in
      --input)    input="$2";    shift 2 ;;
      --title)    title="$2";    shift 2 ;;
      --type)     type="$2";     shift 2 ;;
      --author)   author="$2";   shift 2 ;;
      --date)     date="$2";     shift 2 ;;
      --subtitle) subtitle="$2"; shift 2 ;;
      --out)      out="$2";      shift 2 ;;
      *) echo "Unknown option: $1"; exit 1 ;;
    esac
  done

  if [[ -z "$input" ]]; then
    echo "Usage: make.sh reformat --input source.md --title T --type TYPE --out output.pdf"
    exit 1
  fi

  bold "Parsing: $input"
  $PY "$SCRIPTS/reformat_parse.py" --input "$input" --out "$tmpdir/content.json"
  green "  ✓ Parsed to content.json"

  bold "Applying design and building PDF..."
  local sub_args=()
  [[ -n "$subtitle" ]] && sub_args=(--subtitle "$subtitle")

  cmd_run \
    --title "$title" --type "$type" \
    --author "$author" --date "$date" \
    --content "$tmpdir/content.json" \
    --out "$out" \
    "${sub_args[@]+"${sub_args[@]}"}"

  rm -rf "$tmpdir"
}

# ── demo ──────────────────────────────────────────────────────────────────────
cmd_demo() {
  local tmpdir
  tmpdir="$(mktemp -d)"

  cat > "$tmpdir/content.json" <<'JSON'
[
  {"type":"h1",      "text":"Executive Summary"},
  {"type":"body",    "text":"This document was generated by minimax-pdf — a skill for creating visually polished PDFs. Every design decision is rooted in the document type and content, not a generic template."},
  {"type":"callout", "text":"Key insight: design tokens flow from palette.py through every renderer, keeping cover and body visually consistent."},

  {"type":"h1",      "text":"How It Works"},
  {"type":"h2",      "text":"The Token Pipeline"},
  {"type":"body",    "text":"The palette.py script infers a color palette and typography pair from the document type. These tokens are written to tokens.json and consumed by every downstream script."},
  {"type":"numbered","text":"palette.py generates color tokens, font selection, and the cover pattern"},
  {"type":"numbered","text":"cover.py renders the cover HTML using the selected pattern"},
  {"type":"numbered","text":"render_cover.js uses Playwright to convert the HTML cover to PDF"},
  {"type":"numbered","text":"render_body.py builds inner pages from content.json using ReportLab"},
  {"type":"numbered","text":"merge.py combines cover + body and runs final QA checks"},

  {"type":"h2",      "text":"Cover Patterns"},
  {"type":"table",
    "headers": ["Pattern",      "Document type",    "Visual character"],
    "rows": [
      ["fullbleed",   "report, general",   "Deep background · dot-grid texture"],
      ["split",       "proposal",          "Left dark panel · right dot-grid"],
      ["typographic", "resume, academic",  "Oversized display type · first-word accent"],
      ["atmospheric", "portfolio",         "Dark bg · radial glow · dot-grid"],
      ["magazine",    "magazine",          "Cream bg · centered · hero image"],
      ["darkroom",    "darkroom",          "Navy bg · centered · grayscale image"],
      ["terminal",    "terminal",          "Near-black · grid lines · monospace"],
      ["poster",      "poster",            "White · thick sidebar · oversized title"]
    ]
  },

  {"type":"h1",      "text":"Data Visualisation"},
  {"type":"h2",      "text":"Performance Metrics (Chart)"},
  {"type":"body",    "text":"Charts are rendered natively using matplotlib with a color palette derived from the document accent. No external chart services or image files required."},
  {"type":"chart",
    "chart_type": "bar",
    "title":      "Quarterly Performance",
    "labels":     ["Q1", "Q2", "Q3", "Q4"],
    "datasets": [
      {"label": "Revenue",  "values": [120, 145, 132, 178]},
      {"label": "Expenses", "values": [95,  108, 99,  122]}
    ],
    "y_label": "USD (thousands)",
    "caption": "Quarterly revenue vs. expenses"
  },

  {"type":"h2",      "text":"Market Share (Pie Chart)"},
  {"type":"chart",
    "chart_type": "pie",
    "labels":     ["Product A", "Product B", "Product C", "Other"],
    "datasets":   [{"values": [42, 28, 18, 12]}],
    "caption":    "Annual market share by product line"
  },

  {"type":"pagebreak"},

  {"type":"h1",      "text":"Mathematics"},
  {"type":"body",    "text":"Display math is rendered via matplotlib mathtext — no LaTeX binary installation required. Inline references use standard [N] notation in body text."},
  {"type":"math",    "text":"E = mc^2",                              "label":"(1)"},
  {"type":"math",    "text":"\\int_0^\\infty e^{-x^2}\\,dx = \\frac{\\sqrt{\\pi}}{2}", "label":"(2)"},
  {"type":"math",    "text":"\\sum_{n=1}^{\\infty} \\frac{1}{n^2} = \\frac{\\pi^2}{6}", "caption":"Basel problem (Euler, 1734)"},

  {"type":"h1",      "text":"Process Flow"},
  {"type":"body",    "text":"Flowcharts are drawn directly using matplotlib patches — no Graphviz or external tools needed. Supported node shapes: rect, diamond, oval, parallelogram."},
  {"type":"flowchart",
    "nodes": [
      {"id":"start",  "label":"Start",             "shape":"oval"},
      {"id":"input",  "label":"Receive Input",      "shape":"parallelogram"},
      {"id":"valid",  "label":"Valid?",             "shape":"diamond"},
      {"id":"proc",   "label":"Process Data",       "shape":"rect"},
      {"id":"err",    "label":"Return Error",        "shape":"rect"},
      {"id":"out",    "label":"Return Result",       "shape":"parallelogram"},
      {"id":"end",    "label":"End",                "shape":"oval"}
    ],
    "edges": [
      {"from":"start", "to":"input"},
      {"from":"input", "to":"valid"},
      {"from":"valid", "to":"proc",  "label":"Yes"},
      {"from":"valid", "to":"err",   "label":"No"},
      {"from":"proc",  "to":"out"},
      {"from":"err",   "to":"end"},
      {"from":"out",   "to":"end"}
    ],
    "caption": "Data validation and processing flow"
  },

  {"type":"h1",      "text":"Code Example"},
  {"type":"code",    "language":"python",
    "text":"# Design token pipeline\ntokens = palette.build_tokens(\n    title=\"Annual Report\",\n    doc_type=\"report\",\n    author=\"J. Smith\",\n    date=\"March 2026\",\n)\nhtml = cover.render(tokens)\npdf  = render_cover(html)"},

  {"type":"h1",      "text":"Design Principles"},
  {"type":"body",    "text":"The aesthetic system is documented in design/design.md. The core rule: every design decision must be rooted in the document content and purpose. A color chosen because it fits the content will always outperform a color chosen because it seems safe."},
  {"type":"h2",      "text":"Restraint over decoration"},
  {"type":"body",    "text":"The page is done when there is nothing left to remove. Accent color appears on section rules only — not on headings, not on bullets. No card components, no drop shadows."},
  {"type":"callout", "text":"A PDF passes the quality bar when a designer would not be embarrassed to hand it to a client."},

  {"type":"pagebreak"},
  {"type":"bibliography",
    "title": "References",
    "items": [
      {"id":"1","text":"Bringhurst, R. (2004). The Elements of Typographic Style (3rd ed.). Hartley & Marks."},
      {"id":"2","text":"Cairo, A. (2016). The Truthful Art: Data, Charts, and Maps for Communication. New Riders."},
      {"id":"3","text":"Hochuli, J. & Kinross, R. (1996). Designing Books: Practice and Theory. Hyphen Press."}
    ]
  }
]
JSON

  cmd_run \
    --title   "minimax-pdf demo" \
    --type    "report" \
    --author  "minimax-pdf skill" \
    --date    "$(date '+%B %Y')" \
    --subtitle "A demonstration of the token-based design pipeline" \
    --content "$tmpdir/content.json" \
    --out     "demo.pdf"

  rm -rf "$tmpdir"
}

# ── dispatch ───────────────────────────────────────────────────────────────────
main() {
  if [[ $# -lt 1 ]]; then
    bold "minimax-pdf — make.sh"
    echo ""
    echo "Usage: bash make.sh <command> [options]"
    echo ""
    echo "Commands:"
    echo "  check                             Verify all dependencies"
    echo "  fix                               Auto-install missing deps"
    echo "  run    --title T --type TYPE      CREATE: full pipeline → PDF"
    echo "         [--author A] [--date D] [--subtitle S]"
    echo "         [--abstract A] [--cover-image URL]"
    echo "         [--accent #HEX] [--cover-bg #HEX]"
    echo "         [--content content.json] [--out output.pdf]"
    echo "  fill   --input f.pdf              FILL: inspect or fill form fields"
    echo "  reformat --input doc.md           REFORMAT: parse doc → apply design → PDF"
    echo "  demo                              Build a full-featured demo PDF"
    exit 0
  fi

  case "$1" in
    check)    cmd_check ;;
    fix)      cmd_fix   ;;
    run)      shift; cmd_run      "$@" ;;
    fill)     shift; cmd_fill     "$@" ;;
    reformat) shift; cmd_reformat "$@" ;;
    demo)     cmd_demo  ;;
    *)        echo "Unknown command: $1"; exit 1 ;;
  esac
}

main "$@"