"""
apply_edits_15.py — Web-Based Manuscript Edit Applicator
========================================================

VERSION: 15
PYTHON:  3.9+
DEPS:    Standard library only (no pip installs required).

WHAT THIS TOOL DOES
-------------------
Opens a local web UI in the browser where an author can:
  1. Point to a manuscript file (Markdown, plain text, etc.).
  2. Paste in a batch of EDIT||| and NOTE||| blocks produced by an
     AI editing prompt (style checker, beta reader, fact checker, etc.).
  3. Preview each proposed edit with surrounding context from the
     manuscript, toggling each between "Change" and "Ignore".
  4. Apply the selected edits in one operation, with automatic backup.
  5. Review a results page showing what was applied and what was skipped.
  6. Loop back to step 1 for additional passes or different files.

INTENDED WORKFLOW
-----------------
  The author runs four AI editing passes on each scene:
    Pass 1: Style Check     (house rules, formatting, em-dashes, etc.)
    Pass 2: Fact Check       (legal, military, geographic accuracy)
    Pass 3: Beta Reader      (continuity, pacing, character voice)
    Pass 4: Line Edit        (rhythm, word choice, cuts)

  Each pass produces output in EDIT||| and NOTE||| format.  The author
  copies that output, runs this tool, pastes it in, reviews each edit,
  applies the ones they agree with, and moves to the next pass.

INPUT FORMAT
------------
  The tool accepts two types of blocks, pasted into the Edits textarea:

  EDIT blocks (find-and-replace operations):
    EDIT|||exact old text|||exact new text|||reason for the change

    - The old text must match the manuscript exactly (character-for-character,
      including punctuation, whitespace, and line breaks).
    - The new text is the drop-in replacement.
    - The reason explains what's wrong (shown on the preview card).
    - Multi-line old/new text is supported.  The parser splits on EDIT|||
      markers, not on newlines, so line breaks within fields are preserved.
    - The reason may also span multiple lines.
    - Triple-pipe ||| is the field delimiter.  It must not appear in the
      old text, new text, or reason (extremely unlikely in prose).

  NOTE blocks (non-actionable observations):
    NOTE|||description of a structural or conceptual issue

    - Notes have no old/new text.  They appear as read-only blue cards
      on the preview screen and the results screen.
    - Use for pacing concerns, missing-content flags, or issues that
      require author judgment rather than a text swap.

  Anything that is not an EDIT||| or NOTE||| block is ignored.  Preamble
  text, blank lines, and commentary between blocks are silently skipped.

EDIT STATUSES
-------------
  When the tool reads the manuscript and checks each EDIT block:

    ready     — Old text found exactly once in the manuscript.  The edit
                can be applied.  Defaults to "Change" on the preview screen.
    not_found — Old text not found.  The manuscript may have been edited
                since the AI pass, or the old text was copied imprecisely.
                Defaults to "Ignore".  Cannot be applied.
    duplicate — Old text found more than once.  Ambiguous; the tool cannot
                determine which occurrence to replace.  Defaults to "Ignore".
    error     — Parse error (malformed EDIT block, too few ||| delimiters).
                Defaults to "Ignore".
    info      — A NOTE block.  Read-only.  Not applicable.

THREE-PAGE UI
-------------
  Page 1 — Configuration  (GET /)
    Fields:
      - Drafts Directory:  Full path to the folder containing manuscripts.
      - Backups Directory: Full path where timestamped backups are saved
                           before edits are applied.
      - Filename:          Name of the specific manuscript file to edit.
      - Edits:             Large textarea for pasting EDIT/NOTE blocks.
                           Always starts empty (paths are remembered).

    Buttons:
      - Exit:              Stop the server immediately, save nothing.
      - Save & Exit:       Save paths to config file, then stop.
      - Save & Preview:    Save paths, read the manuscript, parse edits,
                           redirect to the preview page.
      - Preview:           Read the manuscript, parse edits, redirect to
                           the preview page (without saving paths).

  Page 2 — Preview  (GET /preview)
    Shows every parsed EDIT and NOTE as a card:
      - EDIT cards show a Change/Ignore toggle, the old text (red), the
        new text (green), surrounding context lines from the manuscript
        (blue, italic), and the reason.  "Ready" edits default to Change.
        "Not Found", "Ambiguous", and "Error" edits default to Ignore
        with the Change button disabled.
      - NOTE cards show the reason text with a blue "Note" badge.
        No toggle (they are informational only).
    Summary bar shows counts: ready, not found, ambiguous, errors, notes.

    Buttons:
      - Back:              Return to the configuration page.
      - Apply Selected:    Confirm, then apply all "Change" edits.

  Page 3 — Results  (GET /results)
    Shows what happened after Apply:
      - Summary: X applied, Y not applied, Z notes.
      - Cards for every EDIT that was NOT applied (skipped by user,
        not found, ambiguous, or error), plus all NOTE cards.
      - If everything was applied and there are no notes, shows a
        success message.

    Buttons:
      - Back:              Return to config page for another pass.
      - Exit:              Shut down the server.

APPLY SAFETY FEATURES
---------------------
  - Backup before apply:  The original file is copied to the backups
    directory with a timestamp suffix (e.g., Ch13-S3_20260430_143022.md)
    before any edits are written.  If no backups directory is configured,
    a warning is printed but the apply proceeds.

  - Re-read before apply:  The manuscript file is re-read from disk at
    the moment of applying, not from the cached copy loaded at preview
    time.  This means the user can edit the file externally (in their
    text editor) while the preview screen is open, and the edits will
    be applied against the current version of the file.

  - Re-analyze before apply:  After re-reading, all edits are re-checked
    against the fresh file contents.  If the user manually fixed an issue
    while the preview was open, that edit's old text will no longer be
    found, its status will change to "not_found", and it will be silently
    skipped.  The results page will show it as "Not Found".

  - First-occurrence replacement:  Each edit replaces only the first
    occurrence of the old text (using str.replace with count=1).  This
    is why "duplicate" edits are blocked — if the old text appears more
    than once, the tool cannot know which occurrence to replace.

CONFIG PERSISTENCE
------------------
  Config file: apply_edits_config.json  (same directory as this script)
  Saved keys:  drafts_dir, backups_dir, filename, edits_text
  The config file is written atomically (write to .tmp, then os.replace)
  to prevent corruption from interrupted writes.
  The edits_text field is saved to config but the textarea always starts
  empty when the config page loads — paths persist, edits don't.

HTTP ENDPOINTS
--------------
  GET  /          Config page (Page 1).
  GET  /preview   Preview page (Page 2).  Redirects to / if no edits parsed.
  GET  /results   Results page (Page 3).  Redirects to / if no edits parsed.
  POST /config    Receives JSON with form fields + action string.
                  Actions: "exit", "save_exit", "save_preview", "preview".
  POST /apply     Receives JSON {"indices": [0, 1, 3, ...]}.
                  Backs up, re-reads, re-analyzes, applies, writes.
  POST /shutdown  Shuts down the server (used by the Exit button on
                  the results page).

SERVER ARCHITECTURE
-------------------
  - Runs on 127.0.0.1:8767 (localhost only, not accessible from network).
  - Uses Python's ThreadingHTTPServer in a daemon thread.
  - Opens the default browser automatically on startup.
  - Mutable state (parsed_edits, manuscript_text, applied_indices) is
    shared between request handlers via closure variables in serve().
  - The server shuts down when the user clicks Exit, Save & Exit, or
    when the main thread's join() returns.
  - No external dependencies.  No frameworks.  No npm.  Just stdlib.

CSS THEME
---------
  Dark theme with CSS custom properties:
    --bg:      #1a1a2e    (page background)
    --surface: #22223a    (card/bar background)
    --border:  #333355    (borders)
    --text:    #e0e0e0    (body text)
    --muted:   #888       (hints, secondary text)
    --accent:  #5b8af5    (buttons, note badges, context lines)
    --danger:  #e05555    (errors, old text, Ignore toggle)
    --warn:    #d4a843    (warnings, ambiguous)
    --success: #4caf50    (ready, new text, Change toggle, applied count)

USAGE
-----
  python apply_edits_15.py

  The browser opens to the config page.  Set the drafts and backups
  directories (only needed once — they persist).  Enter the filename.
  Paste the EDIT/NOTE output from your AI editing pass.  Click Preview.
  Toggle edits.  Click Apply Selected.  Review results.  Click Back
  for another pass or Exit to quit.

COMPANION PROMPTS
-----------------
  This tool is designed to consume output from these AI editing prompts:
    - Style_Check_Prompt.md        (Pass 1)
    - Fact_Checker_Prompt.md       (Pass 2)
    - Beta_Reader_Prompt.md        (Pass 3)
    - Line_Editor_Prompt.md        (Pass 4)
  Each prompt instructs the AI to output EDIT||| and NOTE||| blocks
  that can be pasted directly into this tool.

CHANGE LOG
----------
  v1-v13:  Initial development, CLI-based, iterative refinement.
  v14:     Web UI with three-page flow (config, preview, results).
           Change/Ignore toggles.  Context lines in blue.  NOTE blocks.
           Re-read-on-apply safety.  Multi-line edit parsing.
           Edits textarea starts empty each session.
  v15:     Documentation pass.  No functional changes from v14.
           All comments and docstrings updated to be self-contained
           so future development can proceed from this file alone.
"""

