Offline Clinical Emergency Nephrology Acute Severe Hyperkalemia Membrane Stabilization, Intracellular Shift & Elimination Titrator (Calcium Gluconate vs Chloride, Insulin-Dextrose Kinetics, Lokelma vs Patiromer, & Emergency Hemodialysis Sieve)

"""
Clinical Decision Support Engine for Emergency Nephrology: Acute Severe Hyperkalemia
Implements ERC 2021/2025, KDIGO 2024, and AHA ECC Resuscitation Guidelines.
"""

from dataclasses import dataclass, field
from enum import Enum
from typing import List, Optional, Tuple, Dict
import math
import unittest


class HyperkalemiaSeverity(str, Enum):
    NORMAL = "Normal Serum Potassium (3.5 - 5.0 mmol/L)"
    MILD = "Mild Hyperkalemia (5.1 - 5.9 mmol/L)"
    MODERATE = "Moderate Hyperkalemia (6.0 - 6.4 mmol/L)"
    SEVERE = "Severe / Life-Threatening Hyperkalemia (>= 6.5 mmol/L or ECG Changes)"


class ECGAbnormality(str, Enum):
    NORMAL = "Normal 12-Lead ECG"
    PEAKED_T_WAVES = "Peaked / Tented T-Waves (narrow base, symmetrical)"
    PR_PROLONGATION = "PR Interval Prolongation (PR > 200 ms) / P-Wave Flattening"
    P_WAVE_LOSS = "Loss of P-Waves (Sino-ventricular conduction)"
    QRS_WIDENING = "QRS Complex Widening (> 120 ms / Bundle Branch Block morphology)"
    SINE_WAVE = "Sine Wave Pattern (Merging of widened QRS and peaked T-wave - Periarrest)"
    VENTRICULAR_ARRHYTHMIA = "Ventricular Tachycardia / Ventricular Fibrillation / Asystole"


class VascularAccessType(str, Enum):
    PERIPHERAL_IV = "Peripheral Intravenous Access"
    CENTRAL_VENOUS_LINE = "Central Venous Catheter (CVC / PICC)"
    IO_ACCESS = "Intraosseous (IO) Access"


class RenalStatus(str, Enum):
    NORMAL_RENAL_FUNCTION = "Normal / Mild Impairment (eGFR > 60 mL/min)"
    MODERATE_CKD = "CKD Stage 3-4 (eGFR 15 - 59 mL/min, Non-oliguric)"
    OLIGURIC_AKI = "Oliguric / Anuric Acute Kidney Injury (Urine Output < 0.5 mL/kg/h)"
    ESRD_ON_HEMODIALYSIS = "End-Stage Renal Disease (ESRD) on Maintenance Hemodialysis"


@dataclass
class MembraneStabilizationPlan:
    indicated: bool
    urgency: str
    agent_name: str
    dose_instructions: str
    elemental_calcium_meq: float
    onset_minutes: int
    duration_minutes: int
    repeat_interval_minutes: int
    precautions: List[str] = field(default_factory=list)


@dataclass
class IntracellularShiftPlan:
    insulin_dextrose_indicated: bool
    insulin_dose: str
    dextrose_dose: str
    hypoglycemia_risk: str
    glucose_monitoring_schedule: str
    beta_agonist_indicated: bool
    beta_agonist_dose: str
    sodium_bicarbonate_indicated: bool
    sodium_bicarbonate_rationale: str
    expected_k_reduction_mmol_l: str


@dataclass
class EliminationPlan:
    loop_diuretics_indicated: bool
    loop_diuretic_dose: Optional[str]
    potassium_binder_indicated: bool
    recommended_binder: Optional[str]
    binder_instructions: Optional[str]
    emergency_dialysis_indicated: bool
    dialysis_urgency: str
    dialysis_indications: List[str] = field(default_factory=list)


