#!/usr/bin/env python3
# SPDX-FileCopyrightText: 2026 Shamiur Rashid Sunny
# SPDX-License-Identifier: AGPL-3.0-only
"""Part 157: one-shot ship helper for the Sunnyware project.

Usage:
  python scripts/ship.py <part_number> "<short description>" [options]

Options:
  --body TEXT        Detailed body for HANDOFF.md (defaults to desc)
  --wait N           Seconds to wait for HF rebuild (default: 150)
  --verify-role R    Role to use for live verify (default: general)
  --verify-input T   Input for live verify (default: Reply with PONG.)
  --skip STEPS       Comma-separated steps to skip.
                     Valid: smokes,gate,docs,commit,gh,hf,verify
  --dry-run          Show what would happen without touching git
  --no-color         Disable ANSI colors

Steps performed:
  1. smokes    - run every scripts/smoke_test_part*.py
  2. gate      - scripts/pre_push_check.py
  3. docs      - append HANDOFF + WORKFLOW + bump AGENTS footer
  4. commit    - git add + commit with the assembled message
  5. gh        - git push origin main
  6. hf        - ./push_hf.sh
  7. verify    - wait for HF, GET /health/ready, fire live request

Never pushes broken code: if any smoke or the gate fails, we abort
before touching git.
"""

import argparse
import datetime
import json
import os
import re
import subprocess
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path

# Part 157b: force UTF-8 stdout on Windows (cp1252 can't encode
# box-drawing chars, emoji, or the ANSI color codes we use).
try:
    sys.stdout.reconfigure(encoding="utf-8")
    sys.stderr.reconfigure(encoding="utf-8")
except Exception:
    pass

ROOT = Path.cwd()
SCRIPTS = ROOT / "scripts"
SRC = ROOT / "src" / "sunnyware"
BASE_URL = "https://shamiur-sunnyware.hf.space"

# Part 157c: legacy smokes that had hard-coded counts before
# newer parts changed them (e.g. roles went 9 -> 10 when the
# auditor role was added in Part 142a). ship.py warns on these
# but does not abort. A future cleanup part will update them.
LEGACY_FAILING_SMOKES = set()  # Part 157b: legacy archived

USE_COLOR = True


def c(txt, code):
    if not USE_COLOR:
        return txt
    return f"\033[{code}m{txt}\033[0m"


def info(msg):
    print(f"  {msg}")


def ok(step, msg):
    print(f"{c('[OK]', '32')} [{step}] {msg}")


def fail(step, msg, exit_code=1):
    print(f"{c('[FAIL]', '31')} [{step}] {msg}")
    sys.exit(exit_code)


def hdr(title):
    line = "=" * 70
    print("")
    print(c(line, "36"))
    print(c(f"  {title}", "36"))
    print(c(line, "36"))


# ─────────────────────────────────────────────────────────────
# STEP 1 — run smokes
# ─────────────────────────────────────────────────────────────
def run_smokes():
    hdr("STEP 1 — smokes")
    files = sorted(SCRIPTS.glob("smoke_test_part*.py"))

    def num_key(p):
        m = re.search(r"part(\d+)", p.name)
        return int(m.group(1)) if m else 0

    files.sort(key=num_key)
    failed = []
    for f in files:
        try:
            # Part 157b: force UTF-8 so smokes that print non-cp1252
            # chars (em-dash, box-drawing) don't spuriously fail on
            # Windows when ship.py captures their output.
            _env = os.environ.copy()
            _env["PYTHONIOENCODING"] = "utf-8"
            _env["PYTHONUTF8"] = "1"
            r = subprocess.run(
                [sys.executable, str(f)],
                capture_output=True, text=True, timeout=180,
                env=_env, encoding="utf-8", errors="replace",
            )
        except subprocess.TimeoutExpired:
            info(f"{c('[FAIL]', '31')} {f.name:36s} TIMEOUT")
            failed.append(f.name)
            continue
        lines = [ln for ln in (r.stdout or "").strip().splitlines() if ln.strip()]
        tail = lines[-1] if lines else "(no output)"
        passed = r.returncode == 0
        is_legacy = f.name in LEGACY_FAILING_SMOKES
        if passed:
            marker = c("[OK]", "32")
        elif is_legacy:
            marker = c("[WARN]", "33")   # yellow
            tail = "(legacy allowlist) " + tail
        else:
            marker = c("[FAIL]", "31")
        info(f"{marker} {f.name:36s} {tail}")
        if not passed and not is_legacy:
            failed.append(f.name)

    if failed:
        fail("1", f"{len(failed)} smoke(s) failed: {', '.join(failed)}")
    ok("1", f"{len(files)} smoke(s) passed")