import os
import sys
import webbrowser
import threading
import json as _json
import shutil
import tempfile
from pathlib import Path
from datetime import datetime
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer


# ── Defaults & Constants ──────────────────────────────────────────────────────
# These defaults are used when apply_edits_config.json doesn't exist or is
# corrupt.  After the first Save, the config file takes over for paths.
# The edits textarea always starts empty regardless of what's in the config.

DEFAULT_DRAFTS_DIR  = ""     # Path to folder containing manuscript files
DEFAULT_BACKUPS_DIR = ""     # Path to folder for timestamped backups
DEFAULT_FILENAME    = ""     # Name of the manuscript file (not full path)
DEFAULT_EDITS_TEXT  = ""     # Pasted EDIT/NOTE blocks (always blank on load)

PORT        = 8767           # Local HTTP server port (localhost only)
CONFIG_FILE = Path(__file__).with_name("apply_edits_config.json")


# ── Config Persistence ────────────────────────────────────────────────────────
# The config file stores drafts_dir, backups_dir, filename, and edits_text
# as a JSON object in the same directory as this script.  It is written
# atomically (write to .tmp, then os.replace) so a crash during write
# cannot corrupt the file.  If the file is missing or corrupt, defaults
# are used and the user configures paths on first run.

def load_config() -> dict:
    """Load config from JSON file; return defaults if missing or corrupt.

    Returns a dict with keys: drafts_dir, backups_dir, filename, edits_text.
    Any missing keys in the JSON file fall back to DEFAULT_* constants.
    """
    try:
        with open(CONFIG_FILE, "r", encoding="utf-8") as fh:
            cfg = _json.load(fh)
        return {
            "drafts_dir":  cfg.get("drafts_dir",  DEFAULT_DRAFTS_DIR),
            "backups_dir": cfg.get("backups_dir", DEFAULT_BACKUPS_DIR),
            "filename":    cfg.get("filename",    DEFAULT_FILENAME),
            "edits_text":  cfg.get("edits_text",  DEFAULT_EDITS_TEXT),
        }
    except (FileNotFoundError, _json.JSONDecodeError, OSError):
        return {
            "drafts_dir":  DEFAULT_DRAFTS_DIR,
            "backups_dir": DEFAULT_BACKUPS_DIR,
            "filename":    DEFAULT_FILENAME,
            "edits_text":  DEFAULT_EDITS_TEXT,
        }


def save_config(cfg: dict) -> None:
    """Write config atomically: write to .tmp file, then os.replace.

    This prevents corruption if the process is killed mid-write.
    If the write fails, the old config file is preserved and a
    warning is printed to the console.
    """
    tmp_path = None
    try:
        fd, tmp_path = tempfile.mkstemp(dir=CONFIG_FILE.parent, suffix=".tmp")
        with os.fdopen(fd, "w", encoding="utf-8") as fh:
            _json.dump(cfg, fh, indent=2, ensure_ascii=False)
        os.replace(tmp_path, CONFIG_FILE)
        print(f"Config saved -> {CONFIG_FILE}")
    except OSError as exc:
        print(f"WARNING: Could not save config: {exc}")
        if tmp_path and os.path.exists(tmp_path):
            try:
                os.remove(tmp_path)
            except OSError:
                pass


# ── Edit Parsing & Analysis ────────────────────────────────────────────────────
# The parser handles two block types: EDIT||| and NOTE|||.
#
# EDIT blocks are split into three fields by |||:
#   EDIT|||old_text|||new_text|||reason
# Multi-line content is supported because the parser splits on the EDIT|||
# and NOTE||| markers (using regex), not on newlines.  Line breaks within
# any field are preserved exactly.
#
# NOTE blocks have a single field after the marker:
#   NOTE|||reason text (may span multiple lines)
#
# The parser returns a list of dicts, each with:
#   type:     "edit" or "note"
#   old:      exact text to find (empty for notes)
#   new:      replacement text (empty for notes)
#   reason:   explanation string (may contain newlines)
#   line_num: sequential block number (1-based, for display)
#   status:   "pending" (edits, before analysis), "info" (notes),
#             or "error" (malformed blocks)

