from edge.app import run_once
from edge.tracking import IouTracker
from edge.smoothing import TrackSmootherPool
from edge.detectors.fall import FallDetector
from edge.detectors.immobility import ImmobilityWatchdog
from edge.detectors.ghost import GhostIncidentDetector
from edge.detectors.zone import ZoneIntrusionDetector
from edge.engine import EventEngine
from edge.snapshot import RingBuffer, FaceBlurrer, Snapshotter


class PipelineRuntime:
    def __init__(self, config, source, pose, sink, wall_clock=None):
        self.config = config
        self.camera_id = config.camera_id  # for per-camera zone routing (multi-cam)
        self.source = source
        self.pose = pose
        self.sink = sink
        # Wall clock for Event.occurred_at only; the loop clock (step's `now`) is monotonic. None
        # off-daemon -> run_once stamps occurred_at with the monotonic `now`, preserving old tests.
        self._wall = wall_clock
        self.tracker = IouTracker()
        self.pool = TrackSmootherPool()
        self.zone_detector = ZoneIntrusionDetector([], config.zone)
        self.engine = EventEngine(
            FallDetector(config.fall),
            ImmobilityWatchdog(config.immobility),
            GhostIncidentDetector(config.ghost),
            self.zone_detector,
            config.engine,
        )
        self.ring = RingBuffer()
        self.snapshotter = Snapshotter(FaceBlurrer())

    def step(self, now: float) -> list:
        return run_once(self.source, self.pose, self.tracker, self.pool,
                        self.engine, self.ring, self.snapshotter, self.sink,
                        now_fn=lambda: now, wall_fn=self._wall)

    def apply_zones(self, zones: list) -> None:
        self.zone_detector.zones = list(zones)