python

# =====================================================================

# SYSTEM ARCHITECTURE: FOUR BRAINS CYBER-FORTRESS CONTROL LOOP (T1D)

# 

# ARCHITECT & DEVELOPER: Omer Giladi

# COPYRIGHT: © 2026 Omer Giladi. All Rights Reserved.

# VERSION: 7.0.0 (Cyber-Physical Military-Grade Resilience)

# =====================================================================



from fastapi import FastAPI, HTTPException

from pydantic import BaseModel

from typing import Dict, Any

from datetime import datetime, timezone

import hmac

import hashlib



app = FastAPI(

    title="Four Brains T1D - Cyber Fortress Engine",

    description=(

        "Universal mission-critical T1D control loop with Cryptographic HMAC validation, "

        "Temporal Drift Filters, and Synthetic Signal Spoof Detectors. Developed by Omer Giladi."

    ),

    version="7.0.0",

    contact={

        "name": "Omer Giladi",

    }

)



# --- Heuristic and Physical Constraints ---

PHI = 1.61803398875

INSULIN_ACTION_DURATION_MINS = 180.0

MAX_24H_TOTAL_DOSE_LIMIT = 35.0  

MAX_PHYSIOLOGICAL_VELOCITY = 5.0  

MAX_SINGLE_CORRECTION_DOSE = 2.5  



# Shared secret key used to validate hardware telemetry authenticity

SHARED_SECRET_KEY = b"Omer_Giladi_Secure_Bio_Key_2026"



class SecureMedicalSignal(BaseModel):

    patient_id: str

    age_group: str          # "CHILD", "TEEN", "ADULT"

    lifestyle: str          # "ACTIVE", "SEDENTARY"

    raw_value: float        

    timestamp: datetime     

    request_id: str         

    crypto_signature: str   # HMAC-SHA256 payload authentication token



T1D_STATE_DB: Dict[str, Dict[str, Any]] = {}



class PatientProfileT1D:

    def __init__(self, age_group: str, lifestyle: str):

        self.age_group = age_group

        self.lifestyle = lifestyle

        if age_group == "CHILD":

            self.insulin_sensitivity = 1.5 * PHI  

            self.basal_rate = 0.005

            self.safety_floor = 75.0               

        elif age_group == "TEEN":

            self.insulin_sensitivity = 0.8 * PHI  

            self.basal_rate = 0.015

            self.safety_floor = 70.0

        else:  

            self.insulin_sensitivity = 1.0 * PHI  

            self.basal_rate = 0.01

            self.safety_floor = 70.0



        if lifestyle == "ACTIVE":

            self.window_modifier = PHI            

        else:

            self.window_modifier = PHI ** 2       



@app.post("/api/v7/local/t1d/secure-process", tags=["Cyber-Fortress Core Loop"])