def parse_edits(edits_text: str) -> list:
    """Parse EDIT||| and NOTE||| blocks from pasted text.

    Uses regex split on 'EDIT|||' and 'NOTE|||' markers to handle
    multi-line content within fields.  Returns a list of item dicts
    ready for analyze_edits().

    Block format:
      EDIT|||old text (may contain newlines)|||new text|||reason
      NOTE|||reason text (may span multiple lines)

    Returns: [{"type": "edit"|"note", "old": str, "new": str,
               "reason": str, "line_num": int, "status": str}, ...]
    """
    items = []

    # We need to find both EDIT||| and NOTE||| markers and process
    # them in order.  Split the text into tokens by finding each marker.
    import re
    # Split on EDIT||| or NOTE|||, keeping the delimiter.
    tokens = re.split(r'(EDIT\|\|\||NOTE\|\|\|)', edits_text)

    # tokens is: [preamble, 'EDIT|||', block1, 'NOTE|||', block2, ...]
    # Process pairs: (marker, block)
    block_num = 0
    i = 0
    while i < len(tokens):
        token = tokens[i]
        if token == 'EDIT|||':
            block_num += 1
            if i + 1 < len(tokens):
                block = tokens[i + 1]
                i += 2
            else:
                block = ""
                i += 1

            segments = block.split("|||")

            if len(segments) < 3:
                items.append({
                    "type": "edit",
                    "old": "", "new": "",
                    "reason": f"Parse error in edit block {block_num}: "
                              f"expected 3 fields separated by |||, "
                              f"got {len(segments)}",
                    "line_num": block_num, "status": "error"
                })
                continue

            old_text = segments[0]
            new_text = segments[1]
            reason   = "|||".join(segments[2:]).strip()
            reason = reason.rstrip("\n\r")

            items.append({
                "type": "edit",
                "old": old_text,
                "new": new_text,
                "reason": reason,
                "line_num": block_num,
                "status": "pending"
            })

        elif token == 'NOTE|||':
            block_num += 1
            if i + 1 < len(tokens):
                block = tokens[i + 1]
                i += 2
            else:
                block = ""
                i += 1

            reason = block.strip().rstrip("\n\r")
            if not reason:
                reason = "(empty note)"

            items.append({
                "type": "note",
                "old": "",
                "new": "",
                "reason": reason,
                "line_num": block_num,
                "status": "info"
            })

        else:
            # Preamble or inter-block text; skip.
            i += 1

    return items


def analyze_edits(manuscript_text: str, edits: list) -> list:
    """Check each EDIT block against the manuscript and set its status.

    Searches the manuscript for each edit's old text:
      - Found exactly once  -> status = "ready" (safe to apply)
      - Not found           -> status = "not_found" (text may have changed)
      - Found multiple times -> status = "duplicate" (ambiguous, blocked)
      - Already "error"      -> unchanged (parse failure)
      - Already "info"       -> unchanged (NOTE block, not applicable)

    This function is called twice:
      1. At preview time, against the cached manuscript.
      2. At apply time, against a fresh re-read of the file, to catch
         any manual edits the user made while the preview was open.

    Modifies the edits list in place and returns it.
    """
    for edit in edits:
        if edit["status"] in ("error", "info"):
            continue
        count = manuscript_text.count(edit["old"])
        if count == 0:
            edit["status"] = "not_found"
        elif count > 1:
            edit["status"] = "duplicate"
            edit["reason"] += f" (found {count} times -- ambiguous)"
        else:
            edit["status"] = "ready"
    return edits


def apply_selected_edits(manuscript_text: str, edits: list, indices: list) -> str:
    """Apply edits at the given indices to the manuscript text.

    For each index in the list:
      - Skip if out of range or status is not "ready".
      - Replace the FIRST occurrence of old text with new text.
        (Using str.replace with count=1 to avoid replacing duplicates.)

    Returns the modified manuscript text.  Does not write to disk —
    the caller handles file I/O.
    """
    for idx in indices:
        if idx < 0 or idx >= len(edits):
            continue
        edit = edits[idx]
        if edit["status"] != "ready":
            continue
        manuscript_text = manuscript_text.replace(edit["old"], edit["new"], 1)
    return manuscript_text


def resolve_filepath(drafts_dir: str, filename: str) -> Path:
    """Resolve the manuscript file path, trying extensions if needed.

    If the filename has no extension (no '.' in the name), the function
    tries appending '.md' first, then '.txt'.  This lets the user type
    just the stem (e.g., "Ch13-S3-Sunday-Torrance") without remembering
    the extension.

    Resolution order:
      1. drafts_dir / filename           (as given)
      2. drafts_dir / filename.md        (if no extension in filename)
      3. drafts_dir / filename.txt       (if no extension in filename)

    Returns the first Path that points to an existing file.
    If none exist, returns the original Path (drafts_dir / filename)
    so the caller can report a meaningful "file not found" error.
    """
    path = Path(drafts_dir) / filename
    if path.is_file():
        return path

    # Only try extensions if the filename has no extension.
    if '.' not in Path(filename).name:
        for ext in ('.md', '.txt'):
            candidate = Path(drafts_dir) / (filename + ext)
            if candidate.is_file():
                return candidate

    # Return the original path so the error message shows what was tried.
    return path


# ── CSS Theme ─────────────────────────────────────────────────────────────────
# Dark theme shared across all three pages.  Uses CSS custom properties
# so colors can be adjusted in one place.  The theme is designed to be
# easy on the eyes during extended editing sessions.
#
# Color roles:
#   --bg:      Page background (darkest)
#   --surface: Card and action bar background
#   --border:  Borders and separators
#   --text:    Primary text color
#   --muted:   Secondary text, hints, labels
#   --accent:  Buttons, note badges, context lines (blue)
#   --danger:  Errors, old text diff, Ignore toggle active (red)
#   --warn:    Warnings, ambiguous, skipped (amber)
#   --success: Ready, new text diff, Change toggle active, applied (green)

_CSS_VARS = """
  :root {
    --bg:      #1a1a2e;
    --surface: #22223a;
    --border:  #333355;
    --text:    #e0e0e0;
    --muted:   #888;
    --accent:  #5b8af5;
    --danger:  #e05555;
    --warn:    #d4a843;
    --success: #4caf50;
  }
  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto,
         Helvetica, Arial, sans-serif; background: var(--bg); color: var(--text);
         line-height: 1.55; }
  code, pre { font-family: 'SF Mono', 'Fira Code', Consolas, monospace; }
"""

_BTN_CSS = """
  .btn { padding: 0.55rem 1.4rem; border: none; border-radius: 6px;
         font-size: 0.9rem; font-weight: 600; cursor: pointer;
         transition: filter 0.15s; }
  .btn-run    { background: var(--accent); color: #fff; }
  .btn-save   { background: var(--accent); color: #fff; }
  .btn-cancel { background: transparent;   color: var(--muted);
                border: 1px solid var(--border); }
  .btn-danger { background: var(--danger); color: #fff; }
  .btn:hover     { filter: brightness(1.15); }
  .btn:disabled  { opacity: 0.4; cursor: default; filter: none; }
"""


# ── HTML Page Builders ────────────────────────────────────────────────────────
# Each function returns a complete HTML page as a string.  The pages use
# f-strings with doubled braces {{ }} for CSS/JS (Python f-string escaping).
# All user-provided text is HTML-escaped before embedding to prevent XSS.
#
# Page 1: build_config_html()   — Configuration form
# Page 2: build_preview_html()  — Edit preview with toggles and context
# Page 3: build_results_html()  — Post-apply summary

