"""Combine the four Strata measurement intervals without retaining host identifiers."""

import argparse
import json
import math
from pathlib import Path
from statistics import median

from measure import COUNTERS, IDENTITY, compare
from warm_batch import PROMPTS


SUCCESS = {"completed", "truncated"}
FAILURE = {"http_error", "invalid_response", "timeout"}


def request_summary(rows):
    if [row["case"] for row in rows] != [case for case, _ in PROMPTS]:
        raise ValueError("warm batch cases or order changed")
    checked = []
    completed = []
    stopped = False
    for row in rows:
        state = row["state"]
        item = {"case": row["case"], "state": state}
        if stopped:
            if state != "not_submitted":
                raise ValueError("a request was submitted after a warm batch failed")
        else:
            if state not in SUCCESS | FAILURE:
                raise ValueError("unexpected warm request state")
            elapsed = row["elapsed_ms"]
            if type(elapsed) not in (int, float) or not math.isfinite(elapsed) or elapsed < 0:
                raise ValueError("invalid request elapsed time")
            item["elapsed_ms"] = elapsed
            if state == "completed":
                completed.append(elapsed)
            if state in SUCCESS:
                tokens = row["completion_tokens"]
                if tokens is not None and (type(tokens) is not int or not 1 <= tokens <= 64):
                    raise ValueError("invalid completion token count")
                item["completion_tokens"] = tokens
            if state == "http_error":
                status = row["http_status"]
                if type(status) is not int or not 100 <= status <= 599 or status == 200:
                    raise ValueError("invalid HTTP failure status")
                item["http_status"] = status
            stopped = state in FAILURE
        checked.append(item)
    return {
        "requests": checked,
        "completed": len(completed),
        "median_completed_elapsed_ms": median(completed) if completed else None,
    }, stopped


def summarize(directory):
    def load(name):
        return json.loads((directory / f"{name}.json").read_text())

    result = {}
    last = None
    stopped = False
    for phase in ("idle", "startup", "warm-1", "warm-2"):
        if stopped:
            if (directory / f"{phase}.json").exists():
                raise ValueError("found a successor batch after a warm batch failed")
            result[phase] = {"state": "not_submitted"}
            break
        if phase.startswith("warm-"):
            batch = load(phase)
            before, after = batch["before"], batch["after"]
        else:
            before, after = load(f"{phase}-before"), load(f"{phase}-after")
        if last is not None:
            if any(last[key] != before[key] for key in IDENTITY):
                raise ValueError("device or boot changed between intervals")
            if before["sample_ns"] < last["sample_ns"] or any(
                before[key] < last[key] for key in COUNTERS
            ):
                raise ValueError("intervals overlap or counters went backwards")
        interval = compare(before, after)
        result[phase] = {"interval": interval}
        if phase.startswith("warm-"):
            if interval != batch["interval"]:
                raise ValueError("saved warm interval disagrees with the raw snapshots")
            requests, stopped = request_summary(batch["requests"])
            result[phase].update(requests)
        last = after
    return result


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("directory", type=Path)
    args = parser.parse_args()
    try:
        print(json.dumps(summarize(args.directory), indent=2, allow_nan=False))
    except (OSError, ValueError, KeyError, TypeError) as exc:
        parser.exit(1, f"could not reconcile measurements: {exc}\n")


if __name__ == "__main__":
    main()
