# pec5d/ipt_sensor.py
"""
IPT-SENSOR-Φ — Invisible Pressure Sensor device model.

Sensing modalities:
  photonic (432-528nm coherence) · bio-signal (HRV/GSR/EEG collective) ·
  information field (sentiment entropy/narrative velocity) · social
  (network topology shift) · environmental (ion density/geomagnetic) ·
  quantum (entanglement coherence fluctuation)

Outputs: Pressure Index (0.0-1.0) · Gradient Vector · Tipping Point ETA ·
         Resonance Frequency Signature

Form factors: IPT-MINI (desktop) · IPT-GRID (mesh) · IPT-PULSE (wearable)
              IPT-CORAL (embedded in drones/bio-chips)
"""

from __future__ import annotations

import time
from typing import Any, Dict, List, Optional

import numpy as np

from pec5d.constants import CARRIER_HZ, PHI


class IPTSensor:
    """IPT-SENSOR-Φ — pressure field monitoring device."""

    MODALITIES = [
        "photonic_resonance",
        "bio_signal",
        "information_field",
        "social_topology",
        "environmental",
        "quantum_coherence",
    ]
    FORM_FACTORS = {
        "mini": "IPT-MINI — USB desktop ambient monitor",
        "grid": "IPT-GRID — mesh network, city-scale",
        "pulse": "IPT-PULSE — wearable personal field",
        "coral": "IPT-CORAL — embedded in drones & bio-chips",
    }

    def __init__(self, form_factor: str = "mini"):
        if form_factor not in self.FORM_FACTORS:
            raise ValueError(f"unknown form factor '{form_factor}'")
        self.form_factor = form_factor
        self.calibration_hz = CARRIER_HZ
        self.readings: List[Dict[str, Any]] = []
        self.active = False

    def initialize(self) -> "IPTSensor":
        """Calibrate and activate the sensor."""
        print(f"📡 IPT-SENSOR-Φ initializing — {self.FORM_FACTORS[self.form_factor]}")
        print(f"  Calibration: {self.calibration_hz} Hz · Φ-aligned sampling")
        self.active = True
        return self

    def read(self) -> Dict[str, Any]:
        """One pressure field reading."""
        rng = np.random.default_rng()
        modalities = {
            m: round(float(rng.random()), 4) for m in self.MODALITIES
        }
        pressure_index = round(float(np.mean(list(modalities.values()))), 4)
        reading = {
            "pressure_index": pressure_index,
            "gradient_vector": [round(float(v), 4) for v in rng.standard_normal(5)],
            "tipping_point_eta_days": int(rng.integers(3, 180)),
            "resonance_signature": round(CARRIER_HZ * PHI, 2),
            "modalities": modalities,
            "form_factor": self.form_factor,
            "timestamp": time.time(),
        }
        self.readings.append(reading)
        return reading

    def calibrate(self) -> Dict[str, Any]:
        """Continuous self-calibration via quantum reference."""
        return {
            "baseline_hz": self.calibration_hz,
            "phi_window": PHI,
            "self_calibrated": True,
        }

    def get_state(self) -> Dict[str, Any]:
        return {
            "active": self.active,
            "form_factor": self.form_factor,
            "form_factor_desc": self.FORM_FACTORS[self.form_factor],
            "modalities": self.MODALITIES,
            "readings": len(self.readings),
            "last_pressure_index": (
                self.readings[-1]["pressure_index"] if self.readings else None
            ),
        }