def build_config_html(cfg: dict) -> str:
    """Build Page 1: Configuration form.

    Fields: Drafts Directory, Backups Directory, Filename, Edits textarea.
    Paths are pre-filled from the saved config.  The Edits textarea always
    starts empty so the user pastes fresh edits each session.

    Buttons (sticky action bar at bottom):
      Exit:           POST /config action="exit" -> server shuts down.
      Save & Exit:    POST /config action="save_exit" -> save config, shut down.
      Save & Preview: POST /config action="save_preview" -> save, parse, preview.
      Preview:        POST /config action="preview" -> parse, preview (no save).

    The JavaScript getConfig() reads all four form fields and sends them
    as JSON to POST /config along with the action string.
    """
    drafts_val  = cfg["drafts_dir"].replace('"', '&quot;')
    backups_val = cfg["backups_dir"].replace('"', '&quot;')
    file_val    = cfg["filename"].replace('"', '&quot;')
    # Always start with an empty edits textarea so the user pastes
    # fresh edits each session.  Paths are preserved from config.
    edits_val   = ""

    return f"""<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Apply Edits -- Configuration</title>
<style>
{_CSS_VARS}
{_BTN_CSS}
  .page-wrap  {{ max-width: 900px; margin: 0 auto; padding: 2rem 1.5rem 140px; }}
  h1          {{ font-size: 1.5rem; font-weight: 700; margin-bottom: 0.25rem; }}
  .subtitle   {{ color: var(--muted); font-size: 0.9rem; margin-bottom: 2rem; }}
  .field      {{ margin-bottom: 1.2rem; }}
  .field label {{ display: block; font-size: 0.9rem; font-weight: 600;
                  margin-bottom: 0.3rem; }}
  .field .hint {{ font-size: 0.78rem; color: var(--muted); margin-bottom: 0.3rem; }}
  .field input {{ width: 100%; background: var(--bg); border: 1px solid var(--border);
                  border-radius: 6px; padding: 0.5rem 0.7rem; color: var(--text);
                  font-size: 0.85rem; font-family: monospace; }}
  .field input:focus {{ outline: none; border-color: var(--accent); }}
  .field textarea {{ width: 100%; background: var(--bg); border: 1px solid var(--border);
                     border-radius: 6px; padding: 0.5rem 0.7rem; color: var(--text);
                     font-size: 0.82rem; font-family: monospace; line-height: 1.5;
                     resize: vertical; }}
  .field textarea:focus {{ outline: none; border-color: var(--accent); }}
  .action-bar {{ position: fixed; bottom: 0; left: 0; right: 0;
                 background: var(--surface); border-top: 1px solid var(--border);
                 padding: 1rem 2rem; display: flex; align-items: center;
                 gap: 1rem; z-index: 20; }}
  .action-bar .hint {{ flex: 1; font-size: 0.82rem; color: var(--muted); }}
  .status-msg {{ position: fixed; bottom: 70px; left: 50%;
                 transform: translateX(-50%);
                 background: var(--surface); border: 1px solid var(--border);
                 border-radius: 8px; padding: 0.7rem 1.4rem;
                 font-size: 0.88rem; display: none; z-index: 30; }}
</style>
</head>
<body>

<div class="page-wrap">
  <h1>Apply Edits</h1>
  <p class="subtitle">Configure paths and paste edits, then click Preview to review changes.</p>

  <div class="field">
    <label>Drafts Directory</label>
    <div class="hint">Full path to the folder containing your manuscript files.</div>
    <input type="text" id="drafts-dir" value="{drafts_val}"
           placeholder="/path/to/drafts">
  </div>

  <div class="field">
    <label>Backups Directory</label>
    <div class="hint">Full path where backups will be saved before edits are applied.</div>
    <input type="text" id="backups-dir" value="{backups_val}"
           placeholder="/path/to/backups">
  </div>

  <div class="field">
    <label>Filename</label>
    <div class="hint">Name of the manuscript file (e.g. Ch13-S3-Sunday-Torrance.md).</div>
    <input type="text" id="filename" value="{file_val}"
           placeholder="chapter.md">
  </div>

  <div class="field">
    <label>Edits</label>
    <div class="hint">Paste EDIT||| formatted lines below. One edit per line.</div>
    <textarea id="edits-text" rows="16">{edits_val}</textarea>
  </div>
</div>

<div class="status-msg" id="status-msg"></div>

<div class="action-bar">
  <span class="hint">Settings saved to <code>apply_edits_config.json</code></span>
  <button class="btn btn-cancel" onclick="doAction('exit')">Exit</button>
  <button class="btn btn-save"   onclick="doAction('save_exit')">Save &amp; Exit</button>
  <button class="btn btn-save"   onclick="doAction('save_preview')">Save &amp; Preview</button>
  <button class="btn btn-run"    onclick="doAction('preview')">Preview</button>
</div>

<script>
  function getConfig() {{
    return {{
      drafts_dir:  document.getElementById('drafts-dir').value.trim(),
      backups_dir: document.getElementById('backups-dir').value.trim(),
      filename:    document.getElementById('filename').value.trim(),
      edits_text:  document.getElementById('edits-text').value,
    }};
  }}

  function showStatus(msg) {{
    const el = document.getElementById('status-msg');
    el.textContent = msg; el.style.display = 'block';
    setTimeout(() => {{ el.style.display = 'none'; }}, 4000);
  }}

  function doAction(action) {{
    const cfg = getConfig();
    cfg.action = action;
    fetch('/config', {{
      method:  'POST',
      headers: {{'Content-Type': 'application/json'}},
      body:    JSON.stringify(cfg)
    }})
    .then(r => r.json())
    .then(data => {{
      if (data.error) {{
        showStatus('Error: ' + data.error);
      }} else if (data.redirect) {{
        window.location.href = data.redirect;
      }} else {{
        if (action === 'save_exit') {{
          showStatus('Config saved. You may close this window.');
        }} else if (action === 'exit') {{
          showStatus('Exiting. You may close this window.');
        }}
      }}
    }})
    .catch(err => showStatus('Error: ' + err));
  }}
</script>
</body>
</html>"""


