#!/usr/bin/env python3 """ build.py — Newsletter issue assembler. Usage: python3 build.py 001 Reads issues/NNN.md, replaces all {{PLACEHOLDERS}} in email-template.html, outputs issues/NNN-rendered.html, and validates the result. Hard errors (exit 1): - Missing or empty PROMPT field - Unfilled {{PLACEHOLDERS}} in rendered output - Subject line over 50 characters - TIP_HEADLINE over 60 characters - Placeholder strings in code blocks (YOUR_VALUE_HERE, , ...) - Missing prompt teaser callout in TIP_BODY - Missing "Copy this prompt" block - Raw HTML comments inside 
 blocks (must be encoded as <--)
"""

import sys
import re
from pathlib import Path

SCRIPT_DIR = Path(__file__).parent
TEMPLATE_PATH = SCRIPT_DIR / "email-template.html"
ISSUES_DIR = SCRIPT_DIR / "issues"

BEEHIIV_UNSUBSCRIBE = "{{unsubscribe_url}}"  # Beehiiv injects this at send time

PLACEHOLDER_PATTERNS = [
    r"YOUR_VALUE_HERE",
    r"YOUR_[A-Z_]+_HERE",
    r"",
    r"]+>",
]


def die(msg: str):
    print(f"\nERROR: {msg}\n", file=sys.stderr)
    sys.exit(1)


def parse_issue(path: Path) -> dict:
    text = path.read_text(encoding="utf-8")
    fields = {}

    fm_match = re.match(r"^---\s*\n(.*?)\n---\s*\n", text, re.DOTALL)
    if not fm_match:
        die(f"No frontmatter found in {path.name}")

    for line in fm_match.group(1).splitlines():
        line = line.strip()
        if ":" in line:
            key, _, val = line.partition(":")
            fields[key.strip()] = val.strip()

    body = text[fm_match.end():]
    # Section header pattern: only "## NAME" where NAME is uppercase + underscores only,
    # followed by end-of-line. The lookahead is identical so that nested headings inside
    # a section body (e.g. "## NEW CLAUDE.md" inside GOD_PROMPT_BODY) don't truncate
    # the section. Without this, the regex was treating any "## " line as a delimiter,
    # silently dropping the rest of GOD_PROMPT_BODY.
    section_pattern = re.compile(
        r"^## ([A-Z_]+)\s*\n(.*?)(?=^## [A-Z_]+\s*\n|\Z)",
        re.MULTILINE | re.DOTALL,
    )
    for m in section_pattern.finditer(body):
        fields[m.group(1).strip()] = m.group(2).strip()

    return fields


def prose_paragraph_split(text: str) -> str:
    """Convert blank-line paragraph breaks in prose fields to 

.

    Email clients (Gmail web, Outlook, Apple Mail) collapse multiple consecutive
    whitespace inside a single 
 tag — a blank line in source content renders
    as one space and the intended two-beat hook reads as one wall-of-text
    paragraph. 

 survives the collapse and preserves the visual break.

    Applies ONLY to plain-text prose fields (TIP_INTRO, GOD_PROMPT_INTRO,
    GOD_PROMPT_CLOSER, PRO_TIP_BODY, QUICK_WIN_BODY). HTML-bearing fields
    (TIP_BODY, TLDR, READ_THIS_WEEK) already have their own structure and are
    NOT processed by this helper.

    See MISTAKE-018 in foundations/MISTAKES-LOG.md.
    """
    return text.replace("\n\n", "

")


def god_prompt_body_format(text: str) -> str:
    """Convert god-tier prompt body to HTML with explicit 
 tags per newline.

    The original implementation relied on `white-space:pre-wrap` CSS to preserve
    newlines in the prompt body. Beehiiv (and likely some email clients) strip or
    normalise whitespace inside 
 tags during paste/render, even when pre-wrap
    is set. The result is the entire structured prompt rendering as one flowing
    paragraph: all bullet lists, step headers, and calibration pairs collapse
    together.

    Fix: every newline becomes an explicit 
 tag at build time. 
 survives
    every platform's whitespace normalisation. The wrapper style still keeps
    `white-space:pre-wrap` as belt-and-suspenders for any stray newlines, but
    the actual line-breaking work is done by the 
