"""Phase 4 end-to-end: floor maps + RTLS (API and edge BLE listener), hysteresis, infant protection (exit, tamper, not heard,
lockdown webhook), duress, asset exit, nurse call API + presence answering, utilities (gas / LMO time-to-critical),
biomedical maintenance (breakdown → downtime → completion, plans → auto work orders, uptime CSV), analytics,
scheduled reports, subscription billing with GST variants and invoice numbering."""
import html as _html, json, os, re, shutil, subprocess, sys, threading, time, http.server
import requests
sys.path.insert(0, "/home/claude/tests")
from e2e_lib import check, csrf, totp, FAILS, BASE

PLAT = "/home/claude/carepulse/platform"
EDGE_DIR = "/tmp/edge4"; shutil.rmtree(EDGE_DIR, ignore_errors=True); os.makedirs(EDGE_DIR)
sql = lambda q, db="cp_client_demo": subprocess.check_output(["mysql", "-uroot", "-N", db, "-e", "SET time_zone='+05:30'; " + q]).decode().strip()
csql = lambda q: sql(q, "carepulse_central")
def ok(cond, label):
    print(("PASS " if cond else "FAIL ") + label)
    if not cond: FAILS.append(label)
def wait(fn, secs=20):
    t = time.time()
    while time.time() - t < secs:
        r = fn()
        if r: return r
        time.sleep(0.5)
    return None
def worker(*a):
    return subprocess.run(["php", "cron/worker.php", "--client=DEMO", *a], cwd=PLAT, capture_output=True, text=True).stdout
def form_fields(page, form_index=0):
    """All current values of the n-th form on a page (text/hidden/number/email/date, checked boxes, selects, textareas)."""
    forms = re.findall(r"<form\b.*?</form>", page, re.S)
    f = forms[form_index]; d = {}
    for m in re.finditer(r"<input\b([^>]*)>", f):
        a = m.group(1); n = re.search(r'name="([^"]+)"', a)
        if not n: continue
        t = (re.search(r'type="([^"]+)"', a) or [None, "text"])[1]
        v = _html.unescape((re.search(r'value="([^"]*)"', a) or [None, ""])[1])
        if t in ("checkbox", "radio"):
            if "checked" in a: d[n.group(1)] = v or "1"
        elif t not in ("file", "submit", "button"): d[n.group(1)] = v
    for m in re.finditer(r'<select\b[^>]*name="([^"]+)"[^>]*>(.*?)</select>', f, re.S):
        s = re.search(r'<option\b[^>]*value="([^"]*)"[^>]*selected', m.group(2)) or re.search(r'<option\b[^>]*value="([^"]*)"', m.group(2))
        d[m.group(1)] = _html.unescape(s.group(1)) if s else ""
    for m in re.finditer(r'<textarea\b[^>]*name="([^"]+)"[^>]*>(.*?)</textarea>', f, re.S): d[m.group(1)] = _html.unescape(m.group(2))
    return d

# ---------------- mock door-lockdown webhook ----------------
LOCK = []
class Lock(http.server.BaseHTTPRequestHandler):
    def log_message(self, *a): pass
    def do_POST(self):
        n = int(self.headers.get("Content-Length", 0)); LOCK.append((self.headers.get("Authorization"), json.loads(self.rfile.read(n))))
        self.send_response(200); self.end_headers(); self.wfile.write(b"{}")
threading.Thread(target=http.server.ThreadingHTTPServer(("127.0.0.1", 9097), Lock).serve_forever, daemon=True).start()

# ---------------- sign in ----------------
c = requests.Session()
r = c.get(BASE + "/login")
r = c.post(BASE + "/login", data={"_csrf": csrf(r.text), "client_code": "DEMO", "email": "admin@demo.demo", "password": "Demo@12345"})
if "Set up 2-step" in r.text:
    sec = re.search(r'class="code">([A-Z2-7 ]+)<', r.text).group(1)
    r = c.post(BASE + "/account/2fa", data={"_csrf": csrf(r.text), "code": totp(sec)})
elif "2-step sign-in" in r.text:
    sec = sql("SELECT totp_secret FROM users WHERE email='admin@demo.demo'")
    r = c.post(BASE + "/login/2fa", data={"_csrf": csrf(r.text), "code": totp(sec)})