def build_preview_html(edits: list, filename: str,
                       manuscript_text: str) -> str:
    """Build Page 2: Edit preview with toggles and context lines.

    For each EDIT item, renders a card with:
      - Change/Ignore toggle (Change = green active, Ignore = red active).
        "Ready" edits default to Change.  Others default to Ignore with
        the Change button disabled.
      - Status badge (Ready / Not Found / Ambiguous / Error).
      - Reason text (may contain <br> for multi-line reasons).
      - OLD text in red, NEW text in green.
      - Context: the nearest non-blank line before and after the match,
        shown in blue italic.  Context is found by splitting the manuscript
        into lines, locating which lines the match spans, and searching
        backward/forward past blank lines.  Only shown for "ready" edits.

    For each NOTE item, renders a read-only card with:
      - Blue "Note" badge.
      - Reason text.
      - No toggle, no diff, no context.

    Summary bar shows counts of each status type.

    Buttons:
      Back:           Navigate to / (config page).
      Apply Selected: POST /apply with indices of all "Change" toggles.

    JavaScript:
      setToggle(idx, mode): Switches a card between Change and Ignore.
      applyEdits():         Collects active Change indices, confirms,
                            POSTs to /apply, redirects to /results.
    """
    rows = []
    for idx, edit in enumerate(edits):
        status = edit["status"]
        item_type = edit.get("type", "edit")

        reason_esc = (edit["reason"]
                      .replace('&', '&amp;')
                      .replace('<', '&lt;')
                      .replace('>', '&gt;')
                      .replace('\n', '<br>'))

        # NOTE items: read-only info cards, no toggle, no diff.
        if item_type == "note":
            rows.append(f"""
      <div class="edit-card note">
        <div class="edit-header">
          <span class="edit-num">#{idx + 1}</span>
          <span class="edit-status status-note">Note</span>
        </div>
        <div class="note-body">{reason_esc}</div>
      </div>""")
            continue

        # EDIT items: toggle, diff, context lines.
        if status == "ready":
            status_cls = "ready"
            status_label = "Ready"
        elif status == "not_found":
            status_cls = "not-found"
            status_label = "Not Found"
        elif status == "duplicate":
            status_cls = "duplicate"
            status_label = "Ambiguous"
        else:
            status_cls = "error"
            status_label = "Error"

        old_esc = (edit["old"]
                   .replace('&', '&amp;')
                   .replace('<', '&lt;')
                   .replace('>', '&gt;'))
        new_esc = (edit["new"]
                   .replace('&', '&amp;')
                   .replace('<', '&lt;')
                   .replace('>', '&gt;'))

        # Extract context lines from manuscript.
        ctx_before = ""
        ctx_after = ""
        if edit["old"] and edit["status"] == "ready":
            pos = manuscript_text.find(edit["old"])
            if pos >= 0:
                # Split entire manuscript into lines with positions.
                lines = manuscript_text.split('\n')
                # Find which line the match starts on.
                char_count = 0
                match_start_line = 0
                for i, line in enumerate(lines):
                    if char_count + len(line) >= pos:
                        match_start_line = i
                        break
                    char_count += len(line) + 1  # +1 for the \n

                # Find which line the match ends on.
                end_pos = pos + len(edit["old"])
                char_count = 0
                match_end_line = 0
                for i, line in enumerate(lines):
                    if char_count + len(line) >= end_pos:
                        match_end_line = i
                        break
                    char_count += len(line) + 1

                # Line before the match (skip blank lines).
                prev_line = ""
                for look_back in range(match_start_line - 1, -1, -1):
                    candidate = lines[look_back].strip()
                    if candidate:
                        prev_line = candidate
                        break
                if prev_line:
                    prev_esc = (prev_line
                                .replace('&', '&amp;')
                                .replace('<', '&lt;')
                                .replace('>', '&gt;'))
                    ctx_before = (f'<div class="ctx-line">'
                                  f'<code>{prev_esc}</code></div>')

                # Line after the match (skip blank lines).
                next_line = ""
                for look_fwd in range(match_end_line + 1, len(lines)):
                    candidate = lines[look_fwd].strip()
                    if candidate:
                        next_line = candidate
                        break
                if next_line:
                    next_esc = (next_line
                                .replace('&', '&amp;')
                                .replace('<', '&lt;')
                                .replace('>', '&gt;'))
                    ctx_after = (f'<div class="ctx-line">'
                                 f'<code>{next_esc}</code></div>')

        disabled = '' if status == 'ready' else 'disabled'
        change_active = 'active' if status == 'ready' else ''
        ignore_active = 'active' if status != 'ready' else ''

        rows.append(f"""
      <div class="edit-card {status_cls}">
        <div class="edit-header">
          <div class="toggle-group" data-idx="{idx}">
            <button class="toggle-btn toggle-change {change_active}"
                    {disabled} onclick="setToggle({idx},'change')">Change</button>
            <button class="toggle-btn toggle-ignore {ignore_active}"
                    onclick="setToggle({idx},'ignore')">Ignore</button>
          </div>
          <span class="edit-num">#{idx + 1}</span>
          <span class="edit-status status-{status_cls}">{status_label}</span>
          <span class="edit-reason">{reason_esc}</span>
        </div>
        <div class="edit-diff">
          {ctx_before}
          <div class="diff-old">
            <span class="diff-label">OLD:</span> <code>{old_esc}</code>
          </div>
          <div class="diff-new">
            <span class="diff-label">NEW:</span> <code>{new_esc}</code>
          </div>
          {ctx_after}
        </div>
      </div>""")

    total     = len(edits)
    ready     = sum(1 for e in edits if e["status"] == "ready")
    not_found = sum(1 for e in edits if e["status"] == "not_found")
    dupes     = sum(1 for e in edits if e["status"] == "duplicate")
    errors    = sum(1 for e in edits if e["status"] == "error")
    notes     = sum(1 for e in edits if e.get("type") == "note")

    cards_html = "\n".join(rows)

    return f"""<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Apply Edits -- Preview</title>
<style>
{_CSS_VARS}
{_BTN_CSS}
  .page-wrap  {{ max-width: 960px; margin: 0 auto; padding: 2rem 1.5rem 140px; }}
  h1          {{ font-size: 1.5rem; font-weight: 700; margin-bottom: 0.25rem; }}
  .subtitle   {{ color: var(--muted); font-size: 0.9rem; margin-bottom: 0.5rem; }}
  .summary    {{ color: var(--muted); font-size: 0.85rem; margin-bottom: 1.5rem;
                 padding: 0.8rem 1rem; background: var(--surface);
                 border: 1px solid var(--border); border-radius: 8px; }}
  .summary .ct-ready    {{ color: var(--success); font-weight: 600; }}
  .summary .ct-notfound {{ color: var(--danger);  font-weight: 600; }}
  .summary .ct-dupe     {{ color: var(--warn);    font-weight: 600; }}
  .summary .ct-error    {{ color: var(--danger);  font-weight: 600; }}
  .summary .ct-note     {{ color: var(--accent);  font-weight: 600; }}
  .edit-card  {{ background: var(--surface); border: 1px solid var(--border);
                 border-radius: 8px; padding: 1rem; margin-bottom: 0.8rem; }}
  .edit-card.not-found {{ border-left: 3px solid var(--danger); }}
  .edit-card.duplicate {{ border-left: 3px solid var(--warn); }}
  .edit-card.error     {{ border-left: 3px solid var(--danger); }}
  .edit-card.ready     {{ border-left: 3px solid var(--success); }}
  .edit-card.note      {{ border-left: 3px solid var(--accent); }}
  .status-note  {{ background: rgba(91,138,245,0.15); color: var(--accent); }}
  .note-body    {{ font-size: 0.85rem; color: var(--text); line-height: 1.6;
                   padding: 0.4rem 0; }}
  .edit-header {{ display: flex; align-items: center; gap: 0.6rem;
                  margin-bottom: 0.6rem; }}
  .toggle-group {{ display: flex; border: 1px solid var(--border);
                   border-radius: 6px; overflow: hidden; flex-shrink: 0; }}
  .toggle-btn {{ padding: 0.25rem 0.6rem; border: none; background: transparent;
                 color: var(--muted); font-size: 0.78rem; font-weight: 600;
                 cursor: pointer; transition: all 0.15s; }}
  .toggle-btn:first-child {{ border-right: 1px solid var(--border); }}
  .toggle-change.active {{ background: var(--success); color: #fff; }}
  .toggle-ignore.active {{ background: var(--danger); color: #fff; }}
  .toggle-btn:disabled {{ opacity: 0.4; cursor: default; }}
  .toggle-btn:disabled.active {{ opacity: 1; }}
  .edit-num    {{ font-weight: 700; font-size: 0.85rem; }}
  .edit-status {{ font-size: 0.78rem; padding: 0.15rem 0.5rem; border-radius: 4px;
                  font-weight: 600; }}
  .status-ready     {{ background: rgba(76,175,80,0.15); color: var(--success); }}
  .status-not-found {{ background: rgba(224,85,85,0.15); color: var(--danger); }}
  .status-duplicate {{ background: rgba(212,168,67,0.15); color: var(--warn); }}
  .status-error     {{ background: rgba(224,85,85,0.15); color: var(--danger); }}
  .edit-reason {{ font-size: 0.82rem; color: var(--muted); flex: 1; }}
  .edit-diff   {{ font-size: 0.82rem; }}
  .diff-old    {{ color: var(--danger); margin-bottom: 0.3rem; }}
  .diff-new    {{ color: var(--success); }}
  .diff-label  {{ font-weight: 700; font-size: 0.75rem; display: inline-block;
                  width: 35px; }}
  .diff-old code, .diff-new code {{
    white-space: pre-wrap; word-break: break-word; }}
  .ctx-line {{ color: #5b8af5; font-size: 0.82rem; padding: 0.2rem 0; }}
  .ctx-line code {{ white-space: pre-wrap; word-break: break-word;
                    font-style: italic; }}
  .action-bar {{ position: fixed; bottom: 0; left: 0; right: 0;
                 background: var(--surface); border-top: 1px solid var(--border);
                 padding: 1rem 2rem; display: flex; align-items: center;
                 gap: 1rem; z-index: 20; }}
  .action-bar .hint {{ flex: 1; font-size: 0.82rem; color: var(--muted); }}
  .status-msg {{ position: fixed; bottom: 70px; left: 50%;
                 transform: translateX(-50%);
                 background: var(--surface); border: 1px solid var(--border);
                 border-radius: 8px; padding: 0.7rem 1.4rem;
                 font-size: 0.88rem; display: none; z-index: 30; }}
</style>
</head>
<body>

<div class="page-wrap">
  <h1>Preview Edits</h1>
  <p class="subtitle">Reviewing: <strong>{filename}</strong></p>

  <div class="summary">
    <span class="ct-ready">{ready} ready</span> &middot;
    <span class="ct-notfound">{not_found} not found</span> &middot;
    <span class="ct-dupe">{dupes} ambiguous</span> &middot;
    <span class="ct-error">{errors} errors</span> &middot;
    <span class="ct-note">{notes} notes</span> &middot;
    {total} total
  </div>

  {cards_html}
</div>

<div class="status-msg" id="status-msg"></div>

<div class="action-bar">
  <span class="hint">Toggle edits between Change and Ignore.
  Only "Ready" edits can be set to Change.</span>
  <button class="btn btn-cancel" onclick="window.location.href='/'">Back</button>
  <button class="btn btn-run" id="apply-btn" onclick="applyEdits()">
    Apply Selected</button>
</div>

<script>
  function showStatus(msg) {{
    const el = document.getElementById('status-msg');
    el.textContent = msg; el.style.display = 'block';
  }}

  function setToggle(idx, mode) {{
    const group = document.querySelector('.toggle-group[data-idx="' + idx + '"]');
    if (!group) return;
    const changeBtn = group.querySelector('.toggle-change');
    const ignoreBtn = group.querySelector('.toggle-ignore');
    if (changeBtn.disabled && mode === 'change') return;
    if (mode === 'change') {{
      changeBtn.classList.add('active');
      ignoreBtn.classList.remove('active');
    }} else {{
      changeBtn.classList.remove('active');
      ignoreBtn.classList.add('active');
    }}
  }}

  function applyEdits() {{
    const groups = document.querySelectorAll('.toggle-group');
    const indices = [];
    groups.forEach(g => {{
      const changeBtn = g.querySelector('.toggle-change');
      if (changeBtn.classList.contains('active') && !changeBtn.disabled) {{
        indices.push(parseInt(g.dataset.idx));
      }}
    }});
    if (indices.length === 0) {{
      showStatus('No edits set to Change.');
      return;
    }}
    if (!confirm('Apply ' + indices.length + ' edit(s)? '
                 + 'A backup will be created first.')) {{
      return;
    }}
    fetch('/apply', {{
      method:  'POST',
      headers: {{'Content-Type': 'application/json'}},
      body:    JSON.stringify({{ indices: indices }})
    }})
    .then(r => r.json())
    .then(data => {{
      if (data.error) {{
        showStatus('Error: ' + data.error);
      }} else if (data.redirect) {{
        window.location.href = data.redirect;
      }}
    }})
    .catch(err => showStatus('Error: ' + err));
  }}
</script>
</body>
</html>"""


