#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

mod proxy;
mod db;

use serde::Serialize;
use base64::{Engine as _, engine::general_purpose::STANDARD};
use std::sync::Mutex;
use std::num::NonZeroUsize;
use lru::LruCache;
use image::GenericImageView;

static THUMB_CACHE: Mutex<Option<LruCache<String, String>>> = Mutex::new(None);
static PROFILE_CACHE: Mutex<Option<LruCache<String, String>>> = Mutex::new(None);

fn get_client() -> reqwest::Client {
    reqwest::Client::builder()
        .connect_timeout(std::time::Duration::from_secs(10))
        .timeout(std::time::Duration::from_secs(60))
        .pool_max_idle_per_host(10)
        .build()
        .expect("Failed to build HTTP client")
}

#[derive(Serialize)]
struct SearchResult {
    file_uuid: String,
    start_time: f64,
    end_time: f64,
    start_frame: i64,
    end_frame: i64,
    summary: String,
    similarity: f64,
    file_name: Option<String>,
}

#[derive(Serialize)]
struct FileInfo {
    file_uuid: String,
    file_name: String,
    file_path: String,
    file_size: i64,
    modified_time: String,
    #[serde(rename = "isRegistered")]
    is_registered: bool,
    status: String,
    registration_time: Option<String>,
    #[serde(rename = "ingested")]
    ingested: bool,
}

#[derive(Serialize)]
struct PersonInfo {
    identity_uuid: String,
    name: String,
    starred: bool,
    status: String,
    metadata: serde_json::Value,
}

#[derive(Serialize)]
struct FaceInfo {
    id: i64,
    file_uuid: String,
    frame_number: i64,
    timestamp_secs: f64,
    face_id: Option<String>,
    confidence: f64,
    bbox: Option<FaceBBox>,
}

#[derive(Serialize)]
struct TraceInfo {
    trace_id: i32,
    file_uuid: String,
    frame_count: i64,
    first_frame: i64,
    last_frame: i64,
    first_sec: f64,
    last_sec: f64,
    avg_confidence: f64,
    face_id: Option<String>,
}

#[derive(Serialize)]
struct FileDetail {
    file_uuid: String,
    file_name: String,
    fps: f64,
    duration: f64,
}

#[derive(Serialize)]
struct FaceCandidate {
    id: i64,
    face_id: Option<String>,
    file_uuid: String,
    frame_number: i64,
    confidence: f64,
    bbox: Option<FaceBBox>,
}

#[derive(Serialize)]
struct FaceBBox {
    x: f64,
    y: f64,
    width: f64,
    height: f64,
}

#[derive(Serialize)]
struct SearchIdentityResult {
    identity_id: i64,
    name: String,
    source: String,
    tmdb_id: Option<i64>,
    file_uuid: Option<String>,
    trace_id: Option<i64>,
    start_frame: Option<i64>,
    end_frame: Option<i64>,
    start_time: f64,
    end_time: f64,
    text_content: Option<String>,
}

const CORE_API: &str = "http://localhost:3002";
const API_KEY: &str = "muser_68600856036340bcafc01930eb4bd839_1774418104_97221b69";

#[tauri::command(rename_all = "camelCase")]
async fn search_llm_smart(query: String, limit: usize) -> Result<Vec<SearchResult>, String> {
    let client = get_client();
    let url = format!("{}/api/v1/search/llm-smart?api_key={}", CORE_API, API_KEY);
    
    let response = client
        .post(&url)
        .json(&serde_json::json!({"query": query, "limit": limit}))
        .send()
        .await
        .map_err(|e| format!("Request failed: {}", e))?;
    
    let json: serde_json::Value = response
        .json()
        .await
        .map_err(|e| format!("Parse failed: {}", e))?;
    
    let results: Vec<SearchResult> = json["results"]
        .as_array()
        .unwrap_or(&vec![])
        .iter()
        .filter_map(|r| {
            Some(SearchResult {
                file_uuid: r["file_uuid"].as_str()?.to_string(),
                start_time: r["start_time"].as_f64()?,
                end_time: r["end_time"].as_f64()?,
                start_frame: r["start_frame"].as_i64().unwrap_or(0),
                end_frame: r["end_frame"].as_i64().unwrap_or(0),
                summary: r["summary"].as_str()?.to_string(),
                similarity: r["similarity"].as_f64().unwrap_or(0.0),
                file_name: r["file_name"].as_str().map(|s| s.to_string()),
            })
        })
        .collect();
    
    Ok(results)
}

#[derive(serde::Deserialize)]
struct GetFilesArgs {
    #[serde(rename = "pageSize")]
    page_size: usize,
}

