from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException

from pydantic import BaseModel

from sqlalchemy import func, select

from sqlalchemy.orm import Session

from app.api.deps import Perm, get_db, require

from app.models import (

    AuditLog, Camera, EntityPosition, LicensePlate, LiveEntity, PlateRead, User, Vehicle,

)

from app.services.connectors import get_connector, list_connectors

from app.services.ingest import ingest_live_reads

router = APIRouter(tags=["live-ingest"])

@router.get("/satellites")

def satellites(db: Session = Depends(get_db), _: User = Depends(require(Perm.READ))):

    """Live positions of real imaging satellites ('satellite cameras'), most recent snapshot."""

    rows = db.scalars(select(LiveEntity).where(LiveEntity.kind == "satellite_camera")

                      .order_by(LiveEntity.label)).all()

    return {"count": len(rows),

            "satellites": [{"identifier": s.identifier, "label": s.label, "lat": s.lat, "lon": s.lon,

                            "altitude_km": round(s.altitude_m / 1000, 1) if s.altitude_m else None,

                            "constellation": (s.attributes or {}).get("constellation"),

                            "period_min": (s.attributes or {}).get("period_min"),

                            "observed_at": s.observed_at} for s in rows]}

@router.get("/entities/{identifier}/track")

def entity_track(identifier: str, limit: int = 500, db: Session = Depends(get_db),

                 _: User = Depends(require(Perm.READ))):

    """Position history (trail) for any tracked entity - e.g. a satellite camera's ground track."""

    rows = db.scalars(select(EntityPosition).where(EntityPosition.identifier == identifier)

                      .order_by(EntityPosition.observed_at.desc()).limit(limit)).all()

    ent = db.scalar(select(LiveEntity).where(LiveEntity.identifier == identifier))

    return {"identifier": identifier, "label": ent.label if ent else None,

            "track": [{"lat": p.lat, "lon": p.lon, "altitude_m": p.altitude_m,

                       "observed_at": p.observed_at} for p in reversed(rows)]}

@router.get("/cameras/stats")

def cameras_stats(db: Session = Depends(get_db), _: User = Depends(require(Perm.READ))):

    by_op = db.execute(select(Camera.operator, func.count()).group_by(Camera.operator)

                       .order_by(func.count().desc()).limit(15)).all()

    by_state = db.execute(select(Camera.state, func.count()).group_by(Camera.state)

                          .order_by(func.count().desc())).all()

    return {"total": db.scalar(select(func.count()).select_from(Camera)) or 0,

            "satellite_cameras": db.scalar(select(func.count()).select_from(LiveEntity)

                                           .where(LiveEntity.kind == "satellite_camera")) or 0,

            "by_operator": [{"operator": o or "Unknown", "count": c} for o, c in by_op],

            "by_state": [{"state": s, "count": c} for s, c in by_state]}

@router.get("/ingest/recent")

def recent_reads(limit: int = 25, db: Session = Depends(get_db), _: User = Depends(require(Perm.READ))):

    """Most-recent plate reads (by ingest time) - drives the live activity feed."""

    rows = db.execute(

        select(PlateRead.plate_norm, PlateRead.read_ts, PlateRead.camera_id,

               PlateRead.confidence, PlateRead.hotlist_hit, LicensePlate.state, Camera.name)

        .join(LicensePlate, LicensePlate.id == PlateRead.plate_id, isouter=True)

        .join(Camera, Camera.id == PlateRead.camera_id, isouter=True)

        .order_by(PlateRead.id.desc()).limit(min(limit, 100))

    ).all()

    return [{"plate_norm": r[0], "read_ts": r[1], "camera_id": r[2],

             "confidence": float(r[3]) if r[3] is not None else None,

             "hotlist_hit": r[4], "state": r[5], "camera_name": r[6]} for r in rows]

@router.get("/stats")

def stats(db: Session = Depends(get_db), _: User = Depends(require(Perm.READ))):

    """Top-line counts for the dashboard - refreshed by the live feed."""

    return {

        "total_reads": db.scalar(select(func.count()).select_from(PlateRead)) or 0,

        "vehicles": db.scalar(select(func.count()).select_from(Vehicle)) or 0,

        "cameras": db.scalar(select(func.count()).select_from(Camera)) or 0,

        "states": db.scalar(select(func.count(func.distinct(LicensePlate.state)))) or 0,

        "hotlist_reads": db.scalar(select(func.count()).select_from(PlateRead).where(PlateRead.hotlist_hit.is_(True))) or 0,

    }

class StreamBatch(BaseModel):

    source_id: str | None = None

    label: str = "stream"

    reads: list[dict]

@router.post("/ingest/stream")

def ingest_stream(batch: StreamBatch, db: Session = Depends(get_db),

                  user: User = Depends(require(Perm.INGEST))):

    """Real-time ingest: push a batch of read objects (no file) straight into the pipeline -

    normalized, deduplicated, and evaluated against watchlists inline. Suitable for a camera

    edge device or message-bus consumer posting reads as they happen."""

    if not batch.reads:

        raise HTTPException(400, "no reads provided")

    if len(batch.reads) > 5000:

        raise HTTPException(413, "batch too large (max 5000 reads)")

    summary = ingest_live_reads(db, batch.source_id, batch.reads, batch.label, created_by=user.id)

    db.add(AuditLog(actor_user_id=user.id, action="ingest.stream",

                    entity_type="import", entity_id=summary.get("import_id"),

                    meta={"label": batch.label, "count": len(batch.reads)}))

    db.commit()

    return summary

@router.get("/connectors")

def connectors(_: User = Depends(require(Perm.READ))):

    return list_connectors()

class ConnectorRun(BaseModel):

    connector: str

    config: dict

    source_id: str | None = None

@router.post("/connectors/run")

def run_connector(req: ConnectorRun, db: Session = Depends(get_db),

                  user: User = Depends(require(Perm.INGEST))):

    """Invoke a connector to pull reads from an external source and ingest them now."""

    conn = get_connector(req.connector)

    if not conn:

        raise HTTPException(404, f"unknown connector '{req.connector}'")

    try:

        reads = conn.fetch(req.config)

    except Exception as e:

        raise HTTPException(502, f"connector fetch failed: {e}")

    if not reads:

        return {"fetched": 0, "inserted": 0, "note": "connector returned no reads"}

    summary = ingest_live_reads(db, req.source_id, reads, f"connector:{req.connector}",

                                created_by=user.id)

    db.add(AuditLog(actor_user_id=user.id, action="connector.run",

                    entity_type="import", entity_id=summary.get("import_id"),

                    meta={"connector": req.connector, "fetched": len(reads)}))

    db.commit()

    return {"fetched": len(reads), **summary}