def build_results_html(edits: list, applied_indices: set,
                       filename: str) -> str:
    """Build Page 3: Post-apply results summary.

    Shows two sections:
      1. Skipped edits: EDIT items that were NOT applied.  This includes
         edits set to "Ignore" by the user (status "ready" but not in
         applied_indices), edits that were "not_found", "duplicate", or
         "error".  Each is shown with its status badge, reason, and
         old/new text.
      2. Notes: All NOTE items, shown as blue info cards.

    If everything was applied and there are no notes, shows a success
    message instead.

    Summary bar: X applied, Y not applied, Z notes.

    Buttons:
      Back: Navigate to / (config page) to start another editing pass.
            State is fully reset when the user clicks Preview again.
      Exit: POST /shutdown to stop the server.
    """
    applied_count = len(applied_indices)
    skipped = [(idx, e) for idx, e in enumerate(edits)
               if idx not in applied_indices and e.get("type") != "note"]
    note_items = [(idx, e) for idx, e in enumerate(edits)
                  if e.get("type") == "note"]
    skipped_count = len(skipped)
    note_count = len(note_items)

    cards = []

    # Skipped edits.
    for idx, edit in skipped:
        status = edit["status"]
        if status == "ready":
            reason_text = "Set to Ignore by user"
            status_cls = "skipped"
            status_label = "Skipped"
        elif status == "not_found":
            status_cls = "not-found"
            status_label = "Not Found"
            reason_text = edit["reason"]
        elif status == "duplicate":
            status_cls = "duplicate"
            status_label = "Ambiguous"
            reason_text = edit["reason"]
        else:
            status_cls = "error"
            status_label = "Error"
            reason_text = edit["reason"]

        old_esc = (edit["old"]
                   .replace('&', '&amp;')
                   .replace('<', '&lt;')
                   .replace('>', '&gt;'))
        new_esc = (edit["new"]
                   .replace('&', '&amp;')
                   .replace('<', '&lt;')
                   .replace('>', '&gt;'))
        reason_esc = (reason_text
                      .replace('&', '&amp;')
                      .replace('<', '&lt;')
                      .replace('>', '&gt;')
                      .replace('\n', '<br>'))

        cards.append(f"""
      <div class="edit-card {status_cls}">
        <div class="edit-header">
          <span class="edit-num">#{idx + 1}</span>
          <span class="edit-status status-{status_cls}">{status_label}</span>
          <span class="edit-reason">{reason_esc}</span>
        </div>
        <div class="edit-diff">
          <div class="diff-old">
            <span class="diff-label">OLD:</span> <code>{old_esc}</code>
          </div>
          <div class="diff-new">
            <span class="diff-label">NEW:</span> <code>{new_esc}</code>
          </div>
        </div>
      </div>""")

    # Notes.
    for idx, edit in note_items:
        reason_esc = (edit["reason"]
                      .replace('&', '&amp;')
                      .replace('<', '&lt;')
                      .replace('>', '&gt;')
                      .replace('\n', '<br>'))
        cards.append(f"""
      <div class="edit-card note">
        <div class="edit-header">
          <span class="edit-num">#{idx + 1}</span>
          <span class="edit-status status-note">Note</span>
        </div>
        <div class="note-body">{reason_esc}</div>
      </div>""")

    cards_html = "\n".join(cards) if cards else """
      <div style="color: var(--success); font-size: 1rem;
                  padding: 2rem; text-align: center;">
        All edits were applied. No notes.
      </div>"""

    return f"""<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Apply Edits -- Results</title>
<style>
{_CSS_VARS}
{_BTN_CSS}
  .page-wrap  {{ max-width: 960px; margin: 0 auto; padding: 2rem 1.5rem 140px; }}
  h1          {{ font-size: 1.5rem; font-weight: 700; margin-bottom: 0.25rem; }}
  .subtitle   {{ color: var(--muted); font-size: 0.9rem; margin-bottom: 0.5rem; }}
  .summary    {{ color: var(--muted); font-size: 0.85rem; margin-bottom: 1.5rem;
                 padding: 0.8rem 1rem; background: var(--surface);
                 border: 1px solid var(--border); border-radius: 8px; }}
  .summary .ct-applied  {{ color: var(--success); font-weight: 600; }}
  .summary .ct-skipped  {{ color: var(--warn);    font-weight: 600; }}
  .summary .ct-note     {{ color: var(--accent);  font-weight: 600; }}
  .edit-card  {{ background: var(--surface); border: 1px solid var(--border);
                 border-radius: 8px; padding: 1rem; margin-bottom: 0.8rem; }}
  .edit-card.skipped   {{ border-left: 3px solid var(--warn); }}
  .edit-card.not-found {{ border-left: 3px solid var(--danger); }}
  .edit-card.duplicate {{ border-left: 3px solid var(--warn); }}
  .edit-card.error     {{ border-left: 3px solid var(--danger); }}
  .edit-card.note      {{ border-left: 3px solid var(--accent); }}
  .status-note    {{ background: rgba(91,138,245,0.15); color: var(--accent); }}
  .note-body      {{ font-size: 0.85rem; color: var(--text); line-height: 1.6;
                     padding: 0.4rem 0; }}
  .edit-header {{ display: flex; align-items: center; gap: 0.6rem;
                  margin-bottom: 0.6rem; }}
  .edit-num    {{ font-weight: 700; font-size: 0.85rem; }}
  .edit-status {{ font-size: 0.78rem; padding: 0.15rem 0.5rem; border-radius: 4px;
                  font-weight: 600; }}
  .status-skipped   {{ background: rgba(212,168,67,0.15); color: var(--warn); }}
  .status-not-found {{ background: rgba(224,85,85,0.15); color: var(--danger); }}
  .status-duplicate {{ background: rgba(212,168,67,0.15); color: var(--warn); }}
  .status-error     {{ background: rgba(224,85,85,0.15); color: var(--danger); }}
  .edit-reason {{ font-size: 0.82rem; color: var(--muted); flex: 1; }}
  .edit-diff   {{ font-size: 0.82rem; }}
  .diff-old    {{ color: var(--danger); margin-bottom: 0.3rem; }}
  .diff-new    {{ color: var(--success); }}
  .diff-label  {{ font-weight: 700; font-size: 0.75rem; display: inline-block;
                  width: 35px; }}
  .diff-old code, .diff-new code {{
    white-space: pre-wrap; word-break: break-word; }}
  .action-bar {{ position: fixed; bottom: 0; left: 0; right: 0;
                 background: var(--surface); border-top: 1px solid var(--border);
                 padding: 1rem 2rem; display: flex; align-items: center;
                 gap: 1rem; z-index: 20; }}
  .action-bar .hint {{ flex: 1; font-size: 0.82rem; color: var(--muted); }}
</style>
</head>
<body>

<div class="page-wrap">
  <h1>Results</h1>
  <p class="subtitle">File: <strong>{filename}</strong></p>

  <div class="summary">
    <span class="ct-applied">{applied_count} applied</span> &middot;
    <span class="ct-skipped">{skipped_count} not applied</span> &middot;
    <span class="ct-note">{note_count} notes</span>
  </div>

  {cards_html}
</div>

<div class="action-bar">
  <span class="hint">Edits have been applied. Backup saved.</span>
  <button class="btn btn-save" onclick="window.location.href='/'">Back</button>
  <button class="btn btn-cancel" onclick="doExit()">Exit</button>
</div>

<script>
  function doExit() {{
    fetch('/shutdown', {{ method: 'POST' }})
    .then(() => {{
      document.body.innerHTML = '<div style="padding:4rem;text-align:center;'
        + 'color:#888;font-size:1.1rem;">Done. You may close this window.</div>';
    }});
  }}
</script>
</body>
</html>"""


