import collections, math
from dataclasses import dataclass, field
from enum import Enum

class Severity(Enum):
    WARNING = "warning"
    CRITICAL = "critical"

@dataclass
class Alert:
    value: float; z_score: float; severity: Severity; timestamp: float

class ZScoreDetector:
    """Rolling Welford Z-Score: O(1) update, numerically stable."""
    def __init__(self, window=100, warn_z=2.5, crit_z=3.0):
        self.window = window; self.warn_z = warn_z; self.crit_z = crit_z
        self._buf = collections.deque(maxlen=window)
        self._mean = 0.0; self._m2 = 0.0; self._n = 0

    def _add(self, x):
        if self._n == self.window:
            old = self._buf[0]; self._n -= 1
            delta_old = old - self._mean
            self._mean -= delta_old / self._n if self._n else 0
            self._m2 -= delta_old * (old - self._mean)
        self._buf.append(x); self._n += 1
        delta = x - self._mean; self._mean += delta / self._n
        self._m2 += delta * (x - self._mean)

    @property
    def std(self): return math.sqrt(self._m2 / self._n) if self._n > 1 else 0.0

    def update(self, x, ts=0.0):
        self._add(x)
        if self._n < 10: return None
        sigma = self.std
        if sigma == 0: return None
        z = (x - self._mean) / sigma
        if abs(z) >= self.crit_z: return Alert(x, z, Severity.CRITICAL, ts)
        if abs(z) >= self.warn_z: return Alert(x, z, Severity.WARNING, ts)
        return None

class EWMAControlChart:
    """EWMA with Shewhart overlay. Control limits narrow as n increases:
    UCL = mu0 + L*sigma*sqrt(alpha/(2-alpha) * (1-(1-alpha)^(2n)))"""
    def __init__(self, mu0, sigma, alpha=0.3, L=3.0, shewhart_z=3.5):
        self.mu0=mu0; self.sigma=sigma; self.alpha=alpha
        self.L=L; self.shewhart_z=shewhart_z
        self.ewma=mu0; self._n=0

    def _control_limits(self):
        a=self.alpha
        factor = a/(2-a) * (1 - (1-a)**(2*self._n))
        width = self.L * self.sigma * math.sqrt(factor)
        return self.mu0+width, self.mu0-width

    def update(self, x):
        self._n += 1
        self.ewma = self.alpha*x + (1-self.alpha)*self.ewma
        ucl, lcl = self._control_limits()
        if self.ewma > ucl: return {"exceeded":"upper","ewma":self.ewma,"ucl":ucl,"lcl":lcl}
        if self.ewma < lcl: return {"exceeded":"lower","ewma":self.ewma,"ucl":ucl,"lcl":lcl}
        # Shewhart overlay: single-point outlier
        shew_w = self.shewhart_z * self.sigma
        if abs(x - self.mu0) > shew_w: return {"exceeded":"shewhart","ewma":self.ewma}
        return None

class SelfStartingCUSUM:
    """Two-sided CUSUM. k=0.5 (Page's optimum for detecting 1-sigma shift).
    h=5 gives ARL0~370 on normal data (standard Shewhart equivalent).
    Self-starting: estimates mu/sigma from first 'warmup' samples."""
    def __init__(self, k=0.5, h=5, warmup=30):
        self.k=k; self.h=h; self.warmup=warmup
        self._buf=[]; self._sp=0.0; self._sn=0.0
        self._mu=None; self._sigma=None

    def update(self, x):
        if self._mu is None:
            self._buf.append(x)
            if len(self._buf) >= self.warmup:
                self._mu = sum(self._buf)/len(self._buf)
                self._sigma = (sum((v-self._mu)**2 for v in self._buf)/len(self._buf))**.5
            return None
        if self._sigma == 0: return None
        yi = (x - self._mu) / self._sigma
        self._sp = max(0, self._sp + yi - self.k)
        self._sn = max(0, self._sn - yi - self.k)
        if self._sp > self.h: return {"direction":"up","stat":self._sp}
        if self._sn > self.h: return {"direction":"down","stat":self._sn}
        return None

from sklearn.ensemble import IsolationForest
import numpy as np

class MultivariateSensorAnomalyDetector:
    """Isolation Forest for joint anomaly detection across correlated sensors.
    Pairs with per-sensor CUSUM for root-cause attribution."""
    def __init__(self, n_estimators=100, contamination=0.01, warmup=500):
        self._model = IsolationForest(n_estimators=n_estimators,
                                      contamination=contamination,
                                      random_state=42)
        self._warmup = warmup; self._buf = []

    def update(self, features: dict) -> dict | None:
        # features: {"temp":105.2, "vibration":0.83, "pressure":14.7, "rpm":1450}
        vec = list(features.values())
        self._buf.append(vec)
        if len(self._buf) < self._warmup:
            return None
        if len(self._buf) == self._warmup:
            self._model.fit(np.array(self._buf))

        score = self._model.score_samples([vec])[0]  # negative = more anomalous
        pred = self._model.predict([vec])[0]          # -1 = anomaly, 1 = normal
        if pred == -1:
            return {"anomaly": True, "score": float(score),
                    "features": features}
        return None