# ─────────────────────────────────────────────────────────────
# STEP 2 — pre-push gate
# ─────────────────────────────────────────────────────────────
def run_gate():
    hdr("STEP 2 — pre-push gate")
    r = subprocess.run(
        [sys.executable, str(SCRIPTS / "pre_push_check.py")],
        capture_output=True, text=True,
    )
    for line in (r.stdout or "").splitlines():
        if "SUMMARY" in line or "RESULT" in line:
            info(line.strip())
    if r.returncode != 0:
        fail("2", "pre-push gate blocked")
    ok("2", "gate passed")


# ─────────────────────────────────────────────────────────────
# STEP 3 — docs sync
# ─────────────────────────────────────────────────────────────
def update_docs(part, desc, body, dry_run=False):
    hdr("STEP 3 — docs sync")
    # HANDOFF.md
    p = ROOT / "HANDOFF.md"
    t = p.read_text(encoding="utf-8")
    marker = f"### Part {part} - {desc}"
    if marker in t:
        ok("3", f"HANDOFF already has Part {part}")
    else:
        when = datetime.date.today().isoformat()
        entry = f"\n\n{marker}\n{body}\n"
        if not dry_run:
            p.write_text(t.rstrip() + entry, encoding="utf-8")
        ok("3", f"HANDOFF extended (Part {part})")

    # WORKFLOW.md
    p = ROOT / "WORKFLOW.md"
    t = p.read_text(encoding="utf-8")
    if f"| {part} " in t:
        ok("3", f"WORKFLOW already has Part {part}")
    else:
        when = datetime.date.today().isoformat()
        block = (
            f"\n\n## {when} - Part {part}\n\n"
            f"| Part | Feature |\n"
            f"|------|---------|\n"
            f"| {part} | {desc} |\n\n"
            f"{body}\n"
        )
        if not dry_run:
            p.write_text(t.rstrip() + block, encoding="utf-8")
        ok("3", f"WORKFLOW extended (Part {part})")

    # AGENTS.md footer
    p = ROOT / "AGENTS.md"
    t = p.read_text(encoding="utf-8")
    lines = t.splitlines()
    footer_idx = None
    for i, ln in enumerate(lines):
        if ln.startswith("**Last update:**"):
            footer_idx = i
            break
    new_footer = f"**Last update:** {datetime.date.today().isoformat()} (Part {part} - {desc})"
    if footer_idx is None:
        if not dry_run:
            p.write_text(t.rstrip() + "\n\n" + new_footer + "\n", encoding="utf-8")
        ok("3", "AGENTS footer appended")
    elif lines[footer_idx] == new_footer:
        ok("3", "AGENTS footer already current")
    else:
        lines[footer_idx] = new_footer
        if not dry_run:
            p.write_text("\n".join(lines) + "\n", encoding="utf-8")
        ok("3", "AGENTS footer bumped")


