"""Continuous RTSP ingestion worker. Connects to an RTSP/HTTP camera stream, runs the ALPR

engine on sampled frames, and ingests recognized plates as real reads - continuously, with

auto-reconnect. One worker per stream.

    python rtsp_worker.py <rtsp_url> [camera_external_id] [state]

Stops on SIGTERM/SIGINT. Dedup in the pipeline collapses the same plate seen repeatedly.

"""

from __future__ import annotations

import signal

import sys

import time

from datetime import datetime, timezone

from sqlalchemy import select

from app.db.session import SessionLocal

from app.models import Camera, Location, Source

from app.services.ingest import ingest_live_reads

from app.services.video_alpr import open_stream, process_capture

WINDOW_SECONDS = 12

SAMPLE_FPS = 2.0

_running = True

def _stop(*_):

    global _running

    _running = False

def main():

    if len(sys.argv) < 2:

        print("usage: python rtsp_worker.py <rtsp_url> [camera_external_id] [state]")

        sys.exit(2)

    url = sys.argv[1]

    cam_ext = sys.argv[2] if len(sys.argv) > 2 else None

    state = sys.argv[3] if len(sys.argv) > 3 else None

    signal.signal(signal.SIGTERM, _stop)

    signal.signal(signal.SIGINT, _stop)

    db = SessionLocal()

    cam = db.scalar(select(Camera).where(Camera.external_camera_id == cam_ext)) if cam_ext else None

    loc = db.get(Location, cam.location_id) if cam and cam.location_id else None

    src_id = cam.source_id if cam else (db.scalar(select(Source.id).limit(1)))

    print(f"RTSP worker: {url} -> camera {cam_ext or '(none)'}", flush=True)

    total = 0

    while _running:

        try:

            cap = open_stream(url)

        except Exception as e:

            print(f"open failed ({e}); retry in 5s", flush=True)

            time.sleep(5)

            continue

        try:

            res = process_capture(cap, sample_fps=SAMPLE_FPS, max_frames=int(WINDOW_SECONDS * SAMPLE_FPS),

                                  max_seconds=WINDOW_SECONDS, min_conf=0.45)

        except Exception as e:

            print(f"capture error: {e}", flush=True)

            res = {"plates": []}

        finally:

            cap.release()

        if res["plates"]:

            now = datetime.now(timezone.utc)

            reads = [{"plate": p["plate_norm"], "state": state or (cam.state if cam else None),

                      "timestamp": now.isoformat(), "camera": cam_ext or "rtsp-stream",

                      "latitude": loc.lat if loc else None, "longitude": loc.lon if loc else None,

                      "confidence": p["ocr_confidence"]} for p in res["plates"]]

            try:

                s = ingest_live_reads(db, src_id, reads, label=f"rtsp-{int(now.timestamp())}")

                total += s.get("inserted", 0)

                print(f"+{s.get('inserted',0)} reads ({[p['plate_norm'] for p in res['plates']]}) total={total}", flush=True)

            except Exception as e:

                print(f"ingest error: {e}", flush=True)

                db.rollback()

        if not _running:

            break

    db.close()

    print(f"RTSP worker stopped after {total} reads", flush=True)

if __name__ == "__main__":

    main()