use axum::{
    body::Body,
    extract::{Path, Query, State},
    http::{header, StatusCode},
    response::{IntoResponse, Json, Response},
    routing::{get, post},
    Router,
};
use serde::{Deserialize, Serialize};

use crate::core::db::PostgresDb;

pub fn trace_agent_routes() -> Router<crate::api::types::AppState> {
    Router::new()
        .route("/api/v1/file/:file_uuid/traces", post(list_traces_sorted))
        .route(
            "/api/v1/file/:file_uuid/trace/:trace_id/faces",
            get(list_trace_faces),
        )
        .route(
            "/api/v1/file/:file_uuid/trace/:trace_id/representative-face",
            get(get_representative_face),
        )
        .route(
            "/api/v1/file/:file_uuid/trace/:trace_id/thumbnail",
            get(get_trace_thumbnail),
        )
        .route(
            "/api/v1/file/:file_uuid/identities/:identity_uuid_a/co-occur-with/:identity_uuid_b",
            get(get_cooccurrence),
        )
        .route(
            "/api/v1/file/:file_uuid/tkg/rebuild",
            post(rebuild_tkg),
        )
        .route(
            "/api/v1/file/:file_uuid/representative-frame",
            get(get_representative_frame),
        )
}

#[derive(Debug, Deserialize)]
struct TracesRequest {
    min_faces: Option<i64>,
    sort_by: Option<String>,
    page: Option<i64>,
    page_size: Option<i64>,
    limit: Option<i64>,
    min_confidence: Option<f64>,
    max_confidence: Option<f64>,
}

#[derive(Debug, Serialize)]
struct TraceInfo {
    trace_id: i32,
    face_count: i64,
    start_frame: i32,
    end_frame: i32,
    start_time: f64,
    end_time: f64,
    duration_sec: f64,
    avg_confidence: f64,
    sample_face_id: Option<String>,
}

#[derive(Debug, Serialize)]
struct TracesResponse {
    success: bool,
    file_uuid: String,
    fps: f64,
    total_traces: i64,
    total_faces: i64,
    page: i64,
    page_size: i64,
    traces: Vec<TraceInfo>,
}

async fn list_traces_sorted(
    State(state): State<crate::api::types::AppState>,
    Path(file_uuid): Path<String>,
    Json(req): Json<TracesRequest>,
) -> Result<Json<TracesResponse>, (StatusCode, String)> {
    let min_faces = req.min_faces.unwrap_or(1);
    let sort = req.sort_by.as_deref().unwrap_or("first_appearance");
    let page = req.page.unwrap_or(1).max(1);
    let page_size = req.page_size.unwrap_or(50).max(1).min(500);
    let hard_limit = req.limit.unwrap_or(500);
    let effective_limit = hard_limit.min(page_size);
    let db_offset = (page - 1) * page_size;
    let min_confidence = req.min_confidence.unwrap_or(0.0);
    let max_confidence = req.max_confidence.unwrap_or(1.0);

    let order_clause = match sort {
        "face_count" => "face_count DESC",
        "duration" => "duration_sec DESC",
        _ => "start_frame ASC",
    };

    let fps: f64 = sqlx::query_scalar(&format!(
        "SELECT COALESCE(fps, 24.0) FROM {} WHERE file_uuid = $1",
        crate::core::db::schema::table_name("videos")
    ))
    .bind(&file_uuid)
    .fetch_optional(state.db.pool())
    .await
    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
    .unwrap_or(24.0);

    let query = format!(
        "SELECT tt.*, fd.id AS sample_face_id FROM (
            SELECT trace_id::int AS trace_id,
                   COUNT(*) AS face_count,
                   MIN(frame_number)::int AS start_frame,
                   MAX(frame_number)::int AS end_frame,
                   (MAX(frame_number) - MIN(frame_number))::float8 AS duration_sec,
                   AVG(confidence)::float8 AS avg_confidence
            FROM {}
            WHERE file_uuid = $1 AND trace_id IS NOT NULL
              AND confidence >= $5 AND confidence <= $6
            GROUP BY trace_id
            HAVING COUNT(*) >= $2
            ORDER BY {}
            LIMIT $3 OFFSET $4
        ) tt
         LEFT JOIN LATERAL (
             SELECT id FROM {}
             WHERE trace_id = tt.trace_id AND file_uuid = $1
             ORDER BY confidence DESC LIMIT 1
         ) fd ON true",
        crate::core::db::schema::table_name("face_detections"),
        order_clause,
        crate::core::db::schema::table_name("face_detections"),
    );

    let rows: Vec<(i32, i64, i32, i32, f64, f64, Option<i32>)> = sqlx::query_as(&query)
        .bind(&file_uuid)
        .bind(min_faces)
        .bind(effective_limit)
        .bind(db_offset)
        .bind(min_confidence)
        .bind(max_confidence)
        .fetch_all(state.db.pool())
        .await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let traces: Vec<TraceInfo> = rows
        .into_iter()
        .map(|(tid, fc, sf, ef, dur, conf, fid)| TraceInfo {
            trace_id: tid,
            face_count: fc,
            start_frame: sf,
            end_frame: ef,
            start_time: sf as f64 / fps,
            end_time: ef as f64 / fps,
            duration_sec: dur / fps,
            avg_confidence: conf,
            sample_face_id: fid.map(|v| v.to_string()),
        })
        .collect();

    let (total_traces, total_faces): (i64, i64) = sqlx::query_as(
        &format!("SELECT COUNT(DISTINCT trace_id), COUNT(*) FROM {} WHERE file_uuid = $1 AND trace_id IS NOT NULL",
            crate::core::db::schema::table_name("face_detections"))
    )
    .bind(&file_uuid)
    .fetch_one(state.db.pool())
    .await
    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    Ok(Json(TracesResponse {
        success: true,
        file_uuid,
        fps,
        total_traces,
        total_faces,
        page,
        page_size,
        traces,
    }))
}