#[tauri::command(rename_all = "camelCase")]
async fn search_agents(query: String, conversation_id: Option<String>) -> Result<serde_json::Value, String> {
    let client = reqwest::Client::builder()
        .timeout(std::time::Duration::from_secs(120))
        .build()
        .map_err(|e| format!("Client build failed: {}", e))?;
    let url = format!("{}/api/v1/agents/search?api_key={}", CORE_API, API_KEY);
    let mut body = serde_json::json!({"query": query});
    if let Some(cid) = conversation_id {
        body["conversation_id"] = serde_json::Value::String(cid);
    }
    let response = client
        .post(&url)
        .json(&body)
        .send()
        .await
        .map_err(|e| format!("Agent search request failed: {}", e))?;
    let json: serde_json::Value = response
        .json()
        .await
        .map_err(|e| format!("Agent search parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn get_files(args: GetFilesArgs) -> Result<Vec<FileInfo>, String> {
    let page_size = args.page_size;
    let client = get_client();
    let url = format!("{}/api/v1/files/scan?api_key={}&page_size={}", CORE_API, API_KEY, page_size);
    
    let response = client.get(&url).send().await.map_err(|e| format!("Request failed: {}", e))?;
    let json: serde_json::Value = response.json().await.map_err(|e| format!("Parse failed: {}", e))?;
    
    let files: Vec<FileInfo> = json["files"]
        .as_array()
        .unwrap_or(&vec![])
        .iter()
        .filter_map(|f| {
            let is_reg = f["is_registered"].as_bool().unwrap_or(false);
            let file_uuid = f["file_uuid"].as_str()
                .unwrap_or_else(|| f["file_path"].as_str().unwrap_or("")).to_string();
            let status = f["status"].as_str().unwrap_or("").to_string();
            Some(FileInfo {
                file_uuid,
                file_name: f["file_name"].as_str()?.to_string(),
                file_path: f["file_path"].as_str().unwrap_or("").to_string(),
                file_size: f["file_size"].as_i64().unwrap_or(0),
                modified_time: f["modified_time"].as_str().unwrap_or("").to_string(),
                is_registered: is_reg,
                registration_time: f["registration_time"].as_str().map(|s| s.to_string()),
                ingested: status == "completed",
                status,
            })
        })
        .collect();
    
    Ok(files)
}

#[derive(Serialize)]
struct RegisterResult {
    success: bool,
    file_uuid: String,
    file_name: String,
    message: String,
}

#[tauri::command(rename_all = "camelCase")]
async fn register_file(file_path: String) -> Result<RegisterResult, String> {
    let client = reqwest::Client::builder()
        .timeout(std::time::Duration::from_secs(120))
        .build()
        .map_err(|e| format!("Client build failed: {}", e))?;
    let url = format!("{}/api/v1/files/register?api_key={}", CORE_API, API_KEY);
    let response = client.post(&url)
        .json(&serde_json::json!({"file_path": file_path}))
        .send()
        .await
        .map_err(|e| format!("Register request failed: {}", e))?;
    let json: serde_json::Value = response.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(RegisterResult {
        success: json["success"].as_bool().unwrap_or(false),
        file_uuid: json["file_uuid"].as_str().unwrap_or("").to_string(),
        file_name: json["file_name"].as_str().unwrap_or("").to_string(),
        message: json["message"].as_str().unwrap_or("").to_string(),
    })
}

#[derive(Serialize)]
struct ProcessResult {
    success: bool,
    file_uuid: String,
    message: String,
}

#[tauri::command(rename_all = "camelCase")]
async fn process_file(file_uuid: String, processors: Vec<String>) -> Result<ProcessResult, String> {
    let url = format!("{}/api/v1/file/{}/process?api_key={}", CORE_API, file_uuid, API_KEY);
    let response = get_client().post(&url)
        .json(&serde_json::json!({"processors": processors}))
        .send()
        .await
        .map_err(|e| format!("Process request failed: {}", e))?;
    let json: serde_json::Value = response.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(ProcessResult {
        success: json["success"].as_bool().unwrap_or(false),
        file_uuid: json["file_uuid"].as_str().unwrap_or("").to_string(),
        message: json["message"].as_str().unwrap_or("").to_string(),
    })
}

#[derive(Serialize)]
struct IngestResult {
    success: bool,
    file_uuid: String,
    message: String,
}

#[tauri::command(rename_all = "camelCase")]
async fn ingest_file(file_uuid: String) -> Result<IngestResult, String> {
    let client = get_client();
    let url = format!("{}/api/v1/file/{}/checkin?api_key={}", CORE_API, file_uuid, API_KEY);
    let resp = client.post(&url).send().await
        .map_err(|e| format!("Ingest (checkin) request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Ingest (checkin) parse failed: {}", e))?;
    Ok(IngestResult {
        success: json["success"].as_bool().unwrap_or(false),
        file_uuid,
        message: json["message"].as_str().unwrap_or("Checkin complete").to_string(),
    })
}

#[tauri::command(rename_all = "camelCase")]
async fn checkout_file(file_uuid: String) -> Result<IngestResult, String> {
    let client = get_client();
    let url = format!("{}/api/v1/file/{}/checkout?api_key={}", CORE_API, file_uuid, API_KEY);
    let resp = client.post(&url).send().await
        .map_err(|e| format!("Checkout request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Checkout parse failed: {}", e))?;
    Ok(IngestResult {
        success: json["success"].as_bool().unwrap_or(false),
        file_uuid,
        message: json["message"].as_str().unwrap_or("Checkout complete").to_string(),
    })
}

#[derive(Serialize)]
struct UnregisterResult {
    success: bool,
    file_uuid: String,
    message: String,
}

#[tauri::command(rename_all = "camelCase")]
async fn unregister_file(file_uuid: String, delete_output_files: Option<bool>) -> Result<UnregisterResult, String> {
    let url = format!("{}/api/v1/unregister?api_key={}", CORE_API, API_KEY);
    let mut body = serde_json::json!({"file_uuid": file_uuid});
    if let Some(dof) = delete_output_files {
        body["delete_output_files"] = serde_json::Value::Bool(dof);
    }
    let response = get_client().post(&url)
        .json(&body)
        .send()
        .await
        .map_err(|e| format!("Unregister request failed: {}", e))?;
    let json: serde_json::Value = response.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(UnregisterResult {
        success: json["success"].as_bool().unwrap_or(false),
        file_uuid: json["file_uuid"].as_str().unwrap_or("").to_string(),
        message: json["message"].as_str().unwrap_or("").to_string(),
    })
}

#[tauri::command(rename_all = "camelCase")]
async fn get_people(_page: usize, _per_page: usize) -> Result<Vec<PersonInfo>, String> {
    eprintln!("[get_people] called");
    let mut people = Vec::new();
    for page in 1u32..=2 {
        let url = format!("{}/api/v1/identities?api_key={}&page={}&per_page=100", CORE_API, API_KEY, page);
        let resp = match get_client().get(&url).send().await {
            Ok(r) => r,
            Err(e) => {
                eprintln!("[get_people] page {} request failed: {} — continuing", page, e);
                continue;
            }
        };
        let json: serde_json::Value = match resp.json().await {
            Ok(v) => v,
            Err(e) => {
                eprintln!("[get_people] page {} parse error: {} — continuing", page, e);
                continue;
            }
        };
        let identities = match json["identities"].as_array() {
            Some(arr) => arr,
            None => {
                eprintln!("[get_people] page {} has no identities array — stopping", page);
                break;
            }
        };
        if identities.is_empty() {
            eprintln!("[get_people] page {} empty — stopping", page);
            break;
        }
        for i in identities {
            let uuid = match i["identity_uuid"].as_str() {
                Some(u) => u.to_string(),
                None => continue,
            };
            let name = match i["name"].as_str() {
                Some(n) => n.to_string(),
                None => continue,
            };
            people.push(PersonInfo {
                identity_uuid: uuid,
                name,
                starred: i["metadata"]["starred"].as_bool().unwrap_or(false),
                status: i["metadata"]["status"].as_str().unwrap_or("pending").to_string(),
                metadata: i["metadata"].clone(),
            });
        }
    }
    eprintln!("[get_people] returning {} people", people.len());
    Ok(people)
}

#[tauri::command(rename_all = "camelCase")]
async fn get_faces(uuid: String, per_page: usize) -> Result<Vec<FaceInfo>, String> {
    let url = format!("{}/api/v1/identity/{}/faces?api_key={}&page_size={}", CORE_API, uuid, API_KEY, per_page);
    let t = std::time::Instant::now();
    eprintln!("[get_faces] --> {}", uuid);
    
    let response = match get_client().get(&url).send().await {
        Ok(r) => r,
        Err(e) => {
            eprintln!("[get_faces] <-- {} ERROR {} {:?}", uuid, e, t.elapsed());
            return Ok(vec![]);
        }
    };
    let json: serde_json::Value = match response.json().await {
        Ok(v) => v,
        Err(e) => {
            eprintln!("[get_faces] <-- {} PARSE_ERR {} {:?}", uuid, e, t.elapsed());
            return Ok(vec![]);
        }
    };
    
    let faces: Vec<FaceInfo> = json["data"]
        .as_array()
        .unwrap_or(&vec![])
        .iter()
        .filter_map(|f| {
            Some(FaceInfo {
                id: f["id"].as_i64().unwrap_or(0),
                file_uuid: f["file_uuid"].as_str()?.to_string(),
                frame_number: f["frame_number"].as_i64().unwrap_or(0),
                timestamp_secs: f["timestamp_secs"].as_f64().unwrap_or(0.0),
                face_id: f["face_id"].as_str().map(|s| s.to_string()),
                confidence: f["confidence"].as_f64().unwrap_or(0.0),
                bbox: f["bbox"].as_object().map(|o| FaceBBox {
                    x: o["x"].as_f64().unwrap_or(0.0),
                    y: o["y"].as_f64().unwrap_or(0.0),
                    width: o["width"].as_f64().unwrap_or(0.0),
                    height: o["height"].as_f64().unwrap_or(0.0),
                }),
            })
        })
        .collect();
    
    eprintln!("[get_faces] <-- {} {} faces {:?}", uuid, faces.len(), t.elapsed());
    Ok(faces)
}

#[derive(Serialize)]
struct TracesResponse {
    total: i64,
    traces: Vec<TraceInfo>,
}

#[tauri::command(rename_all = "camelCase")]
async fn get_traces(uuid: String, per_page: usize, page: Option<u32>) -> Result<TracesResponse, String> {
    let page_size = per_page.min(100);
    let page_num = page.unwrap_or(1);
    let t = std::time::Instant::now();
    eprintln!("[get_traces] --> {} page={} page_size={}", uuid, page_num, page_size);

    let url = format!("{}/api/v1/identity/{}/traces?api_key={}&page_size={}&page={}", CORE_API, uuid, API_KEY, page_size, page_num);

    let resp = get_client().get(&url).send().await
        .map_err(|e| format!("Traces request failed: {}", e))?;

    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Traces parse failed: {}", e))?;

    let total = json["total"].as_i64().unwrap_or(0);

    let traces: Vec<TraceInfo> = json["traces"]
        .as_array()
        .unwrap_or(&vec![])
        .iter()
        .filter_map(|t| {
            Some(TraceInfo {
                trace_id: t["trace_id"].as_i64().unwrap_or(0) as i32,
                file_uuid: t["file_uuid"].as_str()?.to_string(),
                frame_count: t["frame_count"].as_i64().unwrap_or(0),
                first_frame: t["first_frame"].as_i64().unwrap_or(0),
                last_frame: t["last_frame"].as_i64().unwrap_or(0),
                first_sec: t["first_sec"].as_f64().unwrap_or(0.0),
                last_sec: t["last_sec"].as_f64().unwrap_or(0.0),
                avg_confidence: t["avg_confidence"].as_f64().unwrap_or(0.0),
                face_id: t["face_id"].as_str().map(String::from),
            })
        })
        .collect();

    eprintln!("[get_traces] <-- {} total={} {} traces {:?}", uuid, total, traces.len(), t.elapsed());
    Ok(TracesResponse { total, traces })
}

#[tauri::command(rename_all = "camelCase")]
async fn get_file_info(uuid: String) -> Result<FileDetail, String> {
    let url = format!("{}/api/v1/file/{}?api_key={}", CORE_API, uuid, API_KEY);
    let resp = get_client().get(&url).send().await
        .map_err(|e| format!("File info request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("File info parse failed: {}", e))?;
    Ok(FileDetail {
        file_uuid: json["file_uuid"].as_str().unwrap_or("").to_string(),
        file_name: json["file_name"].as_str().unwrap_or("").to_string(),
        fps: json["fps"].as_f64().unwrap_or(24.0),
        duration: json["duration"].as_f64().unwrap_or(0.0),
    })
}

#[tauri::command(rename_all = "camelCase")]
async fn get_thumbnail(uuid: String, frame: u32) -> Result<String, String> {
    let key = format!("{}:{}", uuid, frame);
    {
        let mut cache = THUMB_CACHE.lock().unwrap();
        if let Some(cache) = cache.as_mut() {
            if let Some(cached) = cache.get(&key) {
                return Ok(cached.clone());
            }
        }
    }
    let url = format!("{}/api/v1/file/{}/thumbnail?api_key={}&frame={}", CORE_API, uuid, API_KEY, frame);
    let bytes = get_client().get(&url).send().await
        .map_err(|e| format!("Thumbnail request failed: {}", e))?
        .bytes().await
        .map_err(|e| format!("Thumbnail read failed: {}", e))?;
    let result = format!("data:image/jpeg;base64,{}", STANDARD.encode(&bytes));
    {
        let mut cache = THUMB_CACHE.lock().unwrap();
        let cache = cache.get_or_insert_with(|| LruCache::new(NonZeroUsize::new(500).unwrap()));
        cache.put(key, result.clone());
    }
    Ok(result)
}

#[tauri::command(rename_all = "camelCase")]
async fn get_face_thumbnail(uuid: String, frame: u32, bbox_x: Option<f64>, bbox_y: Option<f64>, bbox_w: Option<f64>, bbox_h: Option<f64>) -> Result<String, String> {
    let key = format!("face:{}:{}:{:?}:{:?}:{:?}:{:?}", uuid, frame, bbox_x, bbox_y, bbox_w, bbox_h);
    {
        let mut cache = THUMB_CACHE.lock().unwrap();
        if let Some(cache) = cache.as_mut() {
            if let Some(cached) = cache.get(&key) {
                return Ok(cached.clone());
            }
        }
    }
    let url = format!("{}/api/v1/file/{}/thumbnail?api_key={}&frame={}", CORE_API, uuid, API_KEY, frame);
    let bytes = get_client().get(&url).send().await
        .map_err(|e| format!("Thumbnail request failed: {}", e))?
        .bytes().await
        .map_err(|e| format!("Thumbnail read failed: {}", e))?;

    let result = if let (Some(bx), Some(by), Some(bw), Some(bh)) = (bbox_x, bbox_y, bbox_w, bbox_h) {
        let img = image::load_from_memory(&bytes).map_err(|e| format!("Image decode failed: {}", e))?;
        let (w, h) = img.dimensions();
        let (px, py, pw, ph) = if bx <= 1.0 && by <= 1.0 && bw <= 1.0 && bh <= 1.0 {
            ((bx * w as f64) as u32, (by * h as f64) as u32, (bw * w as f64) as u32, (bh * h as f64) as u32)
        } else {
            (bx as u32, by as u32, bw as u32, bh as u32)
        };
        let cx = px.min(w.saturating_sub(1));
        let cy = py.min(h.saturating_sub(1));
        let cw = pw.min(w.saturating_sub(cx)).max(1);
        let ch = ph.min(h.saturating_sub(cy)).max(1);
        let cropped = img.crop_imm(cx, cy, cw, ch);
        let mut buf = std::io::Cursor::new(Vec::new());
        cropped.write_to(&mut buf, image::ImageFormat::Jpeg).map_err(|e| format!("Encode failed: {}", e))?;
        format!("data:image/jpeg;base64,{}", STANDARD.encode(buf.into_inner()))
    } else {
        format!("data:image/jpeg;base64,{}", STANDARD.encode(&bytes))
    };

    {
        let mut cache = THUMB_CACHE.lock().unwrap();
        let cache = cache.get_or_insert_with(|| LruCache::new(NonZeroUsize::new(500).unwrap()));
        cache.put(key, result.clone());
    }
    Ok(result)
}

const PROFILE_DIRS: &[&str] = &[
    "/Users/accusys/momentry/output/identities",
    "/Users/accusys/momentry/output_dev/identities",
    "/Volumes/external/momentry/output/identities",
    "/Volumes/external/momentry/output_dev/identities",
];

#[tauri::command(rename_all = "camelCase")]
async fn get_identity_profile(uuid: String) -> Result<String, String> {
    let uuid_display = uuid.clone();
    let no_dash = uuid.replace('-', "");
    {
        let mut cache = PROFILE_CACHE.lock().unwrap();
        if let Some(cache) = cache.as_mut() {
            if let Some(cached) = cache.get(&uuid_display) {
                eprintln!("[get_identity_profile] <-- {} (cached)", uuid_display);
                return Ok(cached.clone());
            }
        }
    }
    let t = std::time::Instant::now();
    let result = (|| -> Option<String> {
        for dir in PROFILE_DIRS {
            for candidate in [&no_dash, &uuid_display] {
                let path = format!("{}/{}/profile.jpg", dir, candidate);
                if std::path::Path::new(&path).exists() {
                    let bytes = std::fs::read(&path).ok()?;
                    return Some(format!("data:image/jpeg;base64,{}", STANDARD.encode(&bytes)));
                }
            }
        }
        None
    })();
    match result {
        Some(data) => {
            let mut cache = PROFILE_CACHE.lock().unwrap();
            let cache = cache.get_or_insert_with(|| LruCache::new(NonZeroUsize::new(500).unwrap()));
            cache.put(uuid_display.clone(), data.clone());
            eprintln!("[get_identity_profile] <-- {} {} {}ms", uuid_display, "FOUND", t.elapsed().as_millis());
            Ok(data)
        }
        None => {
            eprintln!("[get_identity_profile] <-- {} {} {}ms", uuid_display, "404", t.elapsed().as_millis());
            Err("Profile image not found".to_string())
        }
    }
}

#[tauri::command(rename_all = "camelCase")]
async fn update_identity_name(uuid: String, name: String) -> Result<(), String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}?api_key={}", CORE_API, uuid, API_KEY);
    let resp = client.patch(&url)
        .json(&serde_json::json!({"name": name}))
        .send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    if !resp.status().is_success() {
        return Err(format!("Update failed: {}", resp.status()));
    }
    Ok(())
}

#[tauri::command(rename_all = "camelCase")]
async fn update_identity_status(uuid: String, status: String) -> Result<(), String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}?api_key={}", CORE_API, uuid, API_KEY);
    // GET current identity to merge metadata (preserve starred, role, notes, etc.)
    let get_resp = client.get(&url).send().await
        .map_err(|e| format!("GET failed: {}", e))?;
    let json: serde_json::Value = get_resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    let mut metadata = json["metadata"].as_object()
        .cloned()
        .unwrap_or_default();
    metadata.insert("status".to_string(), serde_json::Value::String(status));
    let resp = client.patch(&url)
        .json(&serde_json::json!({"metadata": metadata}))
        .send().await
        .map_err(|e| format!("PATCH failed: {}", e))?;
    if !resp.status().is_success() {
        return Err(format!("Update failed: {}", resp.status()));
    }
    Ok(())
}