check(r, "admin signed in", contains="Monitoring dashboard")

floor = sql("SELECT id FROM floors LIMIT 1")
tag_pump = sql("SELECT id FROM tags WHERE tag_code='AC:23:3F:00:00:03'")
pump2 = sql("SELECT id FROM devices WHERE serial_no='BB-SP-5532'")
inv_paid = csql("SELECT id FROM invoices WHERE status='paid' LIMIT 1")

# ---------------- pages render ----------------
for path, txt in [("/floors", "2nd floor"), (f"/floors/{floor}", "Filter"), (f"/floors/{floor}/edit", "Save layout"), ("/tags", "AC:23:3F:00:00:01"),
                  (f"/tags/{tag_pump}", "Perfusor"), ("/rtls/find?q=perfusor", "Biomedical store"), ("/rtls/find?q=Meena", "ICU"),
                  ("/nurse-calls", "Nurse call"), ("/utilities", "Liquid oxygen"), ("/maintenance", "WO-2026-"), ("/maintenance/new", "Equipment"),
                  ("/maintenance/plans", "Electrical safety"), ("/maintenance/uptime", "Uptime"), ("/maintenance/1", "Occlusion alarm"),
                  (f"/devices/{pump2}", "Work order"), (f"/devices/{pump2}/report", "Report a problem"), ("/analytics", "Nurse call"),
                  ("/settings/reports", "Weekly management summary"), ("/billing", "Hospital Connect"), (f"/billing/{inv_paid}", "TAX INVOICE"),
                  ("/settings?tab=operations", "Nurse call"), ("/dashboard", "Monitoring dashboard")]:
    check(c.get(BASE + path), "page " + path, contains=txt)
r = c.get(BASE + f"/floors/{floor}/image"); ok(r.status_code == 200 and b"<svg" in r.content[:200], "floor plan image served")
live = c.get(BASE + f"/floors/{floor}/live.json").json()
ok(len(live.get("tags", [])) == 14 and all(0 <= t["x"] <= 100 for t in live["tags"]), "live map: 14 tags with % coordinates")
ok(any(t["kind"] == "infant" and t["zone"] == "Maternity ward" for t in live["tags"]), "infant shown in maternity ward")
r = c.get(BASE + "/maintenance/uptime?format=csv&from=2026-01-01")
ok("text/csv" in r.headers.get("Content-Type", "") and "Uptime %" in r.text and "BB-SP" not in r.text[:0], "uptime CSV export")
row = [l for l in r.text.splitlines() if "Perfusor" in l and l.split(",")[-2] not in ("0", "0.0")]
ok(len(row) >= 1, "uptime CSV shows the pump with recorded downtime")
nc = c.get(BASE + "/nurse-calls/live.json").json()
ok(any(x["call_type"] == "bathroom" for x in nc.get("calls", [])), "nurse call board live feed has the open bathroom call")

# ---------------- floor editor: new floor, SVG upload, layout save ----------------
r = c.get(BASE + "/floors/new")
svg = b'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 50"><rect width="100" height="50" fill="#fff"/></svg>'
r = c.post(BASE + "/floors/new", data={"_csrf": csrf(r.text), "name": "QA floor", "level": "5"}, files={"image": ("plan.svg", svg, "image/svg+xml")})
qf = sql("SELECT id FROM floors WHERE name='QA floor'"); ok(qf != "" and sql(f"SELECT image_path FROM floors WHERE id={qf}").endswith(".svg"), "new floor with SVG plan")
r = c.get(BASE + f"/floors/{qf}/edit")
bad = b'<svg xmlns="http://www.w3.org/2000/svg" onload="alert(1)"></svg>'
r = c.post(BASE + f"/floors/{qf}/edit", data={"_csrf": csrf(r.text), "name": "QA floor", "level": "5"}, files={"image": ("x.svg", bad, "image/svg+xml")})
ok("SVG contains scripts" in r.text, "SVG with script handlers rejected")
lay = {"zones": [{"name": "QA room A", "kind": "room", "polygon": [[0, 0], [50, 0], [50, 100], [0, 100]]}, {"name": "QA exit", "kind": "exit", "polygon": [[50, 0], [100, 0], [100, 100], [50, 100]]}],
       "anchors": [{"code": "qa-gw-a", "x": 25, "y": 50}, {"code": "c4:7f:51:aa:bb:cc", "x": 75, "y": 50}]}