// ── Individual face detections for a trace ──

#[derive(Debug, Deserialize)]
struct TraceFacesQuery {
    page: Option<i64>,
    page_size: Option<i64>,
    limit: Option<i64>,
    offset: Option<i64>,
    interpolate: Option<bool>,
}

#[derive(Debug, Serialize)]
struct TraceFaceItem {
    id: i32,
    start_frame: i32,
    end_frame: i32,
    start_time: f64,
    end_time: f64,
    x: Option<i32>,
    y: Option<i32>,
    width: Option<i32>,
    height: Option<i32>,
    confidence: f64,
    interpolated: bool,
}

#[derive(Debug, Serialize)]
struct TraceFacesResponse {
    success: bool,
    file_uuid: String,
    trace_id: i32,
    fps: f64,
    total: i64,
    faces: Vec<TraceFaceItem>,
}

fn lerp_i32(a: Option<i32>, b: Option<i32>, t: f64) -> Option<i32> {
    match (a, b) {
        (Some(av), Some(bv)) => Some((av as f64 + (bv - av) as f64 * t).round() as i32),
        _ => None,
    }
}

async fn list_trace_faces(
    State(state): State<crate::api::types::AppState>,
    Path((file_uuid, trace_id)): Path<(String, i32)>,
    Query(q): Query<TraceFacesQuery>,
) -> Result<Json<TraceFacesResponse>, (StatusCode, String)> {
    let limit = q.limit.unwrap_or(200).min(1000);
    // Support both page/page_size and offset; page/page_size takes precedence
    let offset = if q.page.is_some() || q.page_size.is_some() {
        let p = q.page.unwrap_or(1).max(1);
        let ps = q.page_size.unwrap_or(200).max(1).min(1000);
        (p - 1) * ps
    } else {
        q.offset.unwrap_or(0)
    };
    let interpolate = q.interpolate.unwrap_or(false);

    let fps: f64 = sqlx::query_scalar(&format!(
        "SELECT COALESCE(fps, 24.0) FROM {} WHERE file_uuid = $1",
        crate::core::db::schema::table_name("videos")
    ))
    .bind(&file_uuid)
    .fetch_optional(state.db.pool())
    .await
    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
    .unwrap_or(24.0);

    let total_detected: i64 = sqlx::query_scalar(&format!(
        "SELECT COUNT(*) FROM {} WHERE file_uuid = $1 AND trace_id = $2",
        crate::core::db::schema::table_name("face_detections")
    ))
    .bind(&file_uuid)
    .bind(trace_id)
    .fetch_one(state.db.pool())
    .await
    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let rows: Vec<(
        i32,
        i32,
        Option<i32>,
        Option<i32>,
        Option<i32>,
        Option<i32>,
        f32,
    )> = sqlx::query_as(&format!(
        "SELECT id, frame_number::int, x, y, width, height, confidence::float4 \
                   FROM {} WHERE file_uuid = $1 AND trace_id = $2 \
                   ORDER BY frame_number ASC LIMIT $3 OFFSET $4",
        crate::core::db::schema::table_name("face_detections")
    ))
    .bind(&file_uuid)
    .bind(trace_id)
    .bind(limit)
    .bind(offset)
    .fetch_all(state.db.pool())
    .await
    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let mut faces: Vec<TraceFaceItem> = Vec::new();

    for (i, (id, frame, x, y, w, h, conf)) in rows.iter().enumerate() {
        let cur = (x, y, w, h);

        // Add interpolated frames between previous and current detection
        if interpolate && i > 0 {
            let prev = &rows[i - 1];
            let prev_frame = prev.1;
            let gap = frame - prev_frame;
            if gap > 1 {
                for mid in 1..gap {
                    let t = mid as f64 / gap as f64;
                    let mid_x = lerp_i32(prev.2, *x, t);
                    let mid_y = lerp_i32(prev.3, *y, t);
                    let mid_w = lerp_i32(prev.4, *w, t);
                    let mid_h = lerp_i32(prev.5, *h, t);
                    let mid_frame = prev_frame + mid;
                    let mt = (mid_frame as f64 / fps * 10.0).round() / 10.0;
                    faces.push(TraceFaceItem {
                        id: 0,
                        start_frame: mid_frame,
                        end_frame: mid_frame,
                        start_time: mt,
                        end_time: mt,
                        x: mid_x,
                        y: mid_y,
                        width: mid_w,
                        height: mid_h,
                        confidence: 0.0,
                        interpolated: true,
                    });
                }
            }
        }

        // Add the real detection
        let frame_val = *frame;
        let ft = (frame_val as f64 / fps * 10.0).round() / 10.0;
        faces.push(TraceFaceItem {
            id: *id,
            start_frame: frame_val,
            end_frame: frame_val,
            start_time: ft,
            end_time: ft,
            x: *x,
            y: *y,
            width: *w,
            height: *h,
            confidence: *conf as f64,
            interpolated: false,
        });
    }

    let total = if interpolate && faces.len() as i64 > total_detected {
        faces.len() as i64
    } else {
        total_detected
    };

    Ok(Json(TraceFacesResponse {
        success: true,
        file_uuid,
        trace_id,
        fps,
        total,
        faces,
    }))
}