# ─────────────────────────────────────────────────────────────
# STEP 4 — commit
# ─────────────────────────────────────────────────────────────
def do_commit(part, desc, body, dry_run=False):
    hdr("STEP 4 — commit")

    # files to add: source tree + scripts + docs (safe glob)
    to_add = [
        "src/",
        "scripts/",
        "HANDOFF.md",
        "WORKFLOW.md",
        "AGENTS.md",
        "RESUME.md",
    ]
    if dry_run:
        ok("4", "dry-run: skipped git add")
    else:
        subprocess.run(["git", "add"] + to_add, check=False)

    status = subprocess.run(
        ["git", "status", "--porcelain"],
        capture_output=True, text=True,
    )
    dirty = [ln for ln in (status.stdout or "").splitlines() if ln.strip()]
    if not dirty:
        ok("4", "nothing to commit (tree clean)")
        return None

    msg = f"Part {part}: {desc}\n\n{body}\n"
    mf = ROOT / f".commit_msg_part{part}.txt"
    mf.write_text(msg, encoding="utf-8")

    if dry_run:
        ok("4", f"dry-run: would commit {len(dirty)} file(s)")
        mf.unlink()
        return None

    r = subprocess.run(
        ["git", "commit", "-F", str(mf)],
        capture_output=True, text=True,
    )
    try:
        mf.unlink()
    except Exception:
        pass

    if r.returncode != 0:
        info((r.stderr or r.stdout).strip()[-400:])
        fail("4", "git commit failed")

    head_line = (r.stdout or "").strip().splitlines()[0]
    info(head_line)
    # extract short hash
    m = re.search(r"\[main ([0-9a-f]+)\]", head_line)
    head_hash = m.group(1) if m else ""
    ok("4", f"commit created ({head_hash})")
    return head_hash


# ─────────────────────────────────────────────────────────────
# STEP 5 — push GitHub
# ─────────────────────────────────────────────────────────────
def push_github(dry_run=False):
    hdr("STEP 5 — push GitHub")
    if dry_run:
        ok("5", "dry-run: skipped")
        return
    r = subprocess.run(
        ["git", "push", "origin", "main"],
        capture_output=True, text=True,
    )
    if r.returncode != 0:
        info((r.stderr or "")[-300:])
        fail("5", "git push origin failed")
    for line in (r.stdout or "").strip().splitlines()[-2:]:
        info(line)
    ok("5", "GitHub push OK")


# ─────────────────────────────────────────────────────────────
# STEP 6 — push HF
# ─────────────────────────────────────────────────────────────
def push_hf(dry_run=False):
    hdr("STEP 6 — push HF")
    if dry_run:
        ok("6", "dry-run: skipped")
        return
    r = subprocess.run(
        ["bash", "push_hf.sh"],
        capture_output=True, text=True, timeout=200,
    )
    if r.returncode != 0:
        info((r.stderr or "")[-300:])
        fail("6", "push_hf.sh failed")
    for line in (r.stdout or "").strip().splitlines()[-2:]:
        info(line)
    ok("6", "HF push OK")


# ─────────────────────────────────────────────────────────────
# STEP 7 — wait + verify
# ─────────────────────────────────────────────────────────────
def http_get(path, timeout=20):
    try:
        with urllib.request.urlopen(BASE_URL + path, timeout=timeout) as r:
            return r.status, r.read()
    except urllib.error.HTTPError as e:
        return e.code, b""
    except Exception:
        return 0, b""


def http_post_json(path, payload, timeout=120):
    req = urllib.request.Request(
        BASE_URL + path,
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json"},
        method="POST",
    )
    try:
        with urllib.request.urlopen(req, timeout=timeout) as r:
            return r.status, json.loads(r.read().decode())
    except urllib.error.HTTPError as e:
        try:
            return e.code, json.loads(e.read().decode())
        except Exception:
            return e.code, {}
    except Exception as e:
        return 0, {"error": f"{type(e).__name__}: {e}"}