#[tauri::command(rename_all = "camelCase")]
async fn update_identity_starred(uuid: String, starred: bool) -> Result<(), String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}?api_key={}", CORE_API, uuid, API_KEY);
    let get_resp = client.get(&url).send().await
        .map_err(|e| format!("GET failed: {}", e))?;
    let json: serde_json::Value = get_resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    let mut metadata = json["metadata"].as_object()
        .cloned()
        .unwrap_or_default();
    metadata.insert("starred".to_string(), serde_json::Value::Bool(starred));
    let resp = client.patch(&url)
        .json(&serde_json::json!({"metadata": metadata}))
        .send().await
        .map_err(|e| format!("PATCH failed: {}", e))?;
    if !resp.status().is_success() {
        return Err(format!("Update failed: {}", resp.status()));
    }
    Ok(())
}

#[tauri::command(rename_all = "camelCase")]
async fn update_identity(uuid: String, name: Option<String>, metadata_json: String) -> Result<serde_json::Value, String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}?api_key={}", CORE_API, uuid, API_KEY);
    let mut body = serde_json::json!({});
    if let Some(n) = &name {
        body["name"] = serde_json::Value::String(n.clone());
    }
    if !metadata_json.is_empty() {
        let meta: serde_json::Value = serde_json::from_str(&metadata_json).map_err(|e| format!("Invalid metadata JSON: {}", e))?;
        body["metadata"] = meta;
    }
    let resp = client.patch(&url)
        .json(&body)
        .send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await.map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn upload_profile_image(uuid: String, file_path: String) -> Result<(), String> {
    let file_bytes = std::fs::read(&file_path).map_err(|e| format!("Failed to read file: {}", e))?;
    let file_name = std::path::Path::new(&file_path)
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("profile.jpg")
        .to_string();
    let part = reqwest::multipart::Part::bytes(file_bytes)
        .file_name(file_name)
        .mime_str("image/jpeg")
        .unwrap_or_else(|_| reqwest::multipart::Part::bytes(std::fs::read(&file_path).unwrap_or_default()).file_name("profile.jpg"));
    let form = reqwest::multipart::Form::new()
        .part("image", part);
    let url = format!("{}/api/v1/identity/{}/profile-image?api_key={}", CORE_API, uuid, API_KEY);
    let resp = get_client().post(&url)
        .multipart(form)
        .send().await
        .map_err(|e| format!("Upload failed: {}", e))?;
    if !resp.status().is_success() {
        let status = resp.status();
        let body = resp.text().await.unwrap_or_default();
        return Err(format!("Upload failed: {} {}", status, body));
    }
    let mut cache = PROFILE_CACHE.lock().unwrap();
    if let Some(c) = cache.as_mut() {
        c.pop(&uuid);
    }
    Ok(())
}

