from __future__ import annotations

from datetime import datetime, timezone

from fastapi import APIRouter, Depends, HTTPException

from sqlalchemy import select

from sqlalchemy.orm import Session

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

from app.models import (

    AuditLog, EnrichmentJob, EntityRelationship, OsintEntity, User,

)

from app.schemas import EnrichRunRequest

from app.services.enrichment import list_enrichers, run_enricher

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

@router.get("/enrichers")

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

    return list_enrichers()

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

def run(payload: EnrichRunRequest, db: Session = Depends(get_db),

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

    job = EnrichmentJob(investigation_id=payload.investigation_id, enricher=payload.enricher,

                        target=payload.target, status="running")

    db.add(job)

    db.flush()

    result = run_enricher(payload.enricher, payload.target)

    for ent in result.entities:

        existing = db.scalar(select(OsintEntity).where(

            OsintEntity.kind == ent.kind, OsintEntity.value == ent.value))

        now = datetime.now(timezone.utc)

        if existing:

            existing.last_seen = now

            existing.attributes = {**(existing.attributes or {}), **ent.attributes}

        else:

            db.add(OsintEntity(kind=ent.kind, value=ent.value, attributes=ent.attributes,

                               first_seen=now, last_seen=now))

    for rel in result.relationships:

        db.add(EntityRelationship(src_type=rel.src_kind, src_id=rel.src_value,

                                  dst_type=rel.dst_kind, dst_id=rel.dst_value,

                                  relation=rel.relation, confidence=rel.confidence,

                                  evidence_ref=payload.enricher))

    job.status = "done" if not result.error else "error"

    job.result = result.to_dict()

    job.confidence = result.confidence

    job.finished_at = datetime.now(timezone.utc)

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

                    entity_type="enrichment_job", entity_id=job.id,

                    meta={"enricher": payload.enricher, "target": payload.target,

                          "error": result.error}))

    db.commit()

    return {"job_id": job.id, "status": job.status, "result": result.to_dict()}

@router.get("/enrichment/jobs/{job_id}")

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

    job = db.get(EnrichmentJob, job_id)

    if not job:

        raise HTTPException(404, "job not found")

    return {"id": job.id, "enricher": job.enricher, "target": job.target,

            "status": job.status, "confidence": job.confidence, "result": job.result}