#!/usr/bin/env python3
"""Run four download cases twice, using only the disposable container's loopback."""
import hashlib
import json
import os
from pathlib import Path
import subprocess
import sys
import time
import uuid

ROOT = Path(__file__).resolve().parent
OUT = Path(sys.argv[1] if len(sys.argv) > 1 else "results").resolve()
OUT.mkdir(parents=True, exist_ok=False)
DATA = OUT / "data"
DATA.mkdir()
PAYLOAD = DATA / "payload.bin"
PAYLOAD.write_bytes(bytes(4 * 1024 * 1024))
EXPECTED = hashlib.sha256(PAYLOAD.read_bytes()).hexdigest()
NAME = "nginx-rate-lab-" + uuid.uuid4().hex[:10]
IMAGE = os.environ.get("NGINX_IMAGE", "nginx:1.28.3")
TRANSCRIPT = (OUT / "run.log").open("w", buffering=1)
results = []


def log(text):
    print(text, flush=True)
    TRANSCRIPT.write(text + "\n")


def command(args):
    proc = subprocess.run(args, text=True, stdout=subprocess.PIPE,
                          stderr=subprocess.STDOUT, timeout=90)
    log("$ " + " ".join(args))
    log(proc.stdout.rstrip())
    if proc.returncode:
        raise RuntimeError(f"command failed: {proc.returncode}")
    return proc.stdout


def start(label, location):
    args = ["docker", "exec", NAME, "curl", "--noproxy", "*", "--http1.1",
            "--silent", "--show-error", "--max-time", "70",
            "--output", f"/results/{label}.body",
            "--write-out", "%{http_code} %{size_download} %{time_total} %{speed_download}\n",
            f"http://127.0.0.1:8080/{location}/payload.bin?case={label}"]
    log("$ " + " ".join(args))
    return subprocess.Popen(args, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)


def finish(proc, label):
    stdout, stderr = proc.communicate(timeout=80)
    (OUT / f"{label}.curl.txt").write_text(stdout)
    (OUT / f"{label}.stderr.txt").write_text(stderr)
    log(label + " curl: " + stdout.strip())
    if stderr:
        log(stderr.rstrip())
    assert proc.returncode == 0
    status, size, seconds, speed = stdout.split()
    body = OUT / f"{label}.body"
    actual = body.stat().st_size
    digest = hashlib.sha256(body.read_bytes()).hexdigest()
    row = dict(label=label, status=int(status), bytes=int(size),
               seconds=float(seconds), bytesPerSecond=float(speed), sha256=digest)
    assert actual == row["bytes"]
    if row["status"] == 200:
        assert actual == 4194304 and digest == EXPECTED
    else:
        assert row["status"] == 503 and label.endswith("conn-b")
    log(label + " sha256=" + digest)
    return row


try:
    command(["docker", "image", "inspect", IMAGE, "--format",
             "{{.Id}} {{json .RepoDigests}} {{.Architecture}}"])
    command(["docker", "run", "--rm", "--detach", "--pull=never",
             "--name", NAME, "--network", "none", "--cpus", "1", "--memory", "128m",
             "--mount", f"type=bind,source={ROOT / 'nginx.conf'},target=/etc/nginx/nginx.conf,readonly",
             "--mount", f"type=bind,source={DATA},target=/data,readonly",
             "--mount", f"type=bind,source={OUT},target=/results",
             IMAGE])
    command(["docker", "exec", NAME, "nginx", "-t"])
    command(["docker", "exec", NAME, "nginx", "-V"])
    command(["docker", "exec", NAME, "curl", "--version"])
    command(["docker", "inspect", NAME, "--format",
             "network={{.HostConfig.NetworkMode}} ports={{json .HostConfig.PortBindings}}"])
    log("payload.bytes=4194304 payload.sha256=" + EXPECTED)
    for repeat in (1, 2):
        for case, location, suffixes in [
            ("unlimited", "unlimited", ["unlimited"]),
            ("single", "limited", ["single"]),
            ("double", "limited", ["double-a", "double-b"]),
            ("conn", "one", ["conn-a", "conn-b"]),
        ]:
            labels = [f"r{repeat}-{suffix}" for suffix in suffixes]
            begin = time.monotonic()
            procs = [start(labels[0], location)]
            if len(labels) == 2:
                if case == "conn":
                    first = OUT / f"{labels[0]}.body"
                    deadline = time.monotonic() + 10
                    while not first.exists() or first.stat().st_size == 0:
                        assert procs[0].poll() is None and time.monotonic() < deadline
                        time.sleep(0.02)
                    log(labels[0] + " active: received body bytes before starting second request")
                procs.append(start(labels[1], location))
            rows = [finish(proc, label) for proc, label in zip(procs, labels)]
            elapsed = time.monotonic() - begin
            assert [r["status"] for r in rows] == ([200, 503] if case == "conn" else [200] * len(rows))
            total = sum(r["bytes"] for r in rows if r["status"] == 200)
            group = dict(repeat=repeat, case=case, requests=rows,
                         wallSeconds=round(elapsed, 6), successfulBytes=total,
                         aggregateBytesPerSecond=round(total / elapsed, 3))
            results.append(group)
            log("GROUP " + json.dumps(group, sort_keys=True))
    (OUT / "results.json").write_text(json.dumps(results, indent=2) + "\n")
    log("All 8 case-runs passed; 10 successful payloads matched byte count and SHA-256.")
finally:
    subprocess.run(["docker", "rm", "--force", NAME], stdout=subprocess.DEVNULL,
                   stderr=subprocess.DEVNULL, timeout=30)
    TRANSCRIPT.close()
