from __future__ import annotations

from fastapi import APIRouter, Depends, Query

from sqlalchemy import select

from sqlalchemy.orm import Session

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

from app.core.config import settings

from app.models import AuditLog, Source, User

from app.schemas import SourceCreate, UserOut

router = APIRouter(tags=["admin"])

@router.get("/sources")

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

    return db.scalars(select(Source).order_by(Source.created_at.desc())).all()

@router.post("/sources", status_code=201)

def create_source(payload: SourceCreate, db: Session = Depends(get_db),

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

    src = Source(name=payload.name, system_type=payload.system_type,

                 organization=payload.organization, jurisdiction=payload.jurisdiction,

                 trust_level=payload.trust_level)

    db.add(src)

    db.commit()

    db.refresh(src)

    return src

@router.get("/users", response_model=list[UserOut])

def list_users(db: Session = Depends(get_db), _: User = Depends(require(Perm.ADMIN))):

    return db.scalars(select(User)).all()

@router.get("/audit")

def audit_log(entity_type: str | None = None, entity_id: str | None = None,

              actor: str | None = None, limit: int = Query(default=200, le=1000),

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

    q = select(AuditLog).order_by(AuditLog.created_at.desc()).limit(limit)

    if entity_type:

        q = q.where(AuditLog.entity_type == entity_type)

    if entity_id:

        q = q.where(AuditLog.entity_id == entity_id)

    if actor:

        q = q.where(AuditLog.actor_user_id == actor)

    rows = db.scalars(q).all()

    return [{"id": r.id, "actor": r.actor_user_id, "action": r.action,

             "entity_type": r.entity_type, "entity_id": r.entity_id,

             "metadata": r.meta, "at": r.created_at} for r in rows]

@router.post("/admin/retention/run")

def run_retention(dry_run: bool = True, db: Session = Depends(get_db),

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

    """Enforce the retention window. dry_run reports how many reads WOULD be deleted without

    deleting; set dry_run=false to actually purge. Always audited."""

    from datetime import datetime, timedelta, timezone

    from app.services.retention import count_expired, purge_expired

    cutoff = datetime.now(timezone.utc) - timedelta(days=settings.default_retention_days)

    count = count_expired(db, cutoff)

    deleted = 0

    if not dry_run:

        deleted = purge_expired(db, cutoff)

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

                    entity_type="settings", entity_id=None,

                    meta={"dry_run": dry_run, "cutoff": cutoff.isoformat(),

                          "candidates": count, "deleted": deleted}))

    db.commit()

    return {"cutoff": cutoff.isoformat(), "retention_days": settings.default_retention_days,

            "candidates": count, "deleted": deleted, "dry_run": dry_run}

@router.get("/admin/settings")

def get_settings(_: User = Depends(require(Perm.ADMIN))):

    return {

        "default_retention_days": settings.default_retention_days,

        "rate_limit_per_minute": settings.rate_limit_per_minute,

        "dedup_window_seconds": settings.dedup_window_seconds,

        "impossible_speed_kmh": settings.impossible_speed_kmh,

        "cotravel_window_seconds": settings.cotravel_window_seconds,

        "environment": settings.environment,

    }