r = c.post(BASE + f"/floors/{qf}/layout", data={"_csrf": csrf(c.get(BASE + f"/floors/{qf}/edit").text), "layout": json.dumps(lay)})
ok(r.json().get("zones") == 2 and r.json().get("anchors") == 2, "layout saved (2 zones, 2 gateways)")
ok(sql(f"SELECT z.name FROM rtls_anchors a JOIN zones z ON z.id=a.zone_id WHERE a.code='C4:7F:51:AA:BB:CC'") == "QA exit", "gateway placed in zone by polygon; MAC normalised")

# ---------------- gateway token ----------------
r = c.get(BASE + "/gateways")
r = c.post(BASE + "/gateways/new", data={"_csrf": csrf(r.text), "gw_type": "edge", "name": "RTLS edge P4"})
code = re.search(r'class="big-code">([A-Z0-9-]+)<', r.text).group(1)
out = subprocess.run([sys.executable, "-m", "carepulse_edge", "--pair", code, "--server", BASE, "--config", EDGE_DIR + "/edge.json"], cwd="/home/claude/carepulse/edge", capture_output=True, text=True)
ok("Paired with" in out.stdout, "edge --pair")
cfg = json.load(open(EDGE_DIR + "/edge.json")); H = {"Authorization": "Bearer " + cfg["token"]}
S = lambda rows: requests.post(BASE + "/api/v1/rtls/sightings", headers=H, json={"sightings": rows}).json()

# settings: lockdown webhook + infant missing after 60 s
r = c.get(BASE + "/settings?tab=operations"); f = form_fields(r.text, [i for i, x in enumerate(re.findall(r"<form\b.*?</form>", r.text, re.S)) if "rtls_lockdown_webhook" in x][0])
f.update({"rtls_lockdown_webhook": "http://127.0.0.1:9097/lock", "rtls_lockdown_key": "door-key-1", "rtls_infant_missing_sec": "60", "nurse_call_target_sec": "90"})
check(c.post(BASE + "/settings?tab=operations", data=f), "operations settings saved", contains="aved")
ok(sql("SELECT v FROM settings WHERE k='rtls_infant_missing_sec'") == "60", "infant missing threshold stored")

# ---------------- RTLS: positioning + hysteresis ----------------
NURSE = "AC:23:3F:00:01:01"
res = S([{"tag": "ac233f000101", "anchor": "GW-ICU1", "rssi": -58}, {"tag": "AC233F000101", "anchor": "GW-ICU2", "rssi": -72}])
ok(res["tags"] == 1 and sql(f"SELECT z.name FROM tags t JOIN zones z ON z.id=t.zone_id WHERE tag_code='{NURSE}'") == "ICU-1", "nurse badge located in ICU-1 (unseparated MAC accepted)")
S([{"tag": NURSE, "anchor": "GW-ICU1", "rssi": -62}, {"tag": NURSE, "anchor": "GW-ICU2", "rssi": -59}])
ok(sql(f"SELECT z.name FROM tags t JOIN zones z ON z.id=t.zone_id WHERE tag_code='{NURSE}'") == "ICU-1", "hysteresis: 3 dB stronger neighbour does not flip the room")
res = S([{"tag": NURSE, "anchor": "GW-ICU1", "rssi": -75}, {"tag": NURSE, "anchor": "GW-ICU2", "rssi": -56}])
ok(res["moved"] == 1 and sql(f"SELECT z.name FROM tags t JOIN zones z ON z.id=t.zone_id WHERE tag_code='{NURSE}'") == "ICU-2", "clearly stronger gateway → moves to ICU-2")
ok(sql(f"SELECT COUNT(*) FROM tag_positions p JOIN tags t ON t.id=p.tag_id WHERE t.tag_code='{NURSE}' AND p.left_at IS NULL") == "1", "exactly one open location-history row")
res = S([{"tag": "AC:23:3F:FF:FF:FF", "anchor": "GW-ICU1", "rssi": -60}, {"tag": NURSE, "anchor": "GW-NOPE", "rssi": -50}])
ok(res["unknown_tags"] == 1 and res["unknown_anchors"] == 1, "unknown tag / unknown gateway counted, not stored")
ok(requests.post(BASE + "/api/v1/rtls/sightings", json={"sightings": []}).status_code == 401, "sightings API needs gateway token")

