import os


def run_loop(runtime, client, queue, *, clock, sleep, iterations=None,
             sync_every=150, heartbeat_every=900, flush_every=300,
             frame_interval=0.0):
    counters = {"frames": 0, "syncs": 0, "beats": 0, "flushes": 0, "errors": 0}
    i = 0
    while iterations is None or i < iterations:
        i += 1
        try:
            runtime.step(clock())
            counters["frames"] += 1
        except Exception:
            counters["errors"] += 1
        try:
            if sync_every and i % sync_every == 0:
                cfg = client.fetch_config()
                if cfg is not None:
                    from edge.zones import zones_from_config
                    runtime.apply_zones(zones_from_config(cfg))
                    counters["syncs"] += 1
            if heartbeat_every and i % heartbeat_every == 0:
                if client.send_heartbeat({"fps": 0.0, "frames": counters["frames"]}):
                    counters["beats"] += 1
            if flush_every and i % flush_every == 0:
                queue.flush()
                counters["flushes"] += 1
        except Exception:
            counters["errors"] += 1
        if frame_interval:
            sleep(frame_interval)
    return counters


def main() -> None:  # pragma: no cover (integration entrypoint, exercised on device)
    import time
    from edge.config import load_config
    from edge.cloudclient import CloudClient
    from edge.alert import PostClient
    from edge.queue import OfflineQueue
    from edge.runtime import PipelineRuntime

    cfg = load_config(dict(os.environ))
    nonce = lambda: os.urandom(8).hex()
    now = time.time
    base = cfg.cafe24_url.rstrip("/")
    client = CloudClient(base, cfg.device_id, cfg.secret, nonce, now)
    post = PostClient(base + "/api/events", cfg.device_id, cfg.secret, nonce, now)
    queue = OfflineQueue(os.environ.get("QUEUE_DB", "queue.db"), post)
    # CAMERA_BACKEND selects the capture source: "csi" (Pi CSI cam via picamera2,
    # uses CSI_DEVICE) or the default "uvc" (USB webcam via OpenCV, uses UVC_DEVICE).
    if os.environ.get("CAMERA_BACKEND", "uvc").lower() == "csi":
        from edge.adapters.picamera_source import PiCameraSource
        source = PiCameraSource(int(os.environ.get("CSI_DEVICE", "0")))
    else:
        from edge.adapters.uvc_source import UvcSource
        source = UvcSource(int(os.environ.get("UVC_DEVICE", "0")))
    # POSE_BACKEND selects the accelerator path: "hailo" (Pi5 + Hailo-8, needs HAILO_HEF)
    # or the default CPU "movenet" (needs MOVENET_ONNX).
    if os.environ.get("POSE_BACKEND", "movenet").lower() == "hailo":
        from edge.adapters.hailo_pose import HailoPoseAdapter
        pose = HailoPoseAdapter(os.environ["HAILO_HEF"])
    else:
        from edge.adapters.movenet_pose import MoveNetPoseAdapter
        pose = MoveNetPoseAdapter(os.environ["MOVENET_ONNX"])
    runtime = PipelineRuntime(cfg, source, pose, queue)
    run_loop(runtime, client, queue, clock=now, sleep=time.sleep, iterations=None,
             frame_interval=1.0 / float(os.environ.get("TARGET_FPS", "12")))