@dataclass
class ComprehensiveHyperkalemiaTriage:
    serum_potassium_mmol_l: float
    severity: HyperkalemiaSeverity
    ecg_status: ECGAbnormality
    membrane_stabilization: MembraneStabilizationPlan
    intracellular_shift: IntracellularShiftPlan
    elimination_strategy: EliminationPlan
    immediate_action_checklist: List[str]


class AcuteHyperkalemiaEngine:
    """
    Offline clinical decision support engine for the emergency assessment,
    myocardial membrane stabilization, intracellular shifting, and total-body elimination
    of acute hyperkalemia. Conforms to ERC 2021/2025, KDIGO 2024, and AHA ECC protocols.
    """

    @staticmethod
    def classify_severity(
        serum_potassium: float,
        ecg_findings: List[ECGAbnormality]
    ) -> HyperkalemiaSeverity:
        """
        Classifies hyperkalemia severity.
        Crucial clinical rule: ANY potassium level with conduction abnormalities
        or ECG changes is automatically upgraded to SEVERE / Life-Threatening.
        """
        has_ecg_changes = any(f != ECGAbnormality.NORMAL for f in ecg_findings)

        if serum_potassium >= 6.5 or has_ecg_changes:
            return HyperkalemiaSeverity.SEVERE
        elif serum_potassium >= 6.0:
            return HyperkalemiaSeverity.MODERATE
        elif serum_potassium >= 5.1:
            return HyperkalemiaSeverity.MILD
        else:
            return HyperkalemiaSeverity.NORMAL

    @classmethod
    def evaluate_membrane_stabilization(
        cls,
        serum_potassium: float,
        ecg_findings: List[ECGAbnormality],
        vascular_access: VascularAccessType,
        on_digoxin: bool = False
    ) -> MembraneStabilizationPlan:
        """
        Guides myocardial membrane stabilization with IV Calcium.
        - Calcium Chloride 10% has 3x more elemental calcium (13.6 mEq vs 4.65 mEq)
          preferred in cardiac arrest, peri-arrest sine wave, or via central venous line.
        - Calcium Gluconate 10% preferred for peripheral lines due to markedly lower extravasation necrosis risk.
        """
        has_severe_ecg = any(f in [
            ECGAbnormality.PR_PROLONGATION,
            ECGAbnormality.P_WAVE_LOSS,
            ECGAbnormality.QRS_WIDENING,
            ECGAbnormality.SINE_WAVE,
            ECGAbnormality.VENTRICULAR_ARRHYTHMIA
        ] for f in ecg_findings)

        indicated = (serum_potassium >= 6.5) or any(f != ECGAbnormality.NORMAL for f in ecg_findings)

        if not indicated:
            return MembraneStabilizationPlan(
                indicated=False,
                urgency="Not Indicated",
                agent_name="None",
                dose_instructions="Membrane stabilization not indicated in mild/moderate hyperkalemia without ECG abnormalities.",
                elemental_calcium_meq=0.0,
                onset_minutes=0,
                duration_minutes=0,
                repeat_interval_minutes=0,
                precautions=[]
            )

        precautions = []
        if on_digoxin:
            precautions.append("Digoxin Toxicity Caution: Infuse calcium slowly over 20-30 minutes to prevent 'stone heart' arrhythmias.")
        else:
            precautions.append("Infuse IV over 2 to 3 minutes under continuous cardiac telemetry.")

        is_periarrest = any(f in [ECGAbnormality.SINE_WAVE, ECGAbnormality.VENTRICULAR_ARRHYTHMIA] for f in ecg_findings)

        if vascular_access == VascularAccessType.CENTRAL_VENOUS_LINE or is_periarrest:
            agent = "Calcium Chloride 10%"
            elemental_ca = 13.6  # mEq per 10 mL ampule (1 g)
            dose_str = "10 mL (1 g) Calcium Chloride 10% IV over 2-3 minutes via central line (or IO in arrest)."
            urgency = "STAT EMERGENCY (Peri-Arrest / Central Line)" if is_periarrest else "STAT Urgent (Central Line Available)"
        else:
            agent = "Calcium Gluconate 10%"
            elemental_ca = 4.65  # mEq per 10 mL ampule (1 g)
            dose_str = "10 mL to 20 mL (1-2 g) Calcium Gluconate 10% IV over 2-5 minutes via peripheral line."
            urgency = "IMMEDIATE (Peripheral IV Preferred to Avert Extravasation Necrosis)"

        precautions.append("Re-evaluate 12-lead ECG at 5-10 minutes. Repeat calcium dose if conduction defects or QRS widening persist.")

        return MembraneStabilizationPlan(
            indicated=True,
            urgency=urgency,
            agent_name=agent,
            dose_instructions=dose_str,
            elemental_calcium_meq=elemental_ca,
            onset_minutes=2,
            duration_minutes=45,
            repeat_interval_minutes=10,
            precautions=precautions
        )

    @classmethod
    def calculate_intracellular_shift(
        cls,
        serum_potassium: float,
        blood_glucose_mg_dl: float,
        arterial_ph: Optional[float] = None,
        serum_bicarbonate_mmol_l: Optional[float] = None,
        resting_heart_rate: int = 80,
        active_coronary_ischemia: bool = False
    ) -> IntracellularShiftPlan:
        """
        Titrates intracellular potassium shifting agents:
        1. Regular Insulin + Dextrose (first-line).
        2. Inhaled Beta-2 Agonist (Albuterol / Salbutamol nebulization).
        3. Sodium Bicarbonate (strictly gated to severe metabolic acidosis).
        """
        # 1. Insulin & Dextrose Kinetics
        insulin_dose = "Regular Insulin 10 Units IV bolus"

        if blood_glucose_mg_dl >= 250.0:
            dextrose_dose = f"Hold Dextrose bolus (current blood glucose is {blood_glucose_mg_dl:.1f} mg/dL >= 250 mg/dL). Monitor for rapid drops."
            hypo_risk = "Low risk of acute hypoglycemia, but serial glucose checks mandatory."
        elif 180.0 <= blood_glucose_mg_dl < 250.0:
            dextrose_dose = "Dextrose 50% (D50W) 25 mL (12.5 g glucose) IV bolus with insulin."
            hypo_risk = "Moderate risk. Supplement with 12.5g D50W."
        else:
            # Baseline glucose < 180 mg/dL: High hypoglycemia risk
            dextrose_dose = "Dextrose 50% (D50W) 50 mL (25 g glucose) IV bolus immediately with insulin, followed by 10% Dextrose infusion at 50-75 mL/hr for 4 hours."
            hypo_risk = "HIGH HYPOGLYCEMIA RISK: D50W 50 mL (25g) mandatory + maintenance dextrose infusion."

        glucose_schedule = "Check blood glucose at 0 min, 30 min, 60 min, 120 min, 180 min, and 240 min post-insulin administration."

        # 2. Inhaled Beta-2 Agonist
        beta_indicated = True
        if resting_heart_rate > 130 or active_coronary_ischemia:
            beta_indicated = False
            beta_dose = f"Hold beta-agonist: Relative contraindication due to tachycardia (HR {resting_heart_rate} bpm) or acute myocardial ischemia."
        else:
            beta_dose = "Albuterol (Salbutamol) 10 mg to 20 mg in 4 mL normal saline nebulized over 15 minutes (4-8x standard bronchodilator dose)."

        # 3. Sodium Bicarbonate Gating
        # Strictly indicated ONLY for severe metabolic acidosis (pH < 7.15 or HCO3 < 15)
        bicarb_indicated = False
        if (arterial_ph is not None and arterial_ph < 7.15) or (serum_bicarbonate_mmol_l is not None and serum_bicarbonate_mmol_l < 15.0):
            bicarb_indicated = True
            bicarb_rationale = (
                f"INDICATED: Severe metabolic acidosis present (pH: {arterial_ph}, HCO3: {serum_bicarbonate_mmol_l} mmol/L). "
                "Administer Sodium Bicarbonate 8.4% 50 mEq (50 mL) IV over 5 minutes."
            )
        else:
            bicarb_rationale = (
                "NOT INDICATED: Bicarbonate is ineffective for hyperkalemia shifting without severe metabolic acidosis (pH < 7.15). "
                "Avoid routine use due to volume overload, hypernatremia, and paradoxical CSF acidosis risks."
            )

        expected_drop = "0.65 to 1.2 mmol/L drop within 30-60 minutes (additive effect when insulin and albuterol are combined)."

        return IntracellularShiftPlan(
            insulin_dextrose_indicated=True,
            insulin_dose=insulin_dose,
            dextrose_dose=dextrose_dose,
            hypoglycemia_risk=hypo_risk,
            glucose_monitoring_schedule=glucose_schedule,
            beta_agonist_indicated=beta_indicated,
            beta_agonist_dose=beta_dose,
            sodium_bicarbonate_indicated=bicarb_indicated,
            sodium_bicarbonate_rationale=bicarb_rationale,
            expected_k_reduction_mmol_l=expected_drop
        )

    @classmethod
    def evaluate_elimination_strategy(
        cls,
        serum_potassium: float,
        renal_status: RenalStatus,
        volume_overload: bool = False,
        ecg_refractory: bool = False,
        rhabdomyolysis_present: bool = False,
        active_bowel_ileus: bool = False
    ) -> EliminationPlan:
        """
        Guides potassium removal from the body:
        1. Loop Diuretics (kaliuresis - only if functioning kidneys exist).
        2. Modern Potassium Binders (Sodium Zirconium Cyclosilicate / Lokelma vs Patiromer).
        3. Emergency Hemodialysis (the definitive sieve for refractory, anuric, or life-threatening cases).
        """
        dialysis_reasons = []
        dialysis_indicated = False
        dialysis_urgency = "None / Medical Therapy Sufficient"

        # Check dialysis triggers
        if renal_status in [RenalStatus.OLIGURIC_AKI, RenalStatus.ESRD_ON_HEMODIALYSIS]:
            if serum_potassium >= 6.5 or ecg_refractory:
                dialysis_indicated = True
                dialysis_reasons.append("Severe hyperkalemia in anuric/oliguric renal failure (kidneys cannot eliminate potassium).")
                dialysis_urgency = "EMERGENT (Initiate within 30-60 minutes)"

        if ecg_refractory:
            dialysis_indicated = True
            dialysis_reasons.append("Refractory ECG conduction defects / persistent QRS widening despite IV calcium and shifting.")
            dialysis_urgency = "CRITICAL RESUSCITATION EMERGENCY"

        if volume_overload and (renal_status != RenalStatus.NORMAL_RENAL_FUNCTION):
            dialysis_indicated = True
            dialysis_reasons.append("Concomitant refractory pulmonary edema / volume overload precludes fluid therapies.")
            dialysis_urgency = "EMERGENT"

        if rhabdomyolysis_present and serum_potassium >= 6.5:
            dialysis_indicated = True
            dialysis_reasons.append("Severe rhabdomyolysis / tumor lysis syndrome ongoing endogenous potassium release.")

        # Loop Diuretics
        loop_indicated = False
        loop_dose = None
        if renal_status in [RenalStatus.NORMAL_RENAL_FUNCTION, RenalStatus.MODERATE_CKD]:
            loop_indicated = True
            dose_val = 80 if renal_status == RenalStatus.MODERATE_CKD else 40
            loop_dose = f"Furosemide {dose_val} mg IV bolus. Ensure isotonic volume replacement if euvolemic to maintain kaliuresis."
        else:
            loop_dose = "Hold loop diuretics: Patient is oliguric/anuric or ESRD on dialysis (ineffective and risks ototoxicity)."

        # Modern GI Binders (Lokelma vs Patiromer)
        binder_indicated = not active_bowel_ileus
        if active_bowel_ileus:
            rec_binder = "Hold oral binders"
            binder_instructions = "Oral binders contraindicated in bowel obstruction, ileus, or recent post-op bowel anastomosis."
        else:
            rec_binder = "Sodium Zirconium Cyclosilicate (SZC / Lokelma)"
            binder_instructions = (
                "Lokelma 10 g PO suspended in 45 mL water TID for up to 48 hours. "
                "Inorganic crystal lattice with rapid onset of action (~1 hour). "
                "Preferred over SPS/Kayexalate (avoids sorbitol-induced intestinal necrosis risk)."
            )

        return EliminationPlan(
            loop_diuretics_indicated=loop_indicated,
            loop_diuretic_dose=loop_dose,
            potassium_binder_indicated=binder_indicated,
            recommended_binder=rec_binder,
            binder_instructions=binder_instructions,
            emergency_dialysis_indicated=dialysis_indicated,
            dialysis_urgency=dialysis_urgency,
            dialysis_indications=dialysis_reasons
        )

    @classmethod
    def triage_hyperkalemia(
        cls,
        serum_potassium: float,
        ecg_findings: List[ECGAbnormality],
        vascular_access: VascularAccessType,
        blood_glucose_mg_dl: float,
        renal_status: RenalStatus,
        arterial_ph: Optional[float] = None,
        serum_bicarbonate_mmol_l: Optional[float] = None,
        resting_heart_rate: int = 80,
        active_coronary_ischemia: bool = False,
        volume_overload: bool = False,
        ecg_refractory: bool = False,
        rhabdomyolysis_present: bool = False,
        active_bowel_ileus: bool = False,
        on_digoxin: bool = False
    ) -> ComprehensiveHyperkalemiaTriage:
        """
        Executes the full 3-step resuscitation cascade:
        Step 1: Stabilize Myocardium (IV Calcium)
        Step 2: Shift Potassium Inward (Insulin + Dextrose, Albuterol, Bicarbonate)
        Step 3: Eliminate Potassium from Body (Diuretics, Lokelma, Hemodialysis)
        """
        severity = cls.classify_severity(serum_potassium, ecg_findings)
        primary_ecg = ecg_findings[0] if ecg_findings else ECGAbnormality.NORMAL

        stabilization = cls.evaluate_membrane_stabilization(
            serum_potassium=serum_potassium,
            ecg_findings=ecg_findings,
            vascular_access=vascular_access,
            on_digoxin=on_digoxin
        )

        shift = cls.calculate_intracellular_shift(
            serum_potassium=serum_potassium,
            blood_glucose_mg_dl=blood_glucose_mg_dl,
            arterial_ph=arterial_ph,
            serum_bicarbonate_mmol_l=serum_bicarbonate_mmol_l,
            resting_heart_rate=resting_heart_rate,
            active_coronary_ischemia=active_coronary_ischemia
        )

        elimination = cls.evaluate_elimination_strategy(
            serum_potassium=serum_potassium,
            renal_status=renal_status,
            volume_overload=volume_overload,
            ecg_refractory=ecg_refractory,
            rhabdomyolysis_present=rhabdomyolysis_present,
            active_bowel_ileus=active_bowel_ileus
        )

        checklist = []
        if stabilization.indicated:
            checklist.append(f"STEP 1: Give {stabilization.agent_name} STAT ({stabilization.dose_instructions})")
        checklist.append(f"STEP 2A: Administer {shift.insulin_dose} + {shift.dextrose_dose}")
        if shift.beta_agonist_indicated:
            checklist.append(f"STEP 2B: Nebulize {shift.beta_agonist_dose}")
        if shift.sodium_bicarbonate_indicated:
            checklist.append("STEP 2C: Administer 50 mEq Sodium Bicarbonate IV over 5 min for severe acidosis.")
        if elimination.emergency_dialysis_indicated:
            checklist.append(f"STEP 3 CRITICAL: Activate Emergency Hemodialysis ({elimination.dialysis_urgency})")
        elif elimination.loop_diuretics_indicated:
            checklist.append(f"STEP 3: Administer {elimination.loop_diuretic_dose}")
        if elimination.potassium_binder_indicated:
            checklist.append(f"STEP 3: Start {elimination.recommended_binder} ({elimination.binder_instructions})")
        checklist.append("MONITORING: Repeat serum potassium at 1 hour; continuous telemetry; repeat ECG at 10 min.")

        return ComprehensiveHyperkalemiaTriage(
            serum_potassium_mmol_l=serum_potassium,
            severity=severity,
            ecg_status=primary_ecg,
            membrane_stabilization=stabilization,
            intracellular_shift=shift,
            elimination_strategy=elimination,
            immediate_action_checklist=checklist
        )