# ---------------- infant protection ----------------
BABY = "AC:23:3F:00:02:02"
res = S([{"tag": BABY, "anchor": "GW-LIFTLOBBYE", "rssi": -55}])
aid = sql(f"SELECT a.id FROM alerts a JOIN tags t ON t.id=a.tag_id WHERE t.tag_code='{BABY}' AND a.source_code='INFANT_EXIT' AND a.status='open'")
ok(res["alerts"] == 1 and aid != "" and sql(f"SELECT severity FROM alerts WHERE id={aid}") == "critical", "infant at lift lobby exit → critical alert")
ok(wait(lambda: LOCK) and LOCK[0][0] == "Bearer door-key-1" and LOCK[0][1]["event"] == "infant_exit", "door lockdown webhook called with key")
ok(S([{"tag": BABY, "anchor": "GW-LIFTLOBBYE", "rssi": -54}])["alerts"] == 0, "repeat sighting at exit does not duplicate the alert")
ok("Baby of Kavita" in sql(f"SELECT message FROM alerts WHERE id={aid}"), "alert names the baby")
S([{"tag": BABY, "anchor": "GW-MATERNITYW", "rssi": -60, "tamper": True}])
ok(sql(f"SELECT COUNT(*) FROM alerts a JOIN tags t ON t.id=a.tag_id WHERE t.tag_code='{BABY}' AND a.source_code='INFANT_TAMPER'") == "1", "band tamper → INFANT_TAMPER alert")
NICU = "AC:23:3F:00:02:03"
sql(f"UPDATE tags SET last_seen = NOW() - INTERVAL 3 MINUTE WHERE tag_code='{NICU}'")
worker()
mid = sql(f"SELECT a.id FROM alerts a JOIN tags t ON t.id=a.tag_id WHERE t.tag_code='{NICU}' AND a.source_code='INFANT_MISSING' AND a.status='open'")
ok(mid != "", "infant tag not heard for 3 min → INFANT_MISSING alert (worker)")
S([{"tag": NICU, "anchor": "GW-NICU", "rssi": -61}])
ok(sql(f"SELECT status FROM alerts WHERE id={mid}") == "closed", "heard again in NICU → missing alert closes")
# discharge release
t2 = sql(f"SELECT id FROM tags WHERE tag_code='{BABY}'")
r = c.get(BASE + f"/tags/{t2}")
c.post(BASE + f"/tags/{t2}", data={"_csrf": csrf(r.text), "action": "discharge"})
ok(sql(f"SELECT status FROM tags WHERE id={t2}") == "inactive" and sql(f"SELECT COUNT(*) FROM alerts WHERE tag_id={t2} AND status<>'closed'") == "0", "release at discharge: tag inactive, its alerts closed")
ok(S([{"tag": BABY, "anchor": "GW-LIFTLOBBYE", "rssi": -55}])["unknown_tags"] == 1, "released tag is ignored")

# ---------------- duress + asset exit ----------------
S([{"tag": NURSE, "anchor": "GW-CORRIDOR", "rssi": -50, "button": 1}])
ok("STAFF NEEDS HELP: Sr. Meena Pillai at Corridor" in sql(f"SELECT message FROM alerts WHERE source_code='DURESS' ORDER BY id DESC LIMIT 1"), "staff duress button → critical alert with location")
S([{"tag": "AC:23:3F:00:00:04", "anchor": "GW-STAIREXIT", "rssi": -57}])
ok(sql("SELECT severity FROM alerts WHERE source_code='ASSET_EXIT' ORDER BY id DESC LIMIT 1") == "warning", "infusion pump at stair exit → equipment exit alert")
ok(sql("SELECT COUNT(*) FROM alerts WHERE source_code='TAG_BATTERY'") == "1", "low tag battery reported once (14 % transport monitor tag)")