#[derive(Debug, Serialize)]
struct RepFaceBbox {
    x: i32,
    y: i32,
    width: i32,
    height: i32,
}

#[derive(Debug, Serialize)]
struct RepFaceResult {
    frame_number: i64,
    timestamp_secs: f64,
    bbox: RepFaceBbox,
    confidence: f64,
    quality_score: f64,
    blur_score: f64,
}

#[derive(Debug, Serialize)]
struct RepFaceResponse {
    success: bool,
    file_uuid: String,
    trace_id: i32,
    face_count: i64,
    representative: RepFaceResult,
}

struct RepFaceSelection {
    frame: i64,
    x: i32,
    y: i32,
    w: i32,
    h: i32,
    conf: f64,
    blur: f64,
    score: f64,
    video_path: String,
    fps: f64,
    face_count: i64,
}

async fn select_rep_face<F, T>(
    pool: &sqlx::PgPool,
    file_uuid: &str,
    trace_id: i32,
    err_fn: F,
) -> Result<RepFaceSelection, T>
where
    F: Fn(anyhow::Error) -> T,
{
    use crate::core::db::schema;
    let fd_table = schema::table_name("face_detections");
    let video_table = schema::table_name("videos");

    let fps: f64 = sqlx::query_scalar(&format!(
        "SELECT COALESCE(fps, 25.0) FROM {} WHERE file_uuid = $1", video_table
    ))
    .bind(file_uuid)
    .fetch_optional(pool)
    .await
    .map_err(|e| err_fn(anyhow::anyhow!("{}", e)))?
    .unwrap_or(25.0);

    let face_count: (i64,) = sqlx::query_as(&format!(
        "SELECT COUNT(*) FROM {} WHERE file_uuid = $1 AND trace_id = $2", fd_table
    ))
    .bind(file_uuid)
    .bind(trace_id)
    .fetch_one(pool)
    .await
    .map_err(|e| err_fn(anyhow::anyhow!("{}", e)))?;

    struct Candidate { frame: i64, x: i32, y: i32, w: i32, h: i32, conf: f64, score: f64 }

    let rows = sqlx::query_as::<_, (i64, i32, i32, i32, i32, f64)>(&format!(
        "SELECT frame_number::bigint, x, y, width, height, confidence::float8 \
         FROM {} WHERE file_uuid = $1 AND trace_id = $2 AND confidence > 0.7 \
         AND ((metadata->>'qc_ok')::boolean IS NULL OR (metadata->>'qc_ok')::boolean = true) \
         ORDER BY (width::float8 * height::float8) * confidence::float8 DESC LIMIT 10",
        fd_table
    ))
    .bind(file_uuid).bind(trace_id)
    .fetch_all(pool)
    .await
    .map_err(|e| err_fn(anyhow::anyhow!("{}", e)))?;

    if rows.is_empty() {
        return Err(err_fn(anyhow::anyhow!("No suitable face found")));
    }

    let candidates: Vec<Candidate> = rows.into_iter()
        .map(|(frame, x, y, w, h, conf)| {
            let score = (w as f64 * h as f64) * conf;
            Candidate { frame, x, y, w, h, conf, score }
        })
        .collect();

    let video_path: String = sqlx::query_scalar(&format!(
        "SELECT file_path FROM {} WHERE file_uuid = $1", video_table
    ))
    .bind(file_uuid)
    .fetch_optional(pool)
    .await
    .map_err(|e| err_fn(anyhow::anyhow!("{}", e)))?
    .ok_or_else(|| err_fn(anyhow::anyhow!("Video not found")))?;

    let mut best = candidates[0].frame;
    let mut best_blur = f64::MAX;
    let mut best_idx = 0usize;

    for (i, c) in candidates.iter().enumerate() {
        let seek = c.frame as f64 / fps;
        if let Ok(output) = tokio::process::Command::new("ffmpeg")
            .args(["-ss", &format!("{:.2}", seek), "-i", &video_path,
                   "-vframes", "1", "-vf", &format!("crop={}:{}:{}:{},blurdetect", c.w, c.h, c.x, c.y),
                   "-f", "null", "-"])
            .output().await
        {
            let stderr = String::from_utf8_lossy(&output.stderr);
            for line in stderr.lines() {
                if let Some(blur_str) = line.split("blur mean: ").nth(1) {
                    if let Ok(blur) = blur_str.trim().parse::<f64>() {
                        if blur < best_blur { best_blur = blur; best = c.frame; best_idx = i; }
                    }
                }
            }
        }
    }

    let chosen = &candidates[best_idx];
    Ok(RepFaceSelection {
        frame: chosen.frame, x: chosen.x, y: chosen.y, w: chosen.w, h: chosen.h,
        conf: chosen.conf, blur: best_blur, score: chosen.score,
        video_path, fps, face_count: face_count.0,
    })
}