# =====================================================================
# EMBEDDED VERIFICATION UNIT TESTS
# =====================================================================

class TestAcuteHyperkalemiaEngine(unittest.TestCase):
    def test_severity_classification(self):
        # K = 5.4, no ECG -> MILD
        self.assertEqual(
            AcuteHyperkalemiaEngine.classify_severity(5.4, [ECGAbnormality.NORMAL]),
            HyperkalemiaSeverity.MILD
        )
        # K = 6.2, no ECG -> MODERATE
        self.assertEqual(
            AcuteHyperkalemiaEngine.classify_severity(6.2, [ECGAbnormality.NORMAL]),
            HyperkalemiaSeverity.MODERATE
        )
        # K = 5.8 with peaked T-waves -> Automatically upgraded to SEVERE
        self.assertEqual(
            AcuteHyperkalemiaEngine.classify_severity(5.8, [ECGAbnormality.PEAKED_T_WAVES]),
            HyperkalemiaSeverity.SEVERE
        )
        # K = 7.1, no ECG -> SEVERE
        self.assertEqual(
            AcuteHyperkalemiaEngine.classify_severity(7.1, [ECGAbnormality.NORMAL]),
            HyperkalemiaSeverity.SEVERE
        )

    def test_membrane_stabilization_peripheral_vs_central(self):
        # Peripheral IV: Calcium Gluconate
        stab_periph = AcuteHyperkalemiaEngine.evaluate_membrane_stabilization(
            serum_potassium=6.8,
            ecg_findings=[ECGAbnormality.PEAKED_T_WAVES],
            vascular_access=VascularAccessType.PERIPHERAL_IV
        )
        self.assertTrue(stab_periph.indicated)
        self.assertEqual(stab_periph.agent_name, "Calcium Gluconate 10%")
        self.assertAlmostEqual(stab_periph.elemental_calcium_meq, 4.65)

        # Central Line: Calcium Chloride
        stab_central = AcuteHyperkalemiaEngine.evaluate_membrane_stabilization(
            serum_potassium=6.8,
            ecg_findings=[ECGAbnormality.QRS_WIDENING],
            vascular_access=VascularAccessType.CENTRAL_VENOUS_LINE
        )
        self.assertTrue(stab_central.indicated)
        self.assertEqual(stab_central.agent_name, "Calcium Chloride 10%")
        self.assertAlmostEqual(stab_central.elemental_calcium_meq, 13.6)

    def test_intracellular_shift_hypoglycemia_guardrail(self):
        # Blood glucose 95 mg/dL -> High risk, full D50W mandatory
        shift_low = AcuteHyperkalemiaEngine.calculate_intracellular_shift(
            serum_potassium=6.7,
            blood_glucose_mg_dl=95.0
        )
        self.assertIn("HIGH HYPOGLYCEMIA RISK", shift_low.hypoglycemia_risk)
        self.assertIn("50 mL (25 g glucose)", shift_low.dextrose_dose)

        # Blood glucose 280 mg/dL -> Hold dextrose bolus
        shift_high = AcuteHyperkalemiaEngine.calculate_intracellular_shift(
            serum_potassium=6.7,
            blood_glucose_mg_dl=280.0
        )
        self.assertIn("Hold Dextrose", shift_high.dextrose_dose)

    def test_bicarbonate_strict_gating(self):
        # Normobicarbonatemic (pH 7.38, HCO3 24) -> Bicarbonate NOT indicated
        shift_norm = AcuteHyperkalemiaEngine.calculate_intracellular_shift(
            serum_potassium=6.9,
            blood_glucose_mg_dl=120.0,
            arterial_ph=7.38,
            serum_bicarbonate_mmol_l=24.0
        )
        self.assertFalse(shift_norm.sodium_bicarbonate_indicated)
        self.assertIn("NOT INDICATED", shift_norm.sodium_bicarbonate_rationale)

        # Severe Metabolic Acidosis (pH 7.10, HCO3 11) -> Bicarbonate INDICATED
        shift_acid = AcuteHyperkalemiaEngine.calculate_intracellular_shift(
            serum_potassium=6.9,
            blood_glucose_mg_dl=120.0,
            arterial_ph=7.10,
            serum_bicarbonate_mmol_l=11.0
        )
        self.assertTrue(shift_acid.sodium_bicarbonate_indicated)
        self.assertIn("INDICATED", shift_acid.sodium_bicarbonate_rationale)

    def test_emergency_dialysis_triggers(self):
        # ESRD patient with K=7.2 and peaked T-waves -> Emergent Dialysis
        elim_esrd = AcuteHyperkalemiaEngine.evaluate_elimination_strategy(
            serum_potassium=7.2,
            renal_status=RenalStatus.ESRD_ON_HEMODIALYSIS,
            ecg_refractory=True
        )
        self.assertTrue(elim_esrd.emergency_dialysis_indicated)
        self.assertFalse(elim_esrd.loop_diuretics_indicated)
        self.assertIn("EMERGENCY", elim_esrd.dialysis_urgency)

        # Normal renal function, K=5.8 -> Loop diuretics indicated, no dialysis
        elim_normal = AcuteHyperkalemiaEngine.evaluate_elimination_strategy(
            serum_potassium=5.8,
            renal_status=RenalStatus.NORMAL_RENAL_FUNCTION
        )
        self.assertFalse(elim_normal.emergency_dialysis_indicated)
        self.assertTrue(elim_normal.loop_diuretics_indicated)
        self.assertIn("Furosemide 40 mg", elim_normal.loop_diuretic_dose)

    def test_full_triage_resuscitation_cascade(self):
        triage = AcuteHyperkalemiaEngine.triage_hyperkalemia(
            serum_potassium=7.4,
            ecg_findings=[ECGAbnormality.QRS_WIDENING, ECGAbnormality.PEAKED_T_WAVES],
            vascular_access=VascularAccessType.PERIPHERAL_IV,
            blood_glucose_mg_dl=110.0,
            renal_status=RenalStatus.OLIGURIC_AKI,
            arterial_ph=7.12,
            serum_bicarbonate_mmol_l=12.0
        )
        self.assertEqual(triage.severity, HyperkalemiaSeverity.SEVERE)
        self.assertTrue(triage.membrane_stabilization.indicated)
        self.assertTrue(triage.intracellular_shift.insulin_dextrose_indicated)
        self.assertTrue(triage.intracellular_shift.sodium_bicarbonate_indicated)
        self.assertTrue(triage.elimination_strategy.emergency_dialysis_indicated)
        self.assertIn("Calcium Gluconate", triage.membrane_stabilization.agent_name)
        self.assertTrue(len(triage.immediate_action_checklist) >= 5)


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