# ---------------- nurse call API ----------------
NC = lambda body: requests.post(BASE + "/api/v1/nurse-calls", headers=H, json=body).json()
r1 = NC({"location": {"ward_code": "ICU", "bed_code": "ICU-4"}, "type": "normal", "source": "Ascom"})
ok(r1.get("ok") and r1.get("id"), "nurse call raised for ICU-4")
ok(NC({"location": {"ward_code": "ICU", "bed_code": "ICU-4"}, "type": "normal"}).get("id") == r1["id"], "repeat press → same open call")
S([{"tag": NURSE, "anchor": "GW-ICU4", "rssi": -52}])
ok(sql(f"SELECT CONCAT(status,':',answer_method,':',answered_by IS NOT NULL) FROM nurse_calls WHERE id={r1['id']}") == "answered:presence:1", "nurse badge enters ICU-4 → call answered by presence")
cb = NC({"location": {"ward_code": "W3", "bed_code": "W3-7"}, "type": "code_blue"})
ok(sql(f"SELECT a.severity FROM nurse_calls n JOIN alerts a ON a.id=n.alert_id WHERE n.id={cb['id']}") == "critical", "code blue → critical alert")
ok(NC({"location": {"ward_code": "W3", "bed_code": "W3-7"}, "state": "cancel"}).get("closed") == 1, "cancel at bed clears the call")
ok(sql(f"SELECT CONCAT(n.status,':',a.status) FROM nurse_calls n JOIN alerts a ON a.id=n.alert_id WHERE n.id={cb['id']}") == "cleared:closed", "call cleared and its alert closed")
b = NC({"events": [{"location": {"zone": "Labour room LR-1"}, "type": "bathroom"}, {"location": {"bed_code": "NOPE-9"}, "type": "normal"}, {"location": {"ward_code": "W3", "bed_code": "W3-2"}, "type": "bed_exit", "at": "2026-01-01T10:00:00+05:30"}]})
ok(b["ok"] and b["results"][0]["ok"] and not b["results"][1]["ok"] and b["results"][2]["ok"], "batched events: zone call ok, unknown bed rejected, bed-exit ok")
ok(sql(f"SELECT raised_at FROM nurse_calls WHERE id={b['results'][2]['id']}") == "2026-01-01 10:00:00", "event time honoured")
bid = sql("SELECT id FROM nurse_calls WHERE status='open' AND call_type='bathroom' ORDER BY id LIMIT 1")
r = c.post(BASE + f"/nurse-calls/{bid}", data={"_csrf": re.search(r'const CSRF = "([^"]+)"', c.get(BASE + "/nurse-calls").text).group(1), "ajax": "1"})
ok(r.json().get("ok") and sql(f"SELECT CONCAT(status,':',answer_method) FROM nurse_calls WHERE id={bid}") == "cleared:screen", "cleared from the nurse call board")

# ---------------- edge: BLE gateway HTTP listener → platform ----------------
cfg["rtls"] = {"interval": 1, "http_port": 18088, "http_host": "127.0.0.1", "tag_prefixes": ["AC:23:3F"]}
cfg.update({"listeners": [], "serial_ports": []})
json.dump(cfg, open(EDGE_DIR + "/edge.json", "w"))
edge = subprocess.Popen([sys.executable, "-m", "carepulse_edge", "--config", EDGE_DIR + "/edge.json"], cwd="/home/claude/carepulse/edge", stdout=open(EDGE_DIR + "/edge.log", "w"), stderr=subprocess.STDOUT)
try:
    def post_edge():
        try: return requests.post("http://127.0.0.1:18088/?gw=GW-BIOMEDICAL", json=[{"mac": "AC233F000002", "rssi": -60, "battery": 77}, {"mac": "112233445566", "rssi": -40}], timeout=2).status_code < 300
        except Exception: return False
    ok(wait(post_edge, 15), "edge RTLS HTTP listener accepts gateway JSON")
    ok(wait(lambda: sql("SELECT z.name FROM tags t JOIN zones z ON z.id=t.zone_id WHERE tag_code='AC:23:3F:00:00:02'") == "Biomedical store", 20), "edge → platform: pump tag now in Biomedical store")
    ok(sql("SELECT battery FROM tags WHERE tag_code='AC:23:3F:00:00:02'") == "77", "battery from gateway stored")
finally:
    edge.terminate(); edge.wait(5)