#[tauri::command(rename_all = "camelCase")]
async fn delete_identity(uuid: String) -> Result<(), String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}?api_key={}", CORE_API, uuid, API_KEY);
    let resp = client.delete(&url)
        .send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    if !resp.status().is_success() && resp.status() != 204 {
        return Err(format!("Delete failed: {}", resp.status()));
    }
    Ok(())
}

#[derive(Serialize)]
struct CreateIdentityFromFaceResult {
    success: bool,
    identity_uuid: String,
    name: String,
}

#[tauri::command(rename_all = "camelCase")]
async fn create_identity_from_face(name: String, _face_id: Option<String>, _face_row_id: Option<i64>, file_uuid: String) -> Result<CreateIdentityFromFaceResult, String> {
    let client = get_client();
    
    // Use POST /api/v1/file/:file_uuid/pending-person to create pending identity
    let url = format!("{}/api/v1/file/{}/pending-person?api_key={}", CORE_API, file_uuid, API_KEY);
    let body = serde_json::json!({
        "name": name
    });
    
    let resp = client.post(&url)
        .json(&body)
        .send().await
        .map_err(|e| format!("Create pending person request failed: {}", e))?;
    
    let status = resp.status();
    let resp_json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse response failed: {}", e))?;
    
    eprintln!("[create_identity_from_face] status={} resp={}", status, resp_json);
    
    if !status.is_success() {
        return Err(format!("Create pending person failed: {} - {}", status, resp_json["error"].as_str().unwrap_or("unknown error")));
    }
    
    // identity_uuid is inside data object
    let data_obj = resp_json.get("data").unwrap_or(&resp_json);
    let new_uuid = data_obj.get("identity_uuid")
        .and_then(|v| v.as_str())
        .or_else(|| resp_json.get("identity_uuid").and_then(|v| v.as_str()))
        .or_else(|| resp_json.get("uuid").and_then(|v| v.as_str()))
        .unwrap_or("");
    
    if new_uuid.is_empty() {
        return Err("Create pending person failed: no uuid returned".to_string());
    }
    
    Ok(CreateIdentityFromFaceResult {
        success: true,
        identity_uuid: new_uuid.to_string(),
        name,
    })
}

