"""CarePulse Edge — entry point.   python -m carepulse_edge --config /etc/carepulse/edge.json"""
from __future__ import annotations

import argparse
import asyncio
import json
import logging
import logging.handlers
import os
import platform as _platform
import signal
import socket
import threading
import time

from . import __version__, hl7
from .folderwatch import FolderWatcher
from .mapping import DEFAULT_RATES, Mapper
from .modbus import ModbusPoller
from .platform import ApiError, Platform, Queue, Uploader
from .rtls import RtlsCollector, parse as rtls_parse

log = logging.getLogger("edge")
EVENT_PARAMS = {"bp_sys", "bp_dia", "bp_map"}  # NIBP is a spot measurement: always forward


class Edge:
    def __init__(self, cfg: dict):
        self.cfg = cfg
        os.makedirs(cfg.get("data_dir", "/var/lib/carepulse-edge"), exist_ok=True)
        self.platform = Platform(cfg["server"], cfg["token"], verify_tls=cfg.get("verify_tls", True))
        self.queue = Queue(os.path.join(cfg.get("data_dir", "/var/lib/carepulse-edge"), "queue.db"))
        self.stats: dict = {"started": time.time(), "hl7_messages": 0, "observations": 0, "unmapped": {}}
        self.mapper = Mapper(cfg.get("code_map"))
        self.sample = int(cfg.get("sample_seconds", 60))
        self.tz = None
        if cfg.get("timezone"):  # e.g. "+05:30": used when monitors send times without an offset
            sign = -1 if cfg["timezone"].startswith("-") else 1
            hh, mm = cfg["timezone"].lstrip("+-").split(":")
            import datetime as _d
            self.tz = _d.timezone(sign * _d.timedelta(hours=int(hh), minutes=int(mm)))
        self.last_sent: dict = {}
        self.uploader = Uploader(self.platform, self.queue, self.stats)
        self.threads: list[threading.Thread] = [self.uploader]

    # ------------------------------------------------------------------ HL7 handling
    def handle_hl7(self, raw: bytes, peer: str) -> str:
        try:
            msg = hl7.parse(raw)
        except Exception as e:
            log.warning("bad HL7 from %s: %s", peer, e)
            return ""
        self.stats["hl7_messages"] += 1
        try:
            if msg.type == "ORU^R40":
                self.on_alarms(msg)
            elif msg.type.startswith("ORU"):
                self.on_oru(msg)
            elif msg.type.startswith("ADT"):
                if self.cfg.get("accept_adt", True):
                    self.queue.put("adt", hl7.parse_adt(msg, self.tz))
                    self.uploader.wake.set()
            else:
                return hl7.ack(msg, "AR", f"Message type {msg.type} not supported")
            return hl7.ack(msg, "AA")
        except Exception as e:
            log.exception("error handling %s", msg.type)
            return hl7.ack(msg, "AE", str(e))

    def on_oru(self, msg: hl7.Message):
        o = hl7.parse_oru(msg, self.tz)
        now = time.time()
        readings = []
        bed_key = f"{o.ward}|{o.room}|{o.bed}|{o.patient_id}"
        for ob in o.obs:
            p = self.mapper.param(ob.code, ob.text, ob.system)
            if not p:
                k = f"{ob.code}^{ob.text}"
                self.stats["unmapped"][k] = self.stats["unmapped"].get(k, 0) + 1
                continue
            key = (bed_key, p)
            if p not in EVENT_PARAMS and now - self.last_sent.get(key, 0) < self.sample:
                continue
            self.last_sent[key] = now
            r = {"param": p, "value": ob.value, "measured_at": ob.time or time.strftime("%Y-%m-%dT%H:%M:%S%z")}
            u = Mapper.unit(ob.unit, p)
            if u:
                r["unit"] = u
            readings.append(r)
        head = self._head(o, msg)
        if o.waves and self.cfg.get("waveforms", False):
            self.on_waves(o, head)
        if not readings:
            return
        batch = dict(head, batch_id=f"hl7-{msg.control_id}"[:40], readings=readings)
        kind = Mapper.therapy_kind(r["param"] for r in readings)
        if kind:  # ventilator / pump / dialysis / CTG: keep the therapy session (drug, mode) in step with the device
            label = next((v for k, v in o.texts.items() if any(t in k for t in ("DRUG", "MEDICATION", "VENT_MODE", "MODE", "THERAPY"))), None)
            batch["therapy"] = {"kind": kind, **({"label": label[:160]} if label else {})}
        self.queue.put("readings", batch)
        self.stats["observations"] += len(readings)
        self.uploader.wake.set()

    def _head(self, o: hl7.ORU, msg: hl7.Message) -> dict:
        equip = next((ob.equipment for ob in o.obs if ob.equipment), "") or next((w.equipment for w in o.waves if w.equipment), "") \
            or f"{o.sending_app or 'MONITOR'}-{o.ward}-{o.bed or o.room}"
        head = {"device": {"serial": equip[:80], "manufacturer": self.cfg.get("monitor_vendor") or o.sending_app or "Patient monitor", "model": o.sending_facility or "HL7 monitor"},
                "location": {"ward_code": o.ward, "bed_code": o.bed, "candidates": hl7.bed_candidates(o.ward, o.room, o.bed)}}
        if o.patient_id and self.cfg.get("match_patient_id", True):
            head["patient"] = {"uhid": o.patient_id}
        return head

    def on_waves(self, o: hl7.ORU, head: dict):
        """Waveform arrays (OBX type NA) → /api/v1/waveforms. Unknown channels are counted in stats like unmapped numerics."""
        allowed = set(self.cfg.get("waveform_channels") or [])
        rates = self.cfg.get("waveform_rates", {})
        out = []
        for w in o.waves:
            ch = self.mapper.wave(w.code, w.text)
            if not ch or (allowed and ch not in allowed):
                k = f"WAVE:{w.code}^{w.text}"
                self.stats["unmapped"][k] = self.stats["unmapped"].get(k, 0) + 1
                continue
            rate = w.rate or rates.get(ch) or rates.get(ch.split("_")[0]) or DEFAULT_RATES.get(ch.split("_")[0]) or DEFAULT_RATES.get(ch, 125)
            vals = [v for v in w.values if v is not None]
            if not vals:
                continue
            out.append({"channel": ch, "sample_rate": rate, "start": w.time or time.strftime("%Y-%m-%dT%H:%M:%S%z"), "samples": [v if v is not None else vals[0] for v in w.values]})
        if out:
            self.queue.put("waveforms", dict(head, waveforms=out))
            self.stats["waveform_chunks"] = self.stats.get("waveform_chunks", 0) + len(out)
            self.uploader.wake.set()

    def on_alarms(self, msg: hl7.Message):
        o = hl7.parse_alarms(msg, self.tz)
        if not o.alarms:
            return
        body = dict(self._head(o, msg), alarms=[{"code": a.code, "text": a.text, "priority": a.priority, "state": a.state, "at": a.time} for a in o.alarms])
        self.queue.put("alarms", body)
        self.stats["alarms"] = self.stats.get("alarms", 0) + len(o.alarms)
        self.uploader.wake.set()

    def emit(self, batch: dict):
        self.queue.put("readings", batch)
        self.uploader.wake.set()

    def event(self, kind: str, body: dict):
        self.queue.put(kind, body)
        self.uploader.wake.set()

    # ------------------------------------------------------------------ MLLP server
    async def serve_mllp(self, host: str, port: int):
        async def client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
            peer = "%s:%s" % writer.get_extra_info("peername")[:2]
            log.info("HL7 connection from %s", peer)
            buf = b""
            try:
                while True:
                    chunk = await reader.read(65536)
                    if not chunk:
                        break
                    buf += chunk
                    while b"\x1c" in buf:
                        end = buf.index(b"\x1c")
                        start = buf.find(b"\x0b")
                        raw = buf[start + 1 if start != -1 and start < end else 0:end]
                        buf = buf[end + 2 if buf[end + 1:end + 2] == b"\r" else end + 1:]
                        reply = await asyncio.get_running_loop().run_in_executor(None, self.handle_hl7, raw, peer)
                        if reply:
                            writer.write(hl7.frame(reply))
                            await writer.drain()
            except (ConnectionError, asyncio.IncompleteReadError):
                pass
            finally:
                writer.close()
        server = await asyncio.start_server(client, host, port)
        log.info("HL7 MLLP listener on %s:%s", host, port)
        async with server:
            await server.serve_forever()

    # ------------------------------------------------------------------ ADT → monitors (patient names at the bedside)
    def adt_to_monitors(self):
        target = self.cfg.get("adt_out")
        state_file = os.path.join(self.cfg.get("data_dir", "."), "adt_state.json")
        try:
            sent = json.load(open(state_file))
        except Exception:
            sent = {}
        while True:
            try:
                beds = self.platform.get("/api/v1/gateway/beds").get("beds", [])
                for b in beds:
                    key = f"{b['his_ward_code'] or b['ward']}|{b['his_bed_code'] or b['bed_no']}"
                    who = str(b.get("patient_id") or "")
                    if sent.get(key) == who:
                        continue
                    ward, bed = key.split("|")
                    if who:
                        msg = hl7.build_adt("A01", b, ward, bed, receiving=target.get("receiving_app", "MONITORS"))
                    elif sent.get(key):
                        msg = hl7.build_adt("A03", {"uhid": sent.get(key + "#uhid", ""), "name": ""}, ward, bed, receiving=target.get("receiving_app", "MONITORS"))
                    else:
                        sent[key] = who
                        continue
                    self.send_mllp(target["host"], int(target.get("port", 2575)), msg)
                    sent[key] = who
                    sent[key + "#uhid"] = b.get("uhid") or ""
                    log.info("ADT %s sent for bed %s", "A01" if who else "A03", key)
                json.dump(sent, open(state_file, "w"))
            except Exception as e:
                log.warning("ADT to monitors: %s", e)
            time.sleep(int(target.get("interval", 30)))

    @staticmethod
    def send_mllp(host: str, port: int, text: str, timeout: float = 10.0) -> str:
        with socket.create_connection((host, port), timeout=timeout) as s:
            s.sendall(hl7.frame(text))
            buf = b""
            while b"\x1c" not in buf:
                chunk = s.recv(4096)
                if not chunk:
                    break
                buf += chunk
        return buf.strip(b"\x0b\x1c\r").decode(errors="replace")

    # ------------------------------------------------------------------ MQTT (optional, needs paho-mqtt)
    def mqtt_bridge(self):
        m = self.cfg["mqtt"]
        try:
            import paho.mqtt.client as mqtt  # type: ignore
        except ImportError:
            log.error("MQTT configured but paho-mqtt not installed: pip install paho-mqtt")
            return

        def on_message(_c, _u, msg):
            try:
                d = json.loads(msg.payload)
                rt = self.cfg.get("rtls", {})
                if getattr(self, "rtls", None) and any(msg.topic.startswith(t.rstrip("#").rstrip("+")) for t in rt.get("topics", [])):
                    self.rtls.add(rtls_parse(msg.payload, msg.topic.rsplit("/", 1)[-1]))
                    return
                if "nurse_call" in d:
                    self.event("nurse_call", d["nurse_call"])
                    return
                if "waveforms" in d or "alarms" in d:  # already in CarePulse API shape
                    self.queue.put("waveforms" if "waveforms" in d else "alarms", d)
                    self.uploader.wake.set()
                    return
                items = d["readings"] if "readings" in d else [{"param": d["param"], "value": d["value"], "unit": d.get("unit"), "measured_at": d.get("ts")}]
                serial = d.get("serial") or msg.topic.split("/")[-1]
                self.emit({"device": {"serial": serial, "manufacturer": d.get("manufacturer", "MQTT sensor")},
                           "location": {"name": d["location"]} if d.get("location") else {}, "readings": items})
            except Exception as e:
                log.warning("bad MQTT payload on %s: %s", msg.topic, e)

        c = mqtt.Client(client_id=f"carepulse-edge-{socket.gethostname()}")
        if m.get("username"):
            c.username_pw_set(m["username"], m.get("password"))
        if m.get("tls"):
            c.tls_set()
        c.on_message = on_message
        c.connect(m.get("host", "127.0.0.1"), int(m.get("port", 1883)))
        for t in m.get("topics", ["carepulse/#"]) + self.cfg.get("rtls", {}).get("topics", []):
            c.subscribe(t, qos=0)
        log.info("MQTT bridge subscribed to %s", m.get("topics", ["carepulse/#"]))
        c.loop_forever(retry_first_connection=True)

    # ------------------------------------------------------------------ heartbeat
    def heartbeat(self):
        while True:
            try:
                self.platform.post("/api/v1/gateway/heartbeat", {"app_version": f"edge-{__version__}",
                    "device_info": f"{socket.gethostname()} · {_platform.system()} {_platform.release()} · queue {self.queue.size()} · msgs {self.stats['hl7_messages']}"})
                self.stats.pop("auth_error", None)
            except ApiError as e:
                log.error("heartbeat refused: %s", e)
            except Exception as e:
                log.warning("heartbeat failed: %s", e)
            if self.stats["unmapped"]:
                log.info("unmapped HL7 codes (add to code_map if needed): %s", dict(list(self.stats["unmapped"].items())[:10]))
            time.sleep(60)

    def start_threads(self):
        self.uploader.start()
        threading.Thread(target=self.heartbeat, daemon=True, name="heartbeat").start()
        if self.cfg.get("modbus"):
            mp = ModbusPoller(self.cfg["modbus"], self.emit, self.event); mp.start(); self.threads.append(mp)
        if self.cfg.get("rtls"):
            self.rtls = RtlsCollector(self.cfg["rtls"], lambda b: self.event("rtls", b)); self.rtls.start(); self.threads.append(self.rtls)
        if self.cfg.get("folders"):
            fw = FolderWatcher(self.cfg["folders"], self.platform, self.stats); fw.start(); self.threads.append(fw)
        if self.cfg.get("adt_out", {}).get("host"):
            threading.Thread(target=self.adt_to_monitors, daemon=True, name="adt-out").start()
        if self.cfg.get("mqtt", {}).get("host"):
            threading.Thread(target=self.mqtt_bridge, daemon=True, name="mqtt").start()

    def run(self):
        self.start_threads()
        listeners = self.cfg.get("hl7_listeners") or [{"host": "0.0.0.0", "port": 2575}]

        async def main():
            await asyncio.gather(*(self.serve_mllp(l.get("host", "0.0.0.0"), int(l["port"])) for l in listeners))
        loop = asyncio.new_event_loop()
        for sig in (signal.SIGINT, signal.SIGTERM):
            try:
                loop.add_signal_handler(sig, loop.stop)
            except NotImplementedError:
                pass
        try:
            loop.run_until_complete(main())
        except RuntimeError:
            pass
        finally:
            log.info("stopping; %d items still queued (sent on next start)", self.queue.size())