# ---------------- utilities ----------------
lmo = sql("SELECT id FROM env_locations WHERE kind='lmo'")
r = c.get(BASE + "/utilities"); ok(re.search(r"\d+(\.\d)? days to critical", r.text) is not None, "LMO tank shows days to critical from trend")
rr = requests.post(BASE + "/api/v1/readings", headers=H, json={"device": {"serial": "QA-GAS-1"}, "location": {"name": "Oxygen manifold – main plant room"}, "readings": [{"param": "o2_pressure", "value": 3.2}]}).json()
ok(rr.get("accepted", rr.get("ok")) and sql("SELECT severity FROM alerts WHERE param_code='o2_pressure' ORDER BY id DESC LIMIT 1") == "critical", "O2 line pressure 3.2 bar → critical alert")
time.sleep(1.1)
rr = requests.post(BASE + "/api/v1/readings", headers=H, json={"device": {"serial": "QA-GAS-1"}, "location": {"name": "Oxygen manifold – main plant room"}, "readings": [{"param": "o2_pressure", "value": 58, "unit": "psi"}]}).json()
ok(sql("SELECT ROUND(value,2) FROM readings WHERE param_code='o2_pressure' ORDER BY id DESC LIMIT 1") in ("4.00",), "58 psi converted to 4.00 bar")
check(c.get(BASE + "/environment"), "cold-chain board excludes utilities", code=200)
ok("Oxygen manifold" not in c.get(BASE + "/environment").text, "utility locations not listed on cold-chain board")

# ---------------- maintenance ----------------
defib = sql("SELECT id FROM devices WHERE serial_no='PH-HS1-7721'")
r = c.get(BASE + f"/devices/{defib}/report")
r = c.post(BASE + f"/devices/{defib}/report", data={"_csrf": csrf(r.text), "title": "Fails self test", "priority": "high", "device_down": "1"})
wo = sql(f"SELECT id FROM work_orders WHERE device_id={defib} ORDER BY id DESC LIMIT 1"); num = sql(f"SELECT number FROM work_orders WHERE id={wo}")
ok(re.match(r"WO-\d{4}-\d{4}$", num) is not None and sql(f"SELECT status FROM devices WHERE id={defib}") == "maintenance", "breakdown report → work order, device marked under maintenance")
ok(sql(f"SELECT severity FROM alerts WHERE source_code='{num}'") == "critical", "breakdown of a high-criticality device → critical maintenance alert")
r = c.get(BASE + f"/maintenance/{wo}")
f = form_fields(r.text, [i for i, x in enumerate(re.findall(r"<form\b.*?</form>", r.text, re.S)) if 'value="update"' in x][0]); f.update({"status": "in_progress", "vendor": "Philips service"})
c.post(BASE + f"/maintenance/{wo}", data=f)
ok(sql(f"SELECT CONCAT(status,':',vendor) FROM work_orders WHERE id={wo}") == "in_progress:Philips service", "work order updated")
sql(f"UPDATE work_orders SET down_from = NOW() - INTERVAL 6 HOUR WHERE id={wo}")
r = c.get(BASE + f"/maintenance/{wo}")
c.post(BASE + f"/maintenance/{wo}", data={"_csrf": csrf(r.text), "action": "complete", "resolution": "Battery replaced, self test pass", "parts": "Battery pack", "cost": "18500"})
ok(sql(f"SELECT CONCAT(status,':',ROUND(TIMESTAMPDIFF(MINUTE,down_from,down_to)/60)) FROM work_orders WHERE id={wo}") == "completed:6", "completed: ~6 h downtime recorded")
ok(sql(f"SELECT status FROM devices WHERE id={defib}") == "active" and sql(f"SELECT status FROM alerts WHERE source_code='{num}'") == "closed", "device back in service, alert closed")
r = c.get(BASE + "/maintenance/plans")
c.post(BASE + "/maintenance/plans", data={"_csrf": csrf(r.text), "category": "ventilator", "kind": "ppm", "interval_days": "90", "next_due": time.strftime("%Y-%m-%d", time.localtime(time.time() + 3 * 86400)), "vendor": "Mindray service"})
ok(int(sql("SELECT COUNT(*) FROM maintenance_plans WHERE kind='ppm' AND interval_days=90")) >= 1, "PPM plan created for all ventilators")
daily = lambda: subprocess.run(["php", "-r", "require 'app/bootstrap.php'; Tenant::use(Tenant::byCode('DEMO')); Maintenance::daily();"], cwd=PLAT, capture_output=True)
daily()
ok(sql("SELECT COUNT(*) FROM work_orders w JOIN maintenance_plans p ON p.id=w.plan_id WHERE p.interval_days=90 AND w.kind='ppm'") != "0", "plan due in 3 days → PPM work order created ahead")
n0 = sql("SELECT COUNT(*) FROM work_orders")
daily()
ok(sql("SELECT COUNT(*) FROM work_orders") == n0, "daily run is idempotent")
ppm = sql("SELECT w.id FROM work_orders w JOIN maintenance_plans p ON p.id=w.plan_id WHERE p.interval_days=90 LIMIT 1")
r = c.get(BASE + f"/maintenance/{ppm}")
c.post(BASE + f"/maintenance/{ppm}", data={"_csrf": csrf(r.text), "action": "complete", "resolution": "PPM done as per checklist"})
ok(sql(f"SELECT DATEDIFF(next_due, CURDATE()) FROM maintenance_plans p JOIN work_orders w ON w.plan_id=p.id WHERE w.id={ppm}") == "90", "completing PPM rolls the plan forward 90 days")
r = c.get(BASE + "/maintenance/uptime"); ok("Mean time to repair" in r.text and re.search(r"\d+(\.\d+)? h</div>", r.text), "uptime page shows MTTR")