#[tauri::command(rename_all = "camelCase")]
async fn search_identities(query: String, limit: usize) -> Result<Vec<SearchIdentityResult>, String> {
    let url = format!("{}/api/v1/identities/search?api_key={}&q={}", CORE_API, API_KEY, query);
    let resp = get_client().get(&url).send().await.map_err(|e| format!("Request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await.map_err(|e| format!("Parse failed: {}", e))?;
    let results: Vec<SearchIdentityResult> = json["results"]
        .as_array()
        .unwrap_or(&vec![])
        .iter()
        .take(limit)
        .filter_map(|r| {
            Some(SearchIdentityResult {
                identity_id: r["identity_id"].as_i64().unwrap_or(0),
                name: r["name"].as_str()?.to_string(),
                source: r["source"].as_str().unwrap_or("").to_string(),
                tmdb_id: r["tmdb_id"].as_i64(),
                file_uuid: r["file_uuid"].as_str().map(|s| s.to_string()),
                trace_id: r["trace_id"].as_i64(),
                start_frame: r["start_frame"].as_i64(),
                end_frame: r["end_frame"].as_i64(),
                start_time: r["start_time"].as_f64().unwrap_or(0.0),
                end_time: r["end_time"].as_f64().unwrap_or(0.0),
                text_content: r["text_content"].as_str().map(|s| s.to_string()),
            })
        })
        .collect();
    Ok(results)
}

#[tauri::command(rename_all = "camelCase")]
async fn get_face_candidates(page: usize, per_page: usize) -> Result<Vec<FaceCandidate>, String> {
    let client = get_client();
    let url = format!("{}/api/v1/faces/candidates?api_key={}&page={}&page_size={}", CORE_API, API_KEY, page, per_page);
    let resp = client.get(&url).send().await.map_err(|e| format!("Request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await.map_err(|e| format!("Parse failed: {}", e))?;
    let candidates: Vec<FaceCandidate> = json["candidates"]
        .as_array()
        .unwrap_or(&vec![])
        .iter()
        .filter_map(|c| {
            Some(FaceCandidate {
                id: c["id"].as_i64().unwrap_or(0),
                face_id: c["face_id"].as_str().map(|s| s.to_string()),
                file_uuid: c["file_uuid"].as_str()?.to_string(),
                frame_number: c["frame_number"].as_i64().unwrap_or(0),
                confidence: c["confidence"].as_f64().unwrap_or(0.0),
                bbox: c["bbox"].as_object().map(|o| FaceBBox {
                    x: o["x"].as_f64().unwrap_or(0.0),
                    y: o["y"].as_f64().unwrap_or(0.0),
                    width: o["width"].as_f64().unwrap_or(0.0),
                    height: o["height"].as_f64().unwrap_or(0.0),
                }),
            })
        })
        .collect();
    Ok(candidates)
}

#[tauri::command(rename_all = "camelCase")]
async fn merge_identities(uuid: String, into_uuid: String) -> Result<(), String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}/mergeinto?api_key={}", CORE_API, uuid, API_KEY);
    let resp = client.post(&url)
        .json(&serde_json::json!({"into_uuid": into_uuid}))
        .send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    if !resp.status().is_success() {
        return Err(format!("Merge failed: {}", resp.status()));
    }
    Ok(())
}

#[tauri::command(rename_all = "camelCase")]
async fn bind_face(uuid: String, face_id: Option<String>, face_row_id: Option<i64>, file_uuid: String) -> Result<(), String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}/bind?api_key={}", CORE_API, uuid, API_KEY);
    let mut body = serde_json::json!({"file_uuid": file_uuid});
    if let Some(fid) = &face_id {
        body["face_id"] = serde_json::json!(fid);
    } else if let Some(rid) = face_row_id {
        body["id"] = serde_json::json!(rid);
    } else {
        return Err("Either face_id or face_row_id is required".to_string());
    }
    let resp = client.post(&url)
        .json(&body)
        .send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    if !resp.status().is_success() {
        return Err(format!("Bind failed: {}", resp.status()));
    }
    Ok(())
}

