import os, sys, unittest
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
from carepulse_edge import hl7
from carepulse_edge.mapping import Mapper
from carepulse_edge.folderwatch import xml_values
from carepulse_edge.modbus import decode

MINDRAY = "\r".join([
    "MSH|^~\\&|MINDRAY_EGATEWAY^00A037009A0053DE^EUI-64|MINDRAY|||20261118103000+0530||ORU^R01^ORU_R01|1001|P|2.6|||AL|NE||UNICODE UTF-8|||IHE_PCD_001^IHE PCD^1.3.6.1.4.1.19376.1.6.1.1.1^ISO",
    "PID|||UH777001^^^HOSP^MR||Kale^Vinod||19570302|M",
    "PV1||I|ICU^^ICU-3",
    "OBR|1|||182777000^monitoring of patient^SNOMED-CT|||20261118103000+0530",
    "OBX|1|NM|147842^MDC_ECG_HEART_RATE^MDC|1.2.1.1|112|264864^MDC_DIM_BEAT_PER_MIN^MDC|||||R|||20261118103000+0530||||BED3-MON^Mindray",
    "OBX|2|NM|150456^MDC_PULS_OXIM_SAT_O2^MDC|1.3.1.1|91|262688^MDC_DIM_PERCENT^MDC|||||R",
    "OBX|3|NM|150301^MDC_PRESS_CUFF_SYS^MDC|1.4.1.1|98|266016^MDC_DIM_MMHG^MDC|||||R",
    "OBX|4|NM|150302^MDC_PRESS_CUFF_DIA^MDC|1.4.1.2|58|266016^MDC_DIM_MMHG^MDC|||||R",
    "OBX|5|NM|151562^MDC_RESP_RATE^MDC|1.5.1.1|24|264928^MDC_DIM_RESP_PER_MIN^MDC|||||R",
    "OBX|6|NM|150344^MDC_TEMP^MDC|1.6.1.1|38.4|268192^MDC_DIM_DEGC^MDC|||||R",
    "OBX|7|NM|999999^MDC_UNKNOWN_THING^MDC|1.7|5|262688^MDC_DIM_PERCENT^MDC|||||R",
    "OBX|8|NM|150456^MDC_PULS_OXIM_SAT_O2^MDC|1.3.1.1||262688^MDC_DIM_PERCENT^MDC|||||X",
])
PHILIPS = "\r".join([
    "MSH|^~\\&|PIC_IX|PHILIPS|HIS||20261118104500||ORU^R01|PX55|P|2.3",
    "PID|1||UH240104||Patil^Suresh",
    "PV1|1|I|W3^05^2",
    "OBR|1||||||20261118104500",
    "OBX|1|NM|0002-4182^HR^MDIL||80|0004-0aa0^bpm^MDIL||||||F",
    "OBX|2|NM|0002-4bb8^SpO2^MDIL||97|0004-0220^%^MDIL||||||F",
    "OBX|3|NM|0002-4a05^NBPs^MDIL||132|0004-0f20^mmHg^MDIL||||||F",
    "OBX|4|NM|0002-4a06^NBPd^MDIL||84|0004-0f20^mmHg^MDIL||||||F",
    "OBX|5|NM|0002-5012^awRR^MDIL||16|0004-0ae0^rpm^MDIL||||||F",
])
ADT = "\r".join([
    "MSH|^~\\&|CARESOFT_HIS|HOSP|CAREPULSE|EDGE|20261118100000||ADT^A01^ADT_A01|A900|P|2.5",
    "EVN|A01|20261118100000",
    "PID|1||UH777001^^^HOSP^MR||Kale^Vinod^R||19570302|M|||12 MG Road^^Pune^MH^411001||9822001100",
    "PV1|1|I|ICU^^ICU-3||||D123^Rao^Ananya||||||||||||IP-5521",
])


