#!/usr/bin/python3
"""Publish the CPU's power (Intel/AMD RAPL energy counters) to MQTT.

Every interval, the average power of each RAPL zone (CPU package, cores,
DRAM, ...) since the previous reading is published as a plain number in watts
to <prefix>/sensor/rapl_<zone>/state, e.g. x11sae-f/sensor/rapl_package_0/state.
With --discovery (the default), Home Assistant MQTT discovery configs are
published (retained) at start, so the values show up as power sensors.

The counters are cumulative energy, so the published value is the exact
average over the interval, not a snapshot. They wrap at max_energy_range_uj;
one wrap per interval is handled. Reading them needs root.
"""
import argparse
import json
import logging
import os
import re
import socket
import subprocess
import sys
import time

log = logging.getLogger("rapl-mqtt")


def zones(root):
    """Return {sensor id: zone directory} of all readable RAPL zones."""
    found = {}
    for d in sorted(os.listdir(root)):
        path = os.path.join(root, d)
        if not re.fullmatch(r"intel-rapl(:\d+)+", d) or not os.path.isfile(os.path.join(path, "energy_uj")):
            continue
        with open(os.path.join(path, "name")) as f:
            name = f.read().strip()
        sid = "rapl_" + re.sub(r"[^a-z0-9]+", "_", name.lower()).strip("_")
        if sid in found:            # e.g. "core" of a second package
            sid += "_" + d.split(":")[1]
        found[sid] = path
    return found


def read_uj(path, name="energy_uj"):
    with open(os.path.join(path, name)) as f:
        return int(f.read())


def watts(prev, cur, dt, max_range):
    """Average power in W between two counter readings in µJ, dt seconds apart."""
    delta = cur - prev
    if delta < 0:                   # the counter wrapped
        delta += max_range + 1
    return delta / 1e6 / dt


class Publisher:
    def __init__(self, args):
        self.args = args

    def publish(self, topic, payload, retain=False):
        if self.args.dry_run:
            print(f"{topic} {payload}{' (retained)' if retain else ''}", flush=True)
            return True
        cmd = ["mosquitto_pub", "-h", self.args.broker, "-p", str(self.args.port), "-t", topic, "-m", payload]
        if retain:
            cmd.append("-r")
        r = subprocess.run(cmd, capture_output=True, text=True)
        if r.returncode:
            log.warning("mosquitto_pub to %s failed: %s", topic, r.stderr.strip())
        return r.returncode == 0


def discovery(pub, prefix, host, sids):
    """Publish the Home Assistant discovery configs; False if one failed."""
    ok = True
    for sid in sids:
        cfg = {
            "name": sid.removeprefix("rapl_").replace("_", " ") + " power",
            "unique_id": f"{host}_{sid}",
            "state_topic": f"{prefix}/sensor/{sid}/state",
            "unit_of_measurement": "W",
            "device_class": "power",
            "state_class": "measurement",
            "expire_after": 3 * pub.args.interval,
            "device": {"identifiers": [host], "name": host},
        }
        ok &= pub.publish(f"{pub.args.discovery_prefix}/sensor/{host}_{sid}/config", json.dumps(cfg), retain=True)
    return ok


def main():
    host = socket.gethostname().split(".")[0]
    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    ap.add_argument("--broker", default="localhost", help="MQTT broker (default: %(default)s)")
    ap.add_argument("--port", type=int, default=1883)
    ap.add_argument("--interval", type=float, default=60, help="seconds between values (default: %(default)s)")
    ap.add_argument("--prefix", default=host, help="topic prefix (default: short hostname, %(default)s)")
    ap.add_argument("--no-discovery", dest="discovery", action="store_false",
                    help="don't publish Home Assistant discovery configs")
    ap.add_argument("--discovery-prefix", default="homeassistant")
    ap.add_argument("--sysfs", default="/sys/class/powercap", help=argparse.SUPPRESS)
    ap.add_argument("--count", type=int, default=0, help="stop after this many values per zone (default: run forever)")
    ap.add_argument("--dry-run", action="store_true", help="print instead of publishing")
    args = ap.parse_args()
    logging.basicConfig(level=logging.INFO, format="%(message)s")

    found = zones(args.sysfs)
    if not found:
        sys.exit(f"no RAPL zones under {args.sysfs}")
    log.info("zones: %s", ", ".join(f"{sid} ({p})" for sid, p in found.items()))
    max_range = {sid: read_uj(p, "max_energy_range_uj") for sid, p in found.items()}

    pub = Publisher(args)
    announced = not args.discovery

    prev = {sid: read_uj(p) for sid, p in found.items()}
    t_prev = time.monotonic()
    n = 0
    while not args.count or n < args.count:
        time.sleep(max(0, t_prev + args.interval - time.monotonic()))
        cur = {sid: read_uj(p) for sid, p in found.items()}
        t = time.monotonic()
        if not announced:           # retried until the broker accepted them
            announced = discovery(pub, args.prefix, args.prefix, found)
        for sid in found:
            w = watts(prev[sid], cur[sid], t - t_prev, max_range[sid])
            pub.publish(f"{args.prefix}/sensor/{sid}/state", f"{w:.1f}")
        prev, t_prev = cur, t
        n += 1


if __name__ == "__main__":
    main()