#[tauri::command(rename_all = "camelCase")]
async fn unbind_face(uuid: String, face_id: Option<String>, face_row_id: Option<i64>, file_uuid: String, _frame_number: Option<i64>) -> Result<(), String> {
    let client = get_client();
    let mut body = serde_json::json!({"file_uuid": file_uuid});
    if let Some(fid) = face_id {
        body["face_id"] = serde_json::json!(fid);
    } else if let Some(rid) = face_row_id {
        body["id"] = serde_json::json!(rid);
    } else {
        return Err("Either face_id or face_row_id is required".to_string());
    }
    let url = format!("{}/api/v1/identity/{}/unbind?api_key={}", CORE_API, uuid, API_KEY);
    eprintln!("[unbind_face] POST {} body={}", url, body);
    let resp = client.post(&url)
        .json(&body)
        .send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    let status = resp.status();
    let resp_text = resp.text().await.unwrap_or_default();
    eprintln!("[unbind_face] status={} body={}", status, resp_text);
    if !status.is_success() {
        return Err(format!("Unbind failed: {} - {}", status, resp_text));
    }
    Ok(())
}

#[tauri::command(rename_all = "camelCase")]
async fn identity_undo(uuid: String, steps: Option<usize>) -> Result<serde_json::Value, String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}/undo?api_key={}", CORE_API, uuid, API_KEY);
    let mut body = serde_json::json!({});
    if let Some(s) = steps {
        body["steps"] = serde_json::Value::Number(s.into());
    }
    let resp = client.post(&url).json(&body).send().await
        .map_err(|e| format!("Undo failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn identity_redo(uuid: String, steps: Option<usize>) -> Result<serde_json::Value, String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}/redo?api_key={}", CORE_API, uuid, API_KEY);
    let mut body = serde_json::json!({});
    if let Some(s) = steps {
        body["steps"] = serde_json::Value::Number(s.into());
    }
    let resp = client.post(&url).json(&body).send().await
        .map_err(|e| format!("Redo failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn identity_history(uuid: String, page: Option<usize>, page_size: Option<usize>) -> Result<serde_json::Value, String> {
    let client = get_client();
    let mut url = format!("{}/api/v1/identity/{}/history?api_key={}", CORE_API, uuid, API_KEY);
    if let Some(p) = page { url = format!("{}&page={}", url, p); }
    if let Some(ps) = page_size { url = format!("{}&page_size={}", url, ps); }
    let resp = client.get(&url).send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn identity_bind_undo(uuid: String, steps: Option<usize>) -> Result<serde_json::Value, String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}/bind/undo?api_key={}", CORE_API, uuid, API_KEY);
    let mut body = serde_json::json!({});
    if let Some(s) = steps {
        body["steps"] = serde_json::Value::Number(s.into());
    }
    let resp = client.post(&url).json(&body).send().await
        .map_err(|e| format!("Bind undo failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn identity_bind_redo(uuid: String, steps: Option<usize>) -> Result<serde_json::Value, String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/{}/bind/redo?api_key={}", CORE_API, uuid, API_KEY);
    let mut body = serde_json::json!({});
    if let Some(s) = steps {
        body["steps"] = serde_json::Value::Number(s.into());
    }
    let resp = client.post(&url).json(&body).send().await
        .map_err(|e| format!("Bind redo failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn identity_bind_history(uuid: String, page: Option<usize>, page_size: Option<usize>) -> Result<serde_json::Value, String> {
    let client = get_client();
    let mut url = format!("{}/api/v1/identity/{}/bind/history?api_key={}", CORE_API, uuid, API_KEY);
    if let Some(p) = page { url = format!("{}&page={}", url, p); }
    if let Some(ps) = page_size { url = format!("{}&page_size={}", url, ps); }
    let resp = client.get(&url).send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn merge_undo(merge_id: String) -> Result<serde_json::Value, String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/merge/{}/undo?api_key={}", CORE_API, merge_id, API_KEY);
    let resp = client.post(&url).send().await
        .map_err(|e| format!("Merge undo failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn merge_redo(merge_id: String) -> Result<serde_json::Value, String> {
    let client = get_client();
    let url = format!("{}/api/v1/identity/merge/{}/redo?api_key={}", CORE_API, merge_id, API_KEY);
    let resp = client.post(&url).send().await
        .map_err(|e| format!("Merge redo failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

#[tauri::command(rename_all = "camelCase")]
async fn merge_history(source_uuid: Option<String>, target_uuid: Option<String>, page: Option<usize>, page_size: Option<usize>) -> Result<serde_json::Value, String> {
    let client = get_client();
    let mut url = format!("{}/api/v1/identity/merge/history?api_key={}", CORE_API, API_KEY);
    if let Some(s) = source_uuid { url = format!("{}&source_uuid={}", url, s); }
    if let Some(t) = target_uuid { url = format!("{}&target_uuid={}", url, t); }
    if let Some(p) = page { url = format!("{}&page={}", url, p); }
    if let Some(ps) = page_size { url = format!("{}&page_size={}", url, ps); }
    let resp = client.get(&url).send().await
        .map_err(|e| format!("Request failed: {}", e))?;
    let json: serde_json::Value = resp.json().await
        .map_err(|e| format!("Parse failed: {}", e))?;
    Ok(json)
}

fn main() {
    std::thread::spawn(|| {
        let rt = tokio::runtime::Runtime::new().unwrap();
        rt.block_on(proxy::start_proxy_server());
    });

    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .setup(|app| {
            use tauri::Manager;
            let _ = app.get_webview_window("main");
            if let Err(e) = db::init_db() {
                eprintln!("Failed to init database: {}", e);
            }
            Ok(())
        })
.invoke_handler(tauri::generate_handler![
            search_llm_smart,
            search_agents,
            get_files,
            register_file,
            process_file,
            ingest_file,
            checkout_file,
            unregister_file,
            get_people,
            get_faces,
            get_traces,
            get_file_info,
            get_thumbnail,
            get_face_thumbnail,
            get_identity_profile,
            update_identity_name,
            update_identity_status,
            update_identity_starred,
            update_identity,
            upload_profile_image,
            delete_identity,
            create_identity_from_face,
            search_identities,
            get_face_candidates,
            merge_identities,
            bind_face,
            unbind_face,
            identity_undo,
            identity_redo,
            identity_history,
            identity_bind_undo,
            identity_bind_redo,
            identity_bind_history,
            merge_undo,
            merge_redo,
            merge_history,
            db::get_search_history,
            db::save_search_history,
            db::rename_search_history,
            db::pin_search_history,
            db::delete_search_history,
            db::get_bookmarks,
            db::save_bookmark,
            db::delete_bookmark
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}