# ---------------- analytics + scheduled report ----------------
r = c.get(BASE + "/analytics?days=30")
check(r, "analytics 30 days", contains="Equipment uptime")
ok(re.search(r"Median call response</div><div class=\"v\">\d\d:\d\d", r.text) is not None, "analytics shows nurse call response")
r = c.get(BASE + "/settings/reports")
c.post(BASE + "/settings/reports", data={"_csrf": csrf(r.text), "name": "QA daily nurse call", "report": "nurse_call", "frequency": "daily", "send_hour": "7", "recipients": "qa@demo.demo, not-an-email"})
rid = sql("SELECT id FROM scheduled_reports WHERE name='QA daily nurse call'")
ok(sql(f"SELECT recipients FROM scheduled_reports WHERE id={rid}") == "qa@demo.demo", "report created; invalid recipient dropped")
log = PLAT + "/storage/logs/outbox.log"; size = os.path.getsize(log) if os.path.exists(log) else 0
r = c.get(BASE + "/settings/reports")
c.post(BASE + "/settings/reports", data={"_csrf": csrf(r.text), "action": "send", "id": rid})
worker()
ok(wait(lambda: os.path.exists(log) and "qa@demo.demo" in open(log, encoding="utf-8", errors="ignore").read()[size:], 10), "scheduled report emailed (send now)")

# ---------------- billing ----------------
p = requests.Session()
r = p.get(BASE + "/platform/login")
r = p.post(BASE + "/platform/login", data={"_csrf": csrf(r.text), "email": "owner@caresoft.co.in", "password": "Test@12345abc"})
if "Set up 2-step" in r.text:
    secret = re.search(r'class="code">([A-Z2-7 ]+)<', r.text).group(1)
    r = p.post(BASE + "/platform/2fa/setup", data={"_csrf": csrf(r.text), "code": totp(secret)})
elif "2-step" in r.text:
    sec = csql("SELECT totp_secret FROM platform_users WHERE email='owner@caresoft.co.in'")
    r2 = p.post(BASE + "/platform/2fa", data={"_csrf": csrf(r.text), "code": totp(sec)})
    if "Platform overview" not in r2.text:  # same 30 s code already used — wait for the next one
        time.sleep(31 - time.time() % 30); r2 = p.post(BASE + "/platform/2fa", data={"_csrf": csrf(r2.text), "code": totp(sec)})
    r = r2
