"""Read Linux NVMe namespace and system swap counters without changing settings."""

import argparse
import json
import os
from pathlib import Path
import re
import time


COUNTERS = ("read_bytes", "written_bytes", "swap_in_bytes", "swap_out_bytes")
IDENTITY = ("namespace", "device", "boot", "page_bytes")


def nvme_composite_temp(base):
    try:
        controller = (base / "device").resolve(strict=True)
    except OSError:
        return None
    if not re.fullmatch(r"nvme[0-9]+", controller.name):
        return None
    candidates = set(controller.glob("hwmon*/temp1_input"))
    candidates.update(controller.glob("hwmon/hwmon*/temp1_input"))
    readings = []
    for path in sorted(candidates):
        try:
            if (path.parent / "name").read_text().strip() != "nvme":
                continue
            if (path.parent / "temp1_label").read_text().strip() != "Composite":
                continue
            readings.append(int(path.read_text()) / 1000)
        except (OSError, ValueError):
            continue
    return readings[0] if len(readings) == 1 else None


def snapshot(namespace, *, block=Path("/sys/class/block"), proc=Path("/proc")):
    if not re.fullmatch(r"nvme[0-9]+n[0-9]+", namespace):
        raise ValueError("use a whole NVMe namespace such as nvme0n1")
    base = block / namespace
    sectors = [int(field) for field in (base / "stat").read_text().split()]
    if len(sectors) < 7 or min(sectors) < 0:
        raise ValueError("unexpected block counters")
    swap = dict(line.split() for line in (proc / "vmstat").read_text().splitlines())
    page_bytes = os.sysconf("SC_PAGE_SIZE")
    return {
        "namespace": namespace,
        "device": (base / "dev").read_text().strip(),
        "boot": (proc / "sys/kernel/random/boot_id").read_text().strip(),
        "page_bytes": page_bytes,
        "sample_ns": time.monotonic_ns(),
        "read_bytes": sectors[2] * 512,
        "written_bytes": sectors[6] * 512,
        "swap_in_bytes": int(swap["pswpin"]) * page_bytes,
        "swap_out_bytes": int(swap["pswpout"]) * page_bytes,
        "nvme_composite_temp_c": nvme_composite_temp(base),
    }


def compare(before, after):
    if any(before[key] != after[key] for key in IDENTITY):
        raise ValueError("device or boot changed between samples")
    elapsed = after["sample_ns"] - before["sample_ns"]
    deltas = {key: after[key] - before[key] for key in COUNTERS}
    if elapsed <= 0 or min(deltas.values()) < 0:
        raise ValueError("time or counters went backwards")
    return {
        "namespace": before["namespace"], "elapsed_seconds": elapsed / 1e9, **deltas,
        "nvme_composite_temp_before_c": before.get("nvme_composite_temp_c"),
        "nvme_composite_temp_after_c": after.get("nvme_composite_temp_c"),
    }


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    commands = parser.add_subparsers(dest="command", required=True)
    commands.add_parser("snapshot").add_argument("namespace")
    delta = commands.add_parser("delta")
    delta.add_argument("before", type=Path)
    delta.add_argument("after", type=Path)
    args = parser.parse_args()
    try:
        if args.command == "snapshot":
            result = snapshot(args.namespace)
        else:
            result = compare(json.loads(args.before.read_text()), json.loads(args.after.read_text()))
    except (OSError, ValueError, KeyError) as exc:
        parser.exit(1, f"{exc}\n")
    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()