class HL7Tests(unittest.TestCase):
    def test_mindray_oru(self):
        m = hl7.parse(MINDRAY)
        self.assertEqual(m.type, "ORU^R01")
        self.assertEqual(m.control_id, "1001")
        o = hl7.parse_oru(m)
        self.assertEqual(o.patient_id, "UH777001")
        self.assertEqual((o.ward, o.bed), ("ICU", "ICU-3"))
        mp = Mapper()
        got = {mp.param(x.code, x.text, x.system): (x.value, Mapper.unit(x.unit, "")) for x in o.obs if mp.param(x.code, x.text, x.system)}
        self.assertEqual(got["hr"], (112.0, "/min"))
        self.assertEqual(got["spo2"], (91.0, "%"))
        self.assertEqual(got["bp_sys"], (98.0, "mmHg"))
        self.assertEqual(got["rr"], (24.0, "/min"))
        self.assertEqual(got["temp"], (38.4, "Cel"))
        self.assertEqual(len(o.obs), 7)                      # status X dropped
        self.assertTrue(o.obs[0].time.startswith("2026-11-18T10:30:00+05:30"))
        self.assertEqual(o.obs[0].equipment, "BED3-MON")

    def test_philips_text_codes(self):
        o = hl7.parse_oru(hl7.parse(PHILIPS))
        mp = Mapper()
        got = {mp.param(x.code, x.text, x.system): x.value for x in o.obs}
        self.assertEqual(got, {"hr": 80, "spo2": 97, "bp_sys": 132, "bp_dia": 84, "rr": 16})
        self.assertIn("2", hl7.bed_candidates(o.ward, o.room, o.bed))
        self.assertIn("W3-2", hl7.bed_candidates(o.ward, o.room, o.bed))

    def test_ack(self):
        a = hl7.ack(hl7.parse(MINDRAY))
        self.assertIn("MSA|AA|1001", a)
        self.assertTrue(a.startswith("MSH|^~\\&|CAREPULSE|EDGE|MINDRAY_EGATEWAY^00A037009A0053DE^EUI-64|MINDRAY|"))

    def test_adt(self):
        b = hl7.parse_adt(hl7.parse(ADT))
        self.assertEqual(b["event"], "admit")
        self.assertEqual(b["patient"]["name"], "Vinod Kale")
        self.assertEqual(b["patient"]["dob"], "1957-03-02")
        self.assertEqual(b["admission"]["bed_code"], "ICU-3")
        self.assertEqual(b["admission"]["id"], "IP-5521")
        self.assertEqual(b["admission"]["doctor"], "Ananya Rao")

    def test_build_adt_roundtrip(self):
        msg = hl7.build_adt("A01", {"uhid": "UH1", "name": "Asha Patil", "dob": "1960-01-02", "gender": "F"}, "ICU", "ICU-3")
        b = hl7.parse_adt(hl7.parse(msg))
        self.assertEqual(b["patient"]["uhid"], "UH1")
        self.assertEqual(b["admission"]["bed_code"], "ICU-3")

    def test_code_map_override(self):
        mp = Mapper({"MY_SAT": "spo2", "HR": ""})
        self.assertEqual(mp.param("x", "MY_SAT"), "spo2")
        self.assertIsNone(mp.param("0002-4182", "HR"))

    def test_xml_ecg(self):
        vals, pid = xml_values("<RestingECG><PatientDemographics><PatientID>UH777001</PatientID></PatientDemographics><RestingECGMeasurements><VentricularRate>96</VentricularRate></RestingECGMeasurements></RestingECG>")
        self.assertEqual(vals["hr"], 96); self.assertEqual(pid, "UH777001")

    def test_modbus_decode(self):
        self.assertEqual(decode([0xFFE2], 0, "int16"), -30)
        self.assertAlmostEqual(decode([0x40A0, 0x0000], 0, "float32"), 5.0)
        self.assertAlmostEqual(decode([0x0000, 0x40A0], 0, "float32_le"), 5.0)

    def test_hl7_time(self):
        self.assertEqual(hl7.hl7_time("20261118103000+0530"), "2026-11-18T10:30:00+05:30")
        self.assertIsNone(hl7.hl7_time(""))


WAVE = "\r".join([
    "MSH|^~\\&|MINDRAY_EGATEWAY^0001^EUI-64|MINDRAY|||20261118103000.000+0530||ORU^R01^ORU_R01|W1|P|2.6|||AL|NE||UNICODE UTF-8|||IHE_PCD_001^IHE PCD^1.3.6.1.4.1.19376.1.6.1.1.1^ISO",
    "PID|||IP880102^^^HOSP^MR||Gupta^Harish",
    "PV1||I|ICU^^ICU-3",
    "OBR|1|||WAVE|||20261118103000.000+0530",
    "OBX|1|NM|0^MDC_ATTR_SAMP_RATE^MDC|1.0.0.1|250|^MDC_DIM_PER_SEC||||||F",
    "OBX|2|NA|131330^MDC_ECG_ELEC_POTL_II^MDC|1.0.0.2|0.01^0.02^0.9^-0.1^0.0|^mV|||||F|||20261118103000.000+0530",
    "OBX|3|NA|150452^MDC_PULS_OXIM_PLETH^MDC|1.0.0.3|10^20^30^40^50||||||F|||20261118103000.000+0530",
])
VENT = "\r".join([
    "MSH|^~\\&|MINDRAY_SV800|MINDRAY|||20261118103000+0530||ORU^R01^ORU_R01|V1|P|2.6",
    "PID|||IP880102^^^HOSP^MR||Gupta^Harish",
    "PV1||I|ICU^^ICU-3",
    "OBR|1|||VENT|||20261118103000+0530",
    "OBX|1|NM|^MDC_PRESS_AWAY_END_EXP_POS^MDC||8|^cmH2O||||||F",
    "OBX|2|NM|^MDC_PRESS_AWAY_INSP_PEAK^MDC||27|^cmH2O||||||F",
    "OBX|3|NM|^MDC_VOL_AWAY_TIDAL^MDC||452|^mL||||||F",
    "OBX|4|NM|^MDC_CONC_AWAY_O2_INSP^MDC||50|^%||||||F",
    "OBX|5|ST|^MDC_VENT_MODE^MDC||SIMV-VC||||||F",
])
ALARM = "\r".join([
    "MSH|^~\\&|BBRAUN_SPACE|BBRAUN|||20261118103500+0530||ORU^R40^ORU_R40|A1|P|2.6",
    "PID|||IP880103^^^HOSP^MR||Qureshi^Shabana",
    "PV1||I|ICU^^ICU-4",
    "OBR|1|||ALARM|||20261118103500+0530",
    "OBX|1|ST|196802^MDC_EVT_OCCL^MDC|1.1.1.1|Downstream occlusion|||PH~ST|||||F|||20261118103500+0530",
    "OBX|2|ST|68481^MDC_ATTR_ALERT_STATE^MDC|1.1.1.2|start||||||F",
])