check(r, "platform owner signed in", contains="Platform overview")
r = p.get(BASE + "/platform/settings"); f = form_fields(r.text)
f.update({"seller_gstin": "27AABCC1234D1Z9", "seller_pan": "AABCC1234D", "billing_sac": "998314", "bank_details": "HDFC Bank, A/c 50200012345678, IFSC HDFC0000123", "payment_link": "https://pay.example.in/caresoft"})
check(p.post(BASE + "/platform/settings", data=f), "seller details saved", contains="Settings saved")
check(p.get(BASE + "/platform/billing"), "platform billing list", contains="CP/2026-27/0001")
cid = csql("SELECT id FROM clients WHERE code='DEMO'")
draft = csql("SELECT id FROM invoices WHERE status='draft' LIMIT 1")
r = p.get(BASE + f"/platform/billing/{draft}"); check(r, "draft invoice view", contains="DRAFT")
ok("Live waveform beds" in r.text and "Location tags" in r.text and "CGST" in r.text and "SGST" in r.text, "draft has add-ons and CGST+SGST (same state)")
p.post(BASE + f"/platform/billing/{draft}", data={"_csrf": csrf(r.text), "action": "refresh"})
ok(csql(f"SELECT items FROM invoices WHERE id={draft}").count("998314") >= 1, "refresh picks up SAC code")
p.post(BASE + f"/platform/billing/{draft}", data={"_csrf": csrf(p.get(BASE + f"/platform/billing/{draft}").text), "action": "issue"})
ok(csql(f"SELECT CONCAT(status,':',number) FROM invoices WHERE id={draft}") == "issued:CP/2026-27/0002", "issue → sequential FY number CP/2026-27/0002")
worker()
ok("CP/2026-27/0002" in open(log, encoding="utf-8", errors="ignore").read()[size:], "invoice emailed to billing contact")
tot = float(csql(f"SELECT total FROM invoices WHERE id={draft}")); sub = float(csql(f"SELECT subtotal FROM invoices WHERE id={draft}"))
ok(abs(tot - round(sub * 1.18)) <= 1, "total = subtotal + 18 % GST (rounded to rupee)")
r = c.get(BASE + f"/billing/{draft}"); check(r, "client sees issued invoice", contains="CP/2026-27/0002")
ok("rupees" in r.text.lower() and "only" in r.text.lower(), "amount in words")
p.post(BASE + f"/platform/billing/{draft}", data={"_csrf": csrf(p.get(BASE + f"/platform/billing/{draft}").text), "action": "paid", "payment_ref": "UTR998877"})
ok(csql(f"SELECT CONCAT(status,':',payment_ref) FROM invoices WHERE id={draft}") == "paid:UTR998877", "marked paid with reference")
# GST variants
csql(f"UPDATE clients SET state='Karnataka' WHERE id={cid}")
r = p.get(BASE + "/platform/billing"); p.post(BASE + "/platform/billing", data={"_csrf": csrf(r.text), "client_id": cid, "month": time.strftime("%Y-%m")})
cur = csql(f"SELECT id FROM invoices WHERE client_id={cid} AND period_start=DATE_FORMAT(CURDATE(),'%Y-%m-01')")
ok(csql(f"SELECT CONCAT(tax_type,':',ROUND(tax_rate)) FROM invoices WHERE id={cur}") == "igst:18", "other state → IGST 18 %")
csql(f"UPDATE clients SET country='Kenya' WHERE id={cid}")
p.post(BASE + f"/platform/billing/{cur}", data={"_csrf": csrf(p.get(BASE + f"/platform/billing/{cur}").text), "action": "refresh"})
ok(csql(f"SELECT CONCAT(tax_type,':',ROUND(tax_amount)) FROM invoices WHERE id={cur}") == "none:0", "export client → no GST (LUT)")
ok("LUT" in p.get(BASE + f"/platform/billing/{cur}").text, "export invoice carries LUT note")
p.post(BASE + f"/platform/billing/{cur}", data={"_csrf": csrf(p.get(BASE + f"/platform/billing/{cur}").text), "action": "void"})
ok(csql(f"SELECT status FROM invoices WHERE id={cur}") == "void", "draft voided")
csql(f"UPDATE clients SET state='Maharashtra', country='India' WHERE id={cid}")
ok(c.get(BASE + f"/billing/{cur}").status_code == 404, "client cannot open a void invoice")
nurse = requests.Session(); r = nurse.get(BASE + "/login")
r = nurse.post(BASE + "/login", data={"_csrf": csrf(r.text), "client_code": "DEMO", "email": "nurse@demo.demo", "password": "Demo@12345"})
ok(nurse.get(BASE + "/billing").status_code == 403, "nurse cannot see subscription & invoices")
ok(nurse.get(BASE + "/nurse-calls").status_code == 200, "nurse can open nurse call board")

print("\n%d failure(s)" % len(FAILS))
for f in FAILS: print(" -", f)
sys.exit(1 if FAILS else 0)