def main():
    ap = argparse.ArgumentParser(description="CarePulse Edge gateway")
    ap.add_argument("--config", default=os.environ.get("CAREPULSE_EDGE_CONFIG", "/etc/carepulse/edge.json"))
    ap.add_argument("--pair", help="pairing code from CarePulse (Gateways & apps → Hospital edge gateway)")
    ap.add_argument("--server", help="CarePulse URL, used with --pair")
    args = ap.parse_args()
    cfg = json.load(open(args.config)) if os.path.exists(args.config) else {}
    logging.basicConfig(level=getattr(logging, cfg.get("log_level", "INFO")), format="%(asctime)s %(levelname)s %(name)s: %(message)s")
    if cfg.get("log_file"):
        logging.getLogger().addHandler(logging.handlers.RotatingFileHandler(cfg["log_file"], maxBytes=5_000_000, backupCount=5))
    if args.pair:
        server = (args.server or cfg.get("server", "")).rstrip("/")
        import urllib.request
        req = urllib.request.Request(server + "/api/v1/gateway/pair", data=json.dumps({"code": args.pair, "platform": "edge", "app_version": f"edge-{__version__}",
            "device_info": f"{socket.gethostname()} · {_platform.system()} {_platform.release()}"}).encode(), headers={"Content-Type": "application/json"}, method="POST")
        res = json.loads(urllib.request.urlopen(req, timeout=20).read())
        cfg.update({"server": server, "token": res["token"]})
        os.makedirs(os.path.dirname(os.path.abspath(args.config)), exist_ok=True)
        json.dump(cfg, open(args.config, "w"), indent=2)
        os.chmod(args.config, 0o600)
        print(f"Paired with {res['client']['name']} as gateway #{res['gateway']['id']}. Config saved to {args.config}")
        return
    if not cfg.get("token"):
        raise SystemExit("Not paired. Run: python -m carepulse_edge --pair CODE --server https://your-carepulse --config " + args.config)
    log.info("CarePulse Edge %s starting", __version__)
    Edge(cfg).run()


if __name__ == "__main__":
    main()