class Phase3(unittest.TestCase):
    def test_waveform_na(self):
        o = hl7.parse_oru(hl7.parse(WAVE))
        self.assertEqual(len(o.waves), 2)
        m = Mapper()
        self.assertEqual(m.wave(o.waves[0].code, o.waves[0].text), "ecg_ii")
        self.assertEqual(m.wave(o.waves[1].code, o.waves[1].text), "pleth")
        self.assertEqual(o.waves[0].rate, 250.0)
        self.assertEqual(o.waves[0].values[2], 0.9)
        self.assertTrue(o.waves[0].time.startswith("2026-11-18T10:30:00.000+05:30"))

    def test_ventilator_mapping_and_mode(self):
        o = hl7.parse_oru(hl7.parse(VENT))
        m = Mapper()
        params = [m.param(x.code, x.text, x.system) for x in o.obs]
        self.assertEqual(params, ["peep", "ppeak", "vt", "fio2"])
        self.assertEqual(Mapper.unit("cmH2O", "peep"), "cmH2O")
        self.assertEqual(Mapper.therapy_kind(params), "ventilation")
        self.assertEqual(o.texts.get("MDC_VENT_MODE"), "SIMV-VC")

    def test_pump_alarm_r40(self):
        msg = hl7.parse(ALARM)
        self.assertEqual(msg.type, "ORU^R40")
        o = hl7.parse_alarms(msg)
        self.assertEqual(len(o.alarms), 1)
        a = o.alarms[0]
        self.assertEqual((a.priority, a.state), ("high", "active"))
        self.assertIn("occlusion", a.text.lower())
        self.assertEqual(o.bed, "ICU-4")


class Phase4(unittest.TestCase):
    def test_rtls_formats(self):
        from carepulse_edge.rtls import parse
        a = parse('[{"mac":"ac233f001122","rssi":-61}]', "gw-icu-1")
        self.assertEqual(a, [{"tag": "AC:23:3F:00:11:22", "anchor": "GW-ICU-1", "rssi": -61}])
        b = parse({"gmac": "AABBCCDDEEFF", "obj": [{"dmac": "AC233F001122", "rssi": "-70", "battery": 88, "button": True}]})
        self.assertEqual((b[0]["anchor"], b[0]["rssi"], b[0]["button"]), ("AA:BB:CC:DD:EE:FF", -70, True))
        self.assertEqual(parse({"gateway": "GW1", "devices": [{"mac": "X", "foo": 1}]}), [])

    def test_rtls_window_keeps_strongest_and_flags(self):
        from carepulse_edge.rtls import RtlsCollector
        out = []
        c = RtlsCollector({"interval": 0.01, "tag_prefixes": ["AC:23:3F"]}, out.append)
        c.add([{"tag": "AC:23:3F:00:11:22", "anchor": "G1", "rssi": -80, "tamper": True}, {"tag": "AC:23:3F:00:11:22", "anchor": "G1", "rssi": -60},
               {"tag": "11:22:33:44:55:66", "anchor": "G1", "rssi": -40}])
        v = list(c.buf.values())
        self.assertEqual(len(v), 1)
        self.assertEqual((v[0]["rssi"], v[0]["tamper"]), (-60, True))
        self.assertEqual(c.stats["ignored"], 1)

    def test_modbus_nurse_call_edges(self):
        from carepulse_edge import modbus
        events, vals = [], iter([[0], [1], [3], [2], [0]])
        modbus.read_registers = lambda *a, **k: next(vals)
        p = modbus.ModbusPoller([{"name": "IO", "host": "x", "points": [
            {"register": 0, "type": "uint16", "mask": 1, "param": "nc", "nurse_call": {"bed_code": "W3-4", "type": "normal"}},
            {"register": 0, "type": "uint16", "mask": 2, "param": "be", "nurse_call": {"bed_code": "W3-4", "type": "bed_exit"}}]}],
            lambda b: events.append(("reading", b)), lambda k, b: events.append((b["type"], b["state"])))
        for _ in range(5):
            p.poll(p.devices[0])
        self.assertEqual(events, [("normal", "call"), ("bed_exit", "call"), ("normal", "cancel"), ("bed_exit", "cancel")])


if __name__ == "__main__":
    unittest.main()
