#!/usr/bin/env python3
"""Time verified batches of prepared rowid lookups through three API shells."""

import argparse
from hashlib import sha256
import json
import os
from pathlib import Path
from statistics import median
import subprocess
from time import perf_counter_ns


def batch(count, wide_values):
    value = "(-9223372036854775807-1) + id*1729" if wide_values else "id*1729"
    setup = (
        "exec CREATE TABLE kv(id INTEGER PRIMARY KEY, value INTEGER NOT NULL); "
        "WITH RECURSIVE keys(id) AS (VALUES(1) UNION ALL SELECT id+1 FROM keys WHERE id<2048) "
        f"INSERT INTO kv SELECT id, {value} FROM keys;\n"
        "prepare SELECT value FROM kv WHERE id = ?1;\n"
    )
    operations = (
        f"bind-int 1 {1 + (index * 137) % 2048}\nstep\nstep\nreset\n"
        for index in range(count)
    )
    return (setup + "".join(operations) + "finalize\n").encode()


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("native", type=Path)
    parser.add_argument("original", type=Path)
    parser.add_argument("rewritten", type=Path)
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--mode", choices=("interpret", "jit"), default="interpret")
    parser.add_argument("--lookups", type=int, default=6000)
    parser.add_argument("--trials", type=int, default=3)
    parser.add_argument("--wide-values", action="store_true",
                        help="store signed 64-bit values that require SQLite's eight-byte record encoding")
    parser.add_argument("--runtime-arg", action="append", default=[], metavar="FLAG",
                        help="pass a runtime flag to both Graal binaries")
    args = parser.parse_args()
    if args.lookups < 1 or args.trials < 1:
        parser.error("lookups and trials must be positive")
    paths = {name: getattr(args, name).resolve(strict=True)
             for name in ("native", "original", "rewritten")}
    env = dict(os.environ, LC_ALL="C", TZ="UTC", CGRAAL_TRACE="0",
               CGRAAL_INTERPRET="1" if args.mode == "interpret" else "0")
    workload = batch(args.lookups, args.wide_values)
    results = {name: [] for name in paths}
    reference = None
    names = list(paths)
    for trial in range(args.trials):
        offset = trial % len(names)
        for name in names[offset:] + names[:offset]:
            arguments = [] if name == "native" else args.runtime_arg
            start = perf_counter_ns()
            proc = subprocess.run([str(paths[name]), *arguments, ":memory:"], input=workload, env=env,
                                  capture_output=True, timeout=120)
            elapsed = perf_counter_ns() - start
            if proc.returncode != 0 or proc.stderr:
                raise SystemExit(f"{name} failed: exit {proc.returncode}, stderr {proc.stderr[:500]!r}")
            if proc.stdout.count(b"ROW\tINTEGER ") != args.lookups:
                raise SystemExit(f"{name} returned an unexpected row count")
            if reference is None:
                reference = proc.stdout
            if proc.stdout != reference:
                raise SystemExit(f"{name} differed from the native C output")
            results[name].append(elapsed)
            print(f"{name} trial {trial + 1}: {elapsed / 1e9:.6f} s", flush=True)
    report = {
        "mode": args.mode,
        "runtime_arguments": args.runtime_arg,
        "lookups": args.lookups,
        "wide_values": args.wide_values,
        "input_sha256": sha256(workload).hexdigest(),
        "output_sha256": sha256(reference).hexdigest(),
        "variants": {name: {"path": str(paths[name]), "process_wall_ns": times,
                             "median_wall_ns": median(times)}
                     for name, times in results.items()},
    }
    args.output.write_text(json.dumps(report, indent=2) + "\n")


if __name__ == "__main__":
    main()