def verify(role, user_input, wait_s, dry_run=False):
    hdr("STEP 7 — wait + live verify")
    if dry_run:
        ok("7", "dry-run: skipped")
        return
    if wait_s > 0:
        info(f"waiting {wait_s}s for HF rebuild...")
        time.sleep(wait_s)

    # poll with GET (not HEAD — /health/ready only accepts GET)
    up = False
    for i in range(1, 16):
        code, _ = http_get("/health/ready", timeout=15)
        if code == 200:
            info(f"HF up at attempt {i}")
            up = True
            break
        info(f"attempt {i}: HTTP {code}, waiting 15s")
        time.sleep(15)
    if not up:
        fail("7", "HF did not come back up in ~3 min")

    info("")
    info(f"-- live {role} test --")
    code, d = http_post_json("/api/agent/run", {
        "input": user_input,
        "session_id": f"ship-part-{int(time.time())}",
        "role": role,
    }, timeout=240)

    if code != 200:
        info(f"  HTTP {code}: {json.dumps(d)[:300]}")
        fail("7", "live verify HTTP not 200")

    r = d.get("result") or {}
    content = (r.get("content") or "").strip()
    err = d.get("detail") or d.get("error")
    steps = r.get("steps") or []
    tools_used = [s.get("tool") for s in steps]
    info(f"  provider: {r.get('provider')}")
    info(f"  steps:    {len(steps)}")
    info(f"  tools:    {tools_used}")
    info(f"  error:    {err!r}")
    info(f"  content:  {content[:200]!r}")
    if err:
        fail("7", "live verify returned an error")
    ok("7", "live verify OK")


# ─────────────────────────────────────────────────────────────
# main
# ─────────────────────────────────────────────────────────────
def main():
    global USE_COLOR
    ap = argparse.ArgumentParser(
        prog="ship.py",
        description="One-shot ship helper for Sunnyware.",
    )
    ap.add_argument("part", help="Part number, e.g. 157 or 157b")
    ap.add_argument("desc", help="Short description (one line)")
    ap.add_argument("--body", default=None,
                    help="Detailed body for HANDOFF.md (defaults to desc)")
    ap.add_argument("--wait", type=int, default=150,
                    help="Seconds to wait for HF rebuild (default: 150)")
    ap.add_argument("--verify-role", default="general",
                    help="Role for live verify (default: general)")
    ap.add_argument("--verify-input", default="Reply with the single word PONG.",
                    help="Input for live verify")
    ap.add_argument("--skip", default="",
                    help="Comma-separated steps to skip: "
                         "smokes,gate,docs,commit,gh,hf,verify")
    ap.add_argument("--dry-run", action="store_true",
                    help="Do everything except modify git / HF")
    ap.add_argument("--no-color", action="store_true")
    args = ap.parse_args()

    if args.no_color:
        USE_COLOR = False

    skip = {s.strip().lower() for s in args.skip.split(",") if s.strip()}
    body = args.body if args.body is not None else args.desc

    print("=" * 70)
    print(f"ship.py — Part {args.part}: {args.desc}")
    print(f"skip={sorted(skip) if skip else '(none)'}  dry_run={args.dry_run}")
    print("=" * 70)

    # 1. smokes (before touching git)
    if "smokes" in skip:
        info("[1] skipped")
    else:
        run_smokes()

    # 2. gate
    if "gate" in skip:
        info("[2] skipped")
    else:
        run_gate()

    # 3. docs
    if "docs" in skip:
        info("[3] skipped")
    else:
        update_docs(args.part, args.desc, body, dry_run=args.dry_run)

    # 4. commit
    head_hash = None
    if "commit" in skip:
        info("[4] skipped")
    else:
        head_hash = do_commit(args.part, args.desc, body, dry_run=args.dry_run)

    # 5. gh push
    if "gh" in skip:
        info("[5] skipped")
    else:
        push_github(dry_run=args.dry_run)

    # 6. hf push
    if "hf" in skip:
        info("[6] skipped")
    else:
        push_hf(dry_run=args.dry_run)

    # 7. verify
    if "verify" in skip:
        info("[7] skipped")
    else:
        verify(args.verify_role, args.verify_input, args.wait,
               dry_run=args.dry_run)

    print("")
    print("=" * 70)
    print(f"[DONE] Part {args.part} shipped"
          + (f"  (HEAD {head_hash})" if head_hash else ""))
    print("=" * 70)


if __name__ == "__main__":
    main()