async fn get_representative_face(
    State(state): State<crate::api::types::AppState>,
    Path((file_uuid, trace_id)): Path<(String, i32)>,
) -> Result<Json<RepFaceResponse>, (StatusCode, Json<serde_json::Value>)> {
    let sel = select_rep_face(state.db.pool(), &file_uuid, trace_id, |e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    }).await?;

    Ok(Json(RepFaceResponse {
        success: true,
        file_uuid,
        trace_id,
        face_count: sel.face_count,
        representative: RepFaceResult {
            frame_number: sel.frame,
            timestamp_secs: sel.frame as f64 / sel.fps,
            bbox: RepFaceBbox { x: sel.x, y: sel.y, width: sel.w, height: sel.h },
            confidence: sel.conf,
            quality_score: sel.score,
            blur_score: sel.blur,
        },
    }))
}

async fn get_trace_thumbnail(
    State(state): State<crate::api::types::AppState>,
    Path((file_uuid, trace_id)): Path<(String, i32)>,
) -> Result<Response, (StatusCode, Json<serde_json::Value>)> {
    let sel = select_rep_face(state.db.pool(), &file_uuid, trace_id, |e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    }).await?;

    let seek = sel.frame as f64 / sel.fps;
    let tmp = std::env::temp_dir().join(format!("trace_{}_{}.jpg", file_uuid, trace_id));

    let status = tokio::process::Command::new("ffmpeg")
        .args([
            "-ss", &format!("{:.2}", seek),
            "-i", &sel.video_path,
            "-vframes", "1",
            "-vf", &format!("crop={}:{}:{}:{},scale=320:320", sel.w, sel.h, sel.x, sel.y),
            "-q:v", "2",
            "-y", &tmp.to_string_lossy().to_string(),
        ])
        .output()
        .await
        .map_err(|e| {
            (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
        })?;

    if !status.status.success() {
        return Err((StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": "FFmpeg failed"}))));
    }

    let bytes = tokio::fs::read(&tmp).await.map_err(|e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    })?;

    let _ = tokio::fs::remove_file(&tmp).await;

    Ok(Response::builder()
        .status(StatusCode::OK)
        .header(header::CONTENT_TYPE, "image/jpeg")
        .header(header::CACHE_CONTROL, "public, max-age=86400")
        .body(Body::from(bytes))
        .unwrap())
}

#[derive(Debug, Serialize)]
struct CoOccurIdentity {
    identity_uuid: String,
    name: String,
    trace_id: i32,
}

#[derive(Debug, Serialize)]
struct CoOccurRepFace {
    frame_number: i64,
    bbox: RepFaceBbox,
    confidence: f64,
    thumbnail_url: String,
}

#[derive(Debug, Serialize)]
struct CoOccurrence {
    frame_number: i64,
    timestamp_secs: f64,
    total_cooccurrence_frames: i64,
    representative_face_a: Option<CoOccurRepFace>,
    representative_face_b: Option<CoOccurRepFace>,
}

#[derive(Debug, Serialize)]
struct CoOccurResponse {
    success: bool,
    file_uuid: String,
    identity_a: CoOccurIdentity,
    identity_b: CoOccurIdentity,
    first_cooccurrence: CoOccurrence,
}

async fn get_cooccurrence(
    State(state): State<crate::api::types::AppState>,
    Path((file_uuid, identity_uuid_a, identity_uuid_b)): Path<(String, String, String)>,
) -> Result<Json<CoOccurResponse>, (StatusCode, Json<serde_json::Value>)> {
    use crate::core::db::schema;
    let id_table = schema::table_name("identities");
    let fd_table = schema::table_name("face_detections");

    // Stage 1: Get identity names and IDs
    let id_a = sqlx::query_as::<_, (i32, String)>(&format!(
        "SELECT id, name FROM {} WHERE uuid::text = $1 OR REPLACE(uuid::text, '-', '') = $1",
        id_table
    ))
    .bind(&identity_uuid_a)
    .fetch_optional(state.db.pool())
    .await
    .map_err(|e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    })?
    .ok_or_else(|| {
        (StatusCode::NOT_FOUND, Json(serde_json::json!({"error": "Identity A not found"})))
    })?;

    let id_b = sqlx::query_as::<_, (i32, String)>(&format!(
        "SELECT id, name FROM {} WHERE uuid::text = $1 OR REPLACE(uuid::text, '-', '') = $1",
        id_table
    ))
    .bind(&identity_uuid_b)
    .fetch_optional(state.db.pool())
    .await
    .map_err(|e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    })?
    .ok_or_else(|| {
        (StatusCode::NOT_FOUND, Json(serde_json::json!({"error": "Identity B not found"})))
    })?;

    // Stage 2: Find first frame where both identity_ids appear
    let cooccur: Option<(i64,)> = sqlx::query_as(
        &format!(
            "SELECT MIN(fd.frame_number)::bigint FROM {} fd \
             WHERE fd.file_uuid = $1 AND fd.identity_id = $2 \
             AND fd.frame_number IN ( \
               SELECT frame_number FROM {} \
               WHERE file_uuid = $1 AND identity_id = $3 \
             )",
            fd_table, fd_table
        )
    )
    .bind(&file_uuid)
    .bind(id_a.0)
    .bind(id_b.0)
    .fetch_optional(state.db.pool())
    .await
    .map_err(|e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    })?;

    let (first_frame,) = cooccur.ok_or_else(|| {
        (StatusCode::NOT_FOUND, Json(serde_json::json!({"error": "These two identities never appear together in this file"})))
    })?;

    // Get fps for timestamp
    let video_table = schema::table_name("videos");
    let fps: f64 = sqlx::query_scalar(&format!(
        "SELECT COALESCE(fps, 25.0) FROM {} WHERE file_uuid = $1", video_table
    ))
    .bind(&file_uuid)
    .fetch_optional(state.db.pool())
    .await
    .map_err(|e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    })?
    .unwrap_or(25.0);

    // Stage 3: Get trace_ids for both at this frame
    let trace_a: Option<(i32,)> = sqlx::query_as(
        &format!("SELECT trace_id FROM {} WHERE file_uuid = $1 AND frame_number = $2 AND identity_id = $3 AND trace_id IS NOT NULL LIMIT 1", fd_table)
    )
    .bind(&file_uuid).bind(first_frame).bind(id_a.0)
    .fetch_optional(state.db.pool()).await
    .map_err(|e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    })?;

    let trace_b: Option<(i32,)> = sqlx::query_as(
        &format!("SELECT trace_id FROM {} WHERE file_uuid = $1 AND frame_number = $2 AND identity_id = $3 AND trace_id IS NOT NULL LIMIT 1", fd_table)
    )
    .bind(&file_uuid).bind(first_frame).bind(id_b.0)
    .fetch_optional(state.db.pool()).await
    .map_err(|e| {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
    })?;

    // Stage 4: Get representative faces for both traces (reusing select_rep_face)
    let rep_a = if let Some((tid,)) = trace_a {
        select_rep_face(state.db.pool(), &file_uuid, tid, |e| {
            (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
        }).await.ok().map(|sel| CoOccurRepFace {
            frame_number: sel.frame,
            bbox: RepFaceBbox { x: sel.x, y: sel.y, width: sel.w, height: sel.h },
            confidence: sel.conf,
            thumbnail_url: format!("/api/v1/file/{}/trace/{}/thumbnail", file_uuid, tid),
        })
    } else { None };

    let rep_b = if let Some((tid,)) = trace_b {
        select_rep_face(state.db.pool(), &file_uuid, tid, |e| {
            (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": e.to_string()})))
        }).await.ok().map(|sel| CoOccurRepFace {
            frame_number: sel.frame,
            bbox: RepFaceBbox { x: sel.x, y: sel.y, width: sel.w, height: sel.h },
            confidence: sel.conf,
            thumbnail_url: format!("/api/v1/file/{}/trace/{}/thumbnail", file_uuid, tid),
        })
    } else { None };

    // Total co-occurrence frames (from TKG if available, otherwise from face_detections)
    let total_cooccurrence_frames: i64 = sqlx::query_scalar(
        &format!(
            "SELECT COUNT(DISTINCT fd.frame_number)::bigint FROM {} fd \
             WHERE fd.file_uuid = $1 AND fd.identity_id = $2 \
             AND fd.frame_number IN ( \
               SELECT frame_number FROM {} \
               WHERE file_uuid = $1 AND identity_id = $3 \
             )",
            fd_table, fd_table
        )
    )
    .bind(&file_uuid).bind(id_a.0).bind(id_b.0)
    .fetch_one(state.db.pool()).await
    .unwrap_or(0);

    Ok(Json(CoOccurResponse {
        success: true,
        file_uuid,
        identity_a: CoOccurIdentity {
            identity_uuid: identity_uuid_a,
            name: id_a.1,
            trace_id: trace_a.map(|t| t.0).unwrap_or(0),
        },
        identity_b: CoOccurIdentity {
            identity_uuid: identity_uuid_b,
            name: id_b.1,
            trace_id: trace_b.map(|t| t.0).unwrap_or(0),
        },
        first_cooccurrence: CoOccurrence {
            frame_number: first_frame,
            timestamp_secs: first_frame as f64 / fps,
            total_cooccurrence_frames,
            representative_face_a: rep_a,
            representative_face_b: rep_b,
        },
    }))
}

use crate::core::config::OUTPUT_DIR;

#[derive(Serialize)]
struct TkgRebuildResponse {
    success: bool,
    file_uuid: String,
    result: Option<serde_json::Value>,
    error: Option<String>,
}

async fn rebuild_tkg(
    State(state): State<crate::api::types::AppState>,
    Path(file_uuid): Path<String>,
) -> Json<TkgRebuildResponse> {
    let result = crate::core::processor::tkg::build_tkg(
        &state.db,
        &file_uuid,
        &OUTPUT_DIR,
    )
    .await;

    match result {
        Ok(r) => Json(TkgRebuildResponse {
            success: true,
            file_uuid,
            result: Some(serde_json::json!({
                "face_trace_nodes": r.face_trace_nodes,
                "object_nodes": r.object_nodes,
                "speaker_nodes": r.speaker_nodes,
                "co_occurrence_edges": r.co_occurrence_edges,
                "speaker_face_edges": r.speaker_face_edges,
                "face_face_edges": r.face_face_edges,
            })),
            error: None,
        }),
        Err(e) => Json(TkgRebuildResponse {
            success: false,
            file_uuid,
            result: None,
            error: Some(e.to_string()),
        }),
    }
}

// ── Representative Frame (JSON) ───────────────────────────────────

use crate::core::processor::tkg;

#[derive(Serialize)]
struct RepFrameResponse {
    success: bool,
    file_uuid: String,
    frame_number: i64,
    timestamp_secs: f64,
    face_quality: f64,
    main_identities: Vec<tkg::MainIdentityInfo>,
    traces: Vec<tkg::FrameTraceInfo>,
}

async fn get_representative_frame(
    State(state): State<crate::api::types::AppState>,
    Path(file_uuid): Path<String>,
) -> Result<Json<RepFrameResponse>, (StatusCode, Json<serde_json::Value>)> {
    let result = tkg::query_auto_representative_frame(
        state.db.pool(),
        &file_uuid,
    )
    .await
    .map_err(|e| {
        (StatusCode::NOT_FOUND, Json(serde_json::json!({"error": e.to_string()})))
    })?;

    let fps = query_fps(state.db.pool(), &file_uuid).await;

    Ok(Json(RepFrameResponse {
        success: true,
        file_uuid,
        frame_number: result.frame_number,
        timestamp_secs: result.frame_number as f64 / fps,
        face_quality: result.face_quality,
        main_identities: result.main_identities,
        traces: result.traces,
    }))
}

async fn query_fps(pool: &sqlx::PgPool, file_uuid: &str) -> f64 {
    use crate::core::db::schema;
    let video_table = schema::table_name("videos");
    sqlx::query_scalar(&format!(
        "SELECT COALESCE(fps, 25.0) FROM {} WHERE file_uuid = $1",
        video_table
    ))
    .bind(file_uuid)
    .fetch_optional(pool)
    .await
    .ok()
    .flatten()
    .unwrap_or(25.0)
}