# ── HTTP Server ───────────────────────────────────────────────────────────────
# The server uses Python's built-in ThreadingHTTPServer (stdlib, no deps).
# It runs on 127.0.0.1 only (not accessible from the network).
#
# Mutable state is shared between handlers via closure variables:
#   parsed_edits:    List of edit/note dicts from parse_edits().
#   manuscript_text: List-of-one containing the manuscript string.
#                    (A list is used so inner functions can mutate it;
#                    a plain string would be immutable in the closure.)
#   applied_indices: Set of indices that were successfully applied.
#
# The server runs in a daemon thread.  main() calls server._server_thread.join()
# to wait for shutdown.  The server shuts down when:
#   - User clicks Exit or Save & Exit on the config page.
#   - User clicks Exit on the results page.
#   - The browser tab is closed (the thread is a daemon, so it dies with main).

def serve(live_cfg: dict, run_event: threading.Event):
    """Start the HTTP server, open the browser, and return the server object.

    Args:
        live_cfg:   Mutable config dict (modified in place by POST /config).
        run_event:  Threading event (currently unused, reserved for future use).

    Returns:
        The ThreadingHTTPServer instance.  The caller should join
        server._server_thread to wait for shutdown.
    """
    # ── Mutable shared state (closure variables) ──
    # These are shared between all request handlers via closure.
    # They persist for the lifetime of the server.

    parsed_edits    = []      # List of edit/note dicts from parse_edits()
    manuscript_text = [""]    # List-of-one: manuscript_text[0] is the string.
                              # A list is used because str is immutable;
                              # inner functions need to reassign the value.
    applied_indices = set()   # Set of indices successfully applied in the
                              # most recent Apply operation.

    server = None  # Forward declaration; set after Handler class is defined.

    class Handler(BaseHTTPRequestHandler):
        """HTTP request handler for all three pages.

        Handles GET (page rendering) and POST (actions and apply).
        Uses closure variables (parsed_edits, manuscript_text,
        applied_indices, live_cfg, server) for shared state.
        Suppresses default stderr logging for cleaner console output.
        """

        def log_message(self, format, *args):
            pass  # suppress default stderr logging

        def _send_html(self, html, code=200):
            data = html.encode("utf-8")
            self.send_response(code)
            self.send_header("Content-Type", "text/html; charset=utf-8")
            self.send_header("Content-Length", str(len(data)))
            self.end_headers()
            self.wfile.write(data)

        def _send_json(self, obj, code=200):
            data = _json.dumps(obj).encode("utf-8")
            self.send_response(code)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(data)))
            self.end_headers()
            self.wfile.write(data)

        def do_GET(self):
            path = self.path.split("?")[0]

            if path == "/":
                self._send_html(build_config_html(live_cfg))

            elif path == "/preview":
                if not parsed_edits:
                    self._send_html(build_config_html(live_cfg))
                else:
                    self._send_html(build_preview_html(
                        parsed_edits, live_cfg["filename"],
                        manuscript_text[0]))

            elif path == "/results":
                if not parsed_edits:
                    self._send_html(build_config_html(live_cfg))
                else:
                    self._send_html(build_results_html(
                        parsed_edits, applied_indices,
                        live_cfg["filename"]))

            else:
                self.send_response(404)
                self.end_headers()

        def do_POST(self):
            path = self.path.split("?")[0]
            length = int(self.headers.get("Content-Length", 0))

            if path == "/config":
                try:
                    payload = _json.loads(self.rfile.read(length))
                except Exception:
                    self._send_json({"error": "Invalid JSON"}, 400)
                    return

                action = payload.get("action", "")

                # Update live config from form fields.
                live_cfg["drafts_dir"]  = payload.get(
                    "drafts_dir", "").strip()
                live_cfg["backups_dir"] = payload.get(
                    "backups_dir", "").strip()
                live_cfg["filename"]    = payload.get(
                    "filename", "").strip()
                live_cfg["edits_text"]  = payload.get("edits_text", "")

                if action == "exit":
                    self._send_json({"ok": True})
                    threading.Timer(0.5, server.shutdown).start()
                    return

                if action == "save_exit":
                    save_config(live_cfg)
                    self._send_json({"ok": True})
                    threading.Timer(0.5, server.shutdown).start()
                    return

                if action in ("save_preview", "preview"):
                    # Save config if requested.
                    if action == "save_preview":
                        save_config(live_cfg)

                    # Clear state from any previous run.
                    applied_indices.clear()

                    # Validate inputs.
                    drafts_dir = live_cfg["drafts_dir"]
                    filename   = live_cfg["filename"]
                    edits_text = live_cfg["edits_text"]

                    if not drafts_dir:
                        self._send_json(
                            {"error": "Drafts directory is required."})
                        return
                    if not filename:
                        self._send_json(
                            {"error": "Filename is required."})
                        return
                    if not edits_text.strip():
                        self._send_json({"error": "No edits pasted."})
                        return

                    filepath = resolve_filepath(drafts_dir, filename)
                    if not filepath.is_file():
                        self._send_json(
                            {"error": f"File not found: {filepath} "
                             f"(also tried .md and .txt)"})
                        return

                    # Read manuscript.
                    try:
                        manuscript_text[0] = filepath.read_text(
                            encoding="utf-8")
                    except Exception as exc:
                        self._send_json(
                            {"error": f"Cannot read file: {exc}"})
                        return

                    # Parse and analyze edits.
                    parsed_edits.clear()
                    parsed_edits.extend(parse_edits(edits_text))

                    if not parsed_edits:
                        self._send_json(
                            {"error":
                             "No EDIT||| lines found in pasted text."})
                        return

                    analyze_edits(manuscript_text[0], parsed_edits)

                    self._send_json(
                        {"ok": True, "redirect": "/preview"})
                    return

                self._send_json(
                    {"error": f"Unknown action: {action}"}, 400)

            elif path == "/apply":
                try:
                    payload = _json.loads(self.rfile.read(length))
                except Exception:
                    self._send_json({"error": "Invalid JSON"}, 400)
                    return

                indices = payload.get("indices", [])
                if not indices:
                    self._send_json({"error": "No edits selected."})
                    return

                drafts_dir  = live_cfg["drafts_dir"]
                backups_dir = live_cfg["backups_dir"]
                filename    = live_cfg["filename"]
                filepath    = resolve_filepath(drafts_dir, filename)

                if not filepath.is_file():
                    self._send_json(
                        {"error": f"File not found: {filepath} "
                         f"(also tried .md and .txt)"})
                    return

                # Create backup.
                if backups_dir:
                    backup_path = Path(backups_dir)
                    backup_path.mkdir(parents=True, exist_ok=True)
                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                    stem   = filepath.stem
                    suffix = filepath.suffix
                    backup_file = (backup_path
                                   / f"{stem}_{timestamp}{suffix}")
                    try:
                        shutil.copy2(filepath, backup_file)
                        print(f"Backup saved -> {backup_file}")
                    except Exception as exc:
                        self._send_json(
                            {"error": f"Backup failed: {exc}"})
                        return
                else:
                    print("WARNING: No backups directory configured. "
                          "Skipping backup.")

                # Re-read the file fresh in case the user edited it
                # externally while the preview screen was open.
                try:
                    manuscript_text[0] = filepath.read_text(
                        encoding="utf-8")
                except Exception as exc:
                    self._send_json(
                        {"error": f"Cannot re-read file: {exc}"})
                    return

                # Re-analyze edits against the current file contents.
                # Some edits that were "ready" at preview time may no
                # longer match if the user edited the file.
                analyze_edits(manuscript_text[0], parsed_edits)

                # Filter indices to only those still ready.
                valid_indices = [i for i in indices
                                 if 0 <= i < len(parsed_edits)
                                 and parsed_edits[i]["status"] == "ready"]

                if not valid_indices:
                    self._send_json(
                        {"error": "No selected edits match the current "
                         "file. The file may have been modified since "
                         "preview."})
                    return

                skipped = len(indices) - len(valid_indices)
                if skipped > 0:
                    print(f"NOTE: {skipped} edit(s) no longer match "
                          f"the file and were skipped.")

                # Apply edits.
                result = apply_selected_edits(
                    manuscript_text[0], parsed_edits, valid_indices)

                # Track what was applied.
                applied_indices.clear()
                applied_indices.update(valid_indices)

                # Write result.
                try:
                    filepath.write_text(result, encoding="utf-8")
                    print(f"Edits applied -> {filepath}")
                except Exception as exc:
                    self._send_json(
                        {"error": f"Write failed: {exc}"})
                    return

                self._send_json(
                    {"ok": True, "applied": len(valid_indices),
                     "skipped_since_preview": skipped,
                     "redirect": "/results"})

            elif path == "/shutdown":
                self._send_json({"ok": True})
                threading.Timer(0.5, server.shutdown).start()

            else:
                self.send_response(404)
                self.end_headers()

    server = ThreadingHTTPServer(("127.0.0.1", PORT), Handler)

    server_ready = threading.Event()

    def _serve():
        server_ready.set()
        server.serve_forever()

    server_thread = threading.Thread(target=_serve, daemon=True)
    server._server_thread = server_thread
    server_thread.start()

    if not server_ready.wait(timeout=5.0):
        print("ERROR: HTTP server did not start within 5 seconds.")
        sys.exit(1)

    url = f"http://127.0.0.1:{PORT}"
    print(f"Server running at {url}")
    print("  Configure paths and paste edits in the browser.\n")
    webbrowser.open(url)
    return server


# ── Entry Point ───────────────────────────────────────────────────────────────

def main():
    """Top-level orchestration: load config, start server, wait for shutdown.

    Flow:
      1. load_config() reads apply_edits_config.json or returns defaults.
      2. serve() starts the HTTP server on localhost:8767 in a daemon
         thread and opens the default browser to the config page.
      3. All user interaction happens via the browser.  The server thread
         handles GET and POST requests for all three pages.
      4. main() blocks on server._server_thread.join(), waiting for the
         server to shut down (triggered by Exit, Save & Exit, or /shutdown).
      5. When the server thread finishes, main() prints "Done." and exits.
    """
    live_cfg  = load_config()
    run_event = threading.Event()

    server = serve(live_cfg, run_event)

    # Wait for the server to shut down.
    server._server_thread.join()
    print("Done.")


if __name__ == "__main__":
    main()