"""Generate benign browser activity on a disposable VM. Python standard library only.

This serves actual local files; it does not generate forensic records or outcomes.
Bind is loopback only. No executable, credentials or external service is involved.
"""
import argparse
import hashlib
import html
import json
from datetime import datetime, timezone
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
import shutil
import threading
from urllib.parse import parse_qs, urlsplit


def utc_now():
    return datetime.now(timezone.utc).isoformat()


def prepare(root, image=None):
    root = Path(root).resolve()
    if root.exists():
        raise ValueError("Site folder already exists. Retain it and use a new folder for another run.")
    photo = Path(image).resolve() if image else None
    if photo and (not photo.is_file() or photo.read_bytes()[:3] != b"\xff\xd8\xff"):
        raise ValueError("Image must be an approved existing JPEG, not an executable or renamed file.")
    root.mkdir(parents=True, exist_ok=False)
    marker = root / "training-download.txt"
    marker.write_text("SUSA browser training: harmless download created at " + utc_now() + "\n", encoding="utf-8")
    files = [marker]
    if photo:
        copied = root / "approved-photo.jpg"
        shutil.copyfile(photo, copied)
        files.append(copied)
    manifest = {
        "purpose": "Benign source files, not browser evidence or expected forensic results",
        "createdUTC": utc_now(),
        "imageSource": str(photo) if photo else None,
        "files": [{"name": f.name, "bytes": f.stat().st_size,
                   "sha256": hashlib.sha256(f.read_bytes()).hexdigest()} for f in files],
    }
    (root / "source-manifest.json").write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
    return root


def make_server(root, port=8765):
    root = Path(root).resolve()
    log = (root / "requests.jsonl").open("x", encoding="utf-8", buffering=1)
    lock = threading.Lock()

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, format_string, *args):
            with lock:
                log.write(json.dumps({"recordedUTC": utc_now(), "request": self.requestline,
                                      "message": format_string % args}) + "\n")

        def respond(self, body, mime, *, cache=False, attachment=False, cookie=False):
            self.send_response(200)
            self.send_header("Content-Type", mime)
            self.send_header("Content-Length", str(len(body)))
            self.send_header("Cache-Control", "public, max-age=86400" if cache else "no-store")
            if attachment:
                self.send_header("Content-Disposition", 'attachment; filename="training-download.txt"')
            if cookie:
                self.send_header("Set-Cookie", "SUSA_Training=benign_lab; Path=/; SameSite=Lax; HttpOnly")
                self.send_header("Set-Cookie", "SUSA_TrainingPersist=benign_lab; Max-Age=3600; Path=/; SameSite=Lax; HttpOnly")
            self.end_headers()
            self.wfile.write(body)

        def do_GET(self):
            parsed = urlsplit(self.path)
            if parsed.path == "/download":
                self.respond((root / "training-download.txt").read_bytes(), "text/plain; charset=utf-8", attachment=True)
                return
            if parsed.path == "/photo.jpg":
                photo = root / "approved-photo.jpg"
                if not photo.exists():
                    self.send_error(404, "No approved JPEG supplied for this run")
                    return
                self.respond(photo.read_bytes(), "image/jpeg", cache=True)
                return
            if parsed.path not in {"/", "/help", "/case-notes", "/search", "/set-cookie"}:
                self.send_error(404)
                return
            query = parse_qs(parsed.query).get("q", [""])[0]
            message = {
                "/": "Open Help in your first training profile. Use Case notes in the comparison profile.",
                "/help": "Support page: the download is a harmless text attachment. Record the action time.",
                "/case-notes": "Comparison page: this is a separate browser-profile action.",
                "/search": "Local query marker: " + query + ". This is not a recognised public search engine.",
                "/set-cookie": "Benign session and one-hour cookies were set. These are not logins or authentication tokens.",
            }[parsed.path]
            image_markup = '<img src="/photo.jpg" alt="Approved training JPEG">' if (root / "approved-photo.jpg").exists() else "<p>No JPEG supplied; image practice needs an approved source photo.</p>"
            body = ("<!doctype html><html lang=en><meta charset=utf-8><title>SUSA browser training</title>"
                    "<main><h1>SUSA browser training</h1><p>Local, benign activity on a disposable VM.</p>"
                    f"<p>{html.escape(message)}</p>"
                    '<nav><a href="/help">Help</a> | <a href="/case-notes">Case notes</a> | '
                    '<a href="/download">Download training text</a> | '
                    '<a href="/set-cookie">Set benign session cookie</a> | '
                    '<a href="/search?q=blue+heron+training">Local query marker</a></nav>'
                    f"{image_markup}</main></html>").encode("utf-8")
            self.respond(body, "text/html; charset=utf-8", cookie=parsed.path == "/set-cookie")

    try:
        server = ThreadingHTTPServer(("127.0.0.1", port), Handler)
    except Exception:
        log.close()
        raise
    server.training_log = log
    return server


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--root", required=True, help="Fresh site folder on the disposable VM")
    parser.add_argument("--image", help="Optional approved JPEG for the cache lab")
    parser.add_argument("--port", type=int, default=8765)
    args = parser.parse_args()
    server = None
    try:
        root = prepare(args.root, args.image)
        server = make_server(root, args.port)
        print(f"Training site: http://127.0.0.1:{server.server_port}/", flush=True)
        print(f"Source files and actual hashes: {root / 'source-manifest.json'}", flush=True)
        print("Record your browser actions separately. Request logs do not prove a person or execution.", flush=True)
        print("Stop with Ctrl+C. Keep the files/log; use a fresh root on the next run.", flush=True)
        server.serve_forever()
    except KeyboardInterrupt:
        pass
    except (OSError, ValueError) as error:
        parser.exit(1, f"Stopped: {error}\n")
    finally:
        if server:
            server.server_close()
            server.training_log.close()


if __name__ == "__main__":
    main()
