from pathlib import Path
import json, csv, collections, hashlib
from .paths import paths

P, D = paths()


def union(xs):
    spans = []
    for a, b in sorted(xs):
        if spans and a <= spans[-1][1]:
            spans[-1][1] = max(b, spans[-1][1])
        else:
            spans.append([a, b])
    return sum(b - a for a, b in spans)


def peak(xs):
    events = collections.defaultdict(float)
    for a, b, v in xs:
        events[a] += v
        events[b] -= v
    cur = ans = 0
    for t, d in sorted(events.items()):
        cur += d
        ans = max(cur, ans)
        assert cur >= -1e-6
    assert abs(cur) < 1e-6
    return ans


out = []
for pair in ["tmax", "deepswe"]:
    result = json.loads((D / (pair + "-result.json")).read_text())
    if pair == "tmax":
        rows = json.loads((P / "unified-oracle/tmax-intervals.json").read_text())
    else:
        rows = [
            json.loads(p.read_text()) for p in (P / "deepswe-full/rows").glob("*.json")
        ]
        rows = [r for r in rows if r["status"] == "generation_complete"]
    records = {r["id"]: r for r in rows}
    inv = (
        json.loads((P / "deepswe-full/IMAGE_INVENTORY.json").read_text())
        if pair == "deepswe"
        else None
    )
    for obj, reported in result["best"].items():
        path = D / f"{pair}-{obj}-schedule.csv"
        sched = list(csv.DictReader(path.open()))
        assert len(sched) == len(records) and {r["id"] for r in sched} == set(records)
        cpu = []
        ram = []
        env = []
        req = []
        cache = collections.defaultdict(list)
        ch = mh = 0
        finish = 0
        for s in sched:
            r = records[s["id"]]
            a = float(s["start"])
            b = float(s["end"])
            assert a >= 0 and abs(b - a - r["duration"]) < 1e-6
            finish = max(finish, b)
            assert s["task"] == r["task"]
            env.append((a, b, 1))
            cpu.append((a, b, r["cpu"]))
            ram.append((a, b, r["memory_gib"]))
            iv = r["model_intervals"]
            last = 0
            for x, y in iv:
                assert 0 <= x <= y <= r["duration"] + 1e-5 and x >= last - 1e-5
                last = y
                req.append((a + x, a + y))
            residual = r["duration"] - union(iv)
            ch += r["cpu"] * residual / 3600
            mh += r["memory_gib"] * residual / 3600
            if inv:
                for blob in inv["images"][r["task"]]:
                    cache[blob].append((a, b))
        vals = {
            "cpu": ch,
            "memory": mh,
            "gpu": 8 * union(req) / 3600,
            "storage": (
                sum(
                    inv["sizes"][k] / 1024**3 * union(xs) / 3600
                    for k, xs in cache.items()
                )
                if inv
                else None
            ),
        }
        caps = result["caps"]
        peaks = {"env": peak(env), "cpu": peak(cpu), "memory": peak(ram)}
        assert (
            peaks["env"] <= caps["concurrent_trials"]
            and peaks["cpu"] <= caps["cpu_whole_trial"] + 1e-6
            and peaks["memory"] <= caps["memory_whole_trial_gib"] + 1e-6
        )
        assert (
            finish / 60 <= result["deadline_minutes"] + 1e-6
            and abs(finish / 60 - reported["minutes"]) < 1e-6
        )
        assert abs(vals[obj] - reported["resource_hours"]) < 1e-6
        assert reported["resource_hours"] >= reported["lower_bound"] - 1e-6
        out.append(
            {
                "pair": pair,
                "objective": obj,
                "trials": len(sched),
                "minutes": finish / 60,
                "resource_hours": vals[obj],
                "all_resource_hours": vals,
                "whole_trial_peaks": peaks,
                "schedule_sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
                "verified": True,
            }
        )
(D / "VALIDATION.json").write_text(json.dumps(out, indent=2))
print(json.dumps(out, indent=2))