s.

    See MISTAKE-022 in foundations/MISTAKES-LOG.md.
    """
    return text.replace("\n", "
")


def build_god_gift_block(fields: dict) -> str:
    """Render the god-tier prompt gift block, or empty string if no prompt is provided."""
    body_raw = fields.get("GOD_PROMPT_BODY", "").strip()
    if not body_raw:
        return ""

    body = god_prompt_body_format(body_raw)
    headline = fields.get("GOD_PROMPT_HEADLINE", "").strip()
    intro = prose_paragraph_split(fields.get("GOD_PROMPT_INTRO", "").strip())
    closer = prose_paragraph_split(fields.get("GOD_PROMPT_CLOSER", "").strip())
    pill = fields.get("GOD_PROMPT_PILL", "God-tier prompt · Free this week").strip()

    return f'''

  {pill}
  
{headline}

  
{intro}

  

    
{body}

  

  
{closer}


'''


def build_replacements(fields: dict, read_time: int) -> dict:
    return {
        "ISSUE_NUM":              fields.get("issue", ""),
        "DATE":                   fields.get("date", ""),
        "READ_TIME":              str(read_time),
        "DIFFICULTY":             fields.get("difficulty", "Beginner-friendly"),
        "TIP_HEADLINE":           fields.get("TIP_HEADLINE", ""),
        "TLDR":                   fields.get("TLDR", ""),
        "TIP_INTRO":              prose_paragraph_split(fields.get("TIP_INTRO", "")),
        "TIP_BODY":               fields.get("TIP_BODY", ""),
        "DEEP_DIVE_TITLE":        fields.get("DEEP_DIVE_TITLE", ""),
        "DEEP_DIVE_URL":          fields.get("DEEP_DIVE_URL", ""),
        "DEEP_DIVE_DESCRIPTION":  fields.get("DEEP_DIVE_DESCRIPTION", ""),
        "PROMPT":                 fields.get("PROMPT", ""),
        "PRO_TIP_HEADLINE":       fields.get("PRO_TIP_HEADLINE", ""),
        "PRO_TIP_BODY":           prose_paragraph_split(fields.get("PRO_TIP_BODY", "")),
        "QUICK_WIN_HEADLINE":     fields.get("QUICK_WIN_HEADLINE", ""),
        "QUICK_WIN_BODY":         prose_paragraph_split(fields.get("QUICK_WIN_BODY", "")),
        "READ_THIS_WEEK":         fields.get("READ_THIS_WEEK", ""),
        "GOD_GIFT_BLOCK":         build_god_gift_block(fields),
        "NEXT_TEASE":             fields.get("NEXT_TEASE", ""),
        "UNSUBSCRIBE_URL":        BEEHIIV_UNSUBSCRIBE,
    }


def apply_replacements(template: str, replacements: dict) -> str:
    result = template
    for key, value in replacements.items():
        result = result.replace("{{" + key + "}}", value)
    return result


def validate_fields(fields: dict):
    errors = []

    # PROMPT is mandatory
    if not fields.get("PROMPT", "").strip():
        errors.append("PROMPT field is empty. Every issue must have a copyable plain-English prompt.")

    # Required fields
    for required in ("TLDR", "DEEP_DIVE_TITLE", "DEEP_DIVE_URL", "DEEP_DIVE_DESCRIPTION",
                     "PRO_TIP_HEADLINE", "PRO_TIP_BODY",
                     "READ_THIS_WEEK", "NEXT_TEASE"):
        if not fields.get(required, "").strip():
            errors.append(f"{required} field is empty. Required for the new format.")

    # DEEP_DIVE_URL must be http(s)
    deep_url = fields.get("DEEP_DIVE_URL", "").strip()
    if deep_url and not (deep_url.startswith("http://") or deep_url.startswith("https://") or deep_url.startswith("/")):
        errors.append(f"DEEP_DIVE_URL must be a full URL or absolute path: '{deep_url}'")

    # Subject line length
    subject = fields.get("subject", "")
    if len(subject) > 50:
        errors.append(f"Subject line is {len(subject)} chars (max 50): '{subject}'")

    # Headline length
    headline = fields.get("TIP_HEADLINE", "")
    if len(headline) > 60:
        errors.append(f"TIP_HEADLINE is {len(headline)} chars (max 60): '{headline}'")

    # Issue type present
    if not fields.get("type", "").strip():
        errors.append("Frontmatter missing 'type' field (Command|Config|Workflow|Agent|Debug)")

    for e in errors:
        print(f"VALIDATION FAIL: {e}", file=sys.stderr)
    if errors:
        sys.exit(1)


def validate_rendered(html: str):
    errors = []

    # Unfilled uppercase placeholders
    remaining = re.findall(r"\{\{[A-Z_]+\}\}", html)
    if remaining:
        errors.append(f"Unfilled placeholders: {', '.join(set(remaining))}")

    # Placeholder strings in code blocks
    code_blocks = re.findall(r"]*>.*?
", html, re.DOTALL) for block in code_blocks: for pattern in PLACEHOLDER_PATTERNS: if re.search(pattern, block, re.IGNORECASE): errors.append(f"Code block contains incomplete placeholder: {pattern}") break # Raw HTML comments inside 
 blocks
    for block in code_blocks:
        if "