async def process_secure_t1d(payload: SecureMedicalSignal):

    pid = payload.patient_id

    current_time = payload.timestamp

    server_now = datetime.now(timezone.utc) if current_time.tzinfo else datetime.now()



    # --- CYBER GATE 1: Cryptographic Payload Signature Verification ---

    message_to_verify = f"{payload.patient_id}:{payload.raw_value}:{payload.request_id}".encode()

    expected_signature = hmac.new(SHARED_SECRET_KEY, message_to_verify, hashlib.sha256).hexdigest()



    if not hmac.compare_digest(payload.crypto_signature, expected_signature):

        raise HTTPException(status_code=401, detail="CYBER ALERT: Cryptographic signature mismatch. Token rejected.")



    # --- CYBER GATE 2: Temporal Drift Anti-Replay Mitigation ---

    time_drift_seconds = abs((server_now - current_time).total_seconds())

    if time_drift_seconds > 300:  

        raise HTTPException(status_code=400, detail="CYBER ALERT: Temporal drift anomaly. Replay attack suspected.")



    # --- Multitenant State Memory Initialization ---

    if pid not in T1D_STATE_DB:

        T1D_STATE_DB[pid] = {

            "profile": PatientProfileT1D(payload.age_group, payload.lifestyle),

            "last_value": payload.raw_value,

            "last_timestamp": current_time,

            "epsilon_history": [],  

            "insulin_history": [],  

            "daily_dose_history": [], 

            "linear_trends_counter": 0, 

            "requests": set()

        }



    state = T1D_STATE_DB[pid]

    profile = state["profile"]



    if payload.request_id in state["requests"]:

        raise HTTPException(status_code=400, detail="Security Block: Duplicate request identity.")



    time_delta = (current_time - state["last_timestamp"]).total_seconds() / 60.0

    signal_dropout_active = time_delta > 15.0

    if signal_dropout_active:

        state["epsilon_history"].clear()

        time_delta = 5.0

    if time_delta <= 0: time_delta = 5.0



    # --- BRAIN A: Sensing & Epsilon Filtering ---

    instant_epsilon = (payload.raw_value - state["last_value"]) / time_delta



    # --- CYBER GATE 3: Synthetic Linear Spoof Detector (BAAG Heuristics) ---

    if len(state["epsilon_history"]) > 0 and abs(instant_epsilon - state["epsilon_history"][-1]) < 0.001 and instant_epsilon > 0:

        state["linear_trends_counter"] += 1

    else:

        state["linear_trends_counter"] = max(0, state["linear_trends_counter"] - 1)



    signal_spoofed = state["linear_trends_counter"] >= 4 



    if not signal_dropout_active:

        state["epsilon_history"].append(instant_epsilon)

        if len(state["epsilon_history"]) > 3:

            state["epsilon_history"].pop(0)

        smoothed_epsilon = sum(state["epsilon_history"]) / len(state["epsilon_history"])

    else:

        smoothed_epsilon = instant_epsilon  



    # --- BRAIN B: Prediction Engine (Fibonacci Dynamics) ---

    prediction_window = profile.window_modifier

    predicted_glucose = payload.raw_value + (smoothed_epsilon * prediction_window)

    is_harmonic = abs(smoothed_epsilon) <= PHI  



    # --- Rigid Biological Sanity Isolation ---

    fibonacci_valid = True

    failsafe_reason = "NOMINAL_OPERATION"



    if abs(smoothed_epsilon) > MAX_PHYSIOLOGICAL_VELOCITY or abs(predicted_glucose - payload.raw_value) > 80.0:

        fibonacci_valid = False

        failsafe_reason = "BIOLOGICAL_FALLBACK: Mathematical prediction integrity compromised."



    if signal_spoofed:

        fibonacci_valid = False

        failsafe_reason = "CYBER LOCKDOWN: Synthetic signal attack detected. Dynamic dosing suspended."



    # --- Insulin-On-Board (IOB) Decay Estimator ---

    active_iob = 0.0

    valid_insulin_events = []

    for event in state["insulin_history"]:

        elapsed_mins = (current_time - event["time"]).total_seconds() / 60.0

        if elapsed_mins < INSULIN_ACTION_DURATION_MINS:

            remaining_factor = 1.0 - (elapsed_mins / INSULIN_ACTION_DURATION_MINS)

            active_iob += event["dose"] * remaining_factor

            valid_insulin_events.append(event)

    state["insulin_history"] = valid_insulin_events



    # --- Total Daily Dose (TDD) Tracking Window ---

    total_24h_injected = 0.0

    valid_24h_events = []

    for event in state["daily_dose_history"]:

        elapsed_hours = (current_time - event["time"]).total_seconds() / 3600.0

        if elapsed_hours < 24.0:

            total_24h_injected += event["dose"]

            valid_24h_events.append(event)

    state["daily_dose_history"] = valid_24h_events



    # --- BRAIN C: The Selector / Arbiter with Double-Gate Controls ---

    raw_target_dose = 0.0

    tdd_ceiling_breached = total_24h_injected >= MAX_24H_TOTAL_DOSE_LIMIT



    if tdd_ceiling_breached:

        raw_target_dose = profile.basal_rate

        failsafe_reason = f"HARDWARE RESTRAINT: 24h TDD Limit Exceeded ({total_24h_injected:.2f} U)."



    elif not fibonacci_valid:

        if payload.raw_value > 150.0 and not signal_spoofed:

            static_deviation = payload.raw_value - 130.0

            raw_target_dose = max((((static_deviation / profile.insulin_sensitivity) * 0.015) - active_iob), 0.0)

        else:

            raw_target_dose = profile.basal_rate  



    elif predicted_glucose > 135.0:

        deviation = predicted_glucose - 130.0

        calculated_correction = (deviation / profile.insulin_sensitivity) * 0.02

        if calculated_correction > active_iob:

            raw_target_dose = calculated_correction - active_iob

            failsafe_reason = "NOMINAL: Micro-dose calculated successfully."

        else:

            raw_target_dose = 0.0

            failsafe_reason = "NOMINAL: Internal IOB satisfies current delta."

    else:

        raw_target_dose = profile.basal_rate * PHI

        failsafe_reason = "NOMINAL: Basal maintenance active."



    # --- CRITICAL INVARIANT GATE: Hardware Corridor Protection ---

    if raw_target_dose > MAX_SINGLE_CORRECTION_DOSE:

        raw_target_dose = MAX_SINGLE_CORRECTION_DOSE

        failsafe_reason += " [CAPPED: Absolute Biological Limit Triggered]."



    # --- BRAIN D: The Amygdala (Absolute Biological Fail-Safe Reflex) ---

    safety_override = False

    if payload.raw_value < profile.safety_floor:

        safety_override = True

        final_dose = 0.0

        status = "CRITICAL_FAIL_SAFE"

        failsafe_reason = f"AMYGDALA DIRECT OVERRIDE: Glucose at {payload.raw_value} mg/dL breached safety floor. Infusion cut."

    else:

        final_dose = raw_target_dose

        status = "NORMAL_HARMONIC_T1D" if fibonacci_valid and not tdd_ceiling_breached else "SECURE_PROTECTED_STATE"



    # --- Memory Mutation Commit ---

    state["last_value"] = payload.raw_value

    state["last_timestamp"] = current_time

    state["requests"].add(payload.request_id)



    if final_dose > 0:

        event_record = {"time": current_time, "dose": final_dose}

        state["insulin_history"].append(event_record)

        state["daily_dose_history"].append(event_record)



    return {

        "status": status,

        "patient_id": pid,

        "developer_credit": "Developed by Omer Giladi",

        "cyber_security": {

            "signature_verified": True,

            "temporal_drift_seconds": round(time_drift_seconds, 1),

            "signal_spoofing_detected": signal_spoofed

        },

        "telemetry": {

            "current_glucose": payload.raw_value,

            "smoothed_epsilon": round(smoothed_epsilon, 3),

            "fibonacci_prediction": round(predicted_glucose, 1) if fibonacci_valid and not signal_spoofed else -1.0

        },

        "control_action": {

            "override_active": safety_override,

            "insulin_dose_units": round(final_dose, 3),

            "clinical_log": failsafe_reason

        }

    }