use crate::db::pool::{Connection, params};
use serde::Serialize;

#[derive(Debug, Clone, Serialize)]
pub struct SavedSearch {
    pub id: i64,
    pub name: String,
    pub query_string: String,
    pub created_at: String,
    pub updated_at: String,
}

fn row_to_saved(row: &crate::db::pool::Row<'_>) -> Result<SavedSearch, crate::db::pool::DbError> {
    Ok(SavedSearch {
        id: row.get(0)?,
        name: row.get(1)?,
        query_string: row.get(2)?,
        created_at: row.get(3)?,
        updated_at: row.get(4)?,
    })
}

pub fn list(conn: &Connection) -> Result<Vec<SavedSearch>, String> {
    let mut stmt = conn
        .prepare(crate::dbq!(db_saved_searches::Q_001))
        .map_err(|e| format!("Failed to prepare saved searches: {e}"))?;
    let rows = stmt
        .query_map([], row_to_saved)
        .map_err(|e| format!("Failed to query saved searches: {e}"))?;
    rows.map(|row| row.map_err(|e| format!("Failed to read saved search: {e}")))
        .collect()
}

pub fn create(conn: &Connection, name: &str, query_string: &str) -> Result<SavedSearch, String> {
    let name = name.trim();
    let query_string = query_string.trim();
    if name.is_empty() || query_string.is_empty() {
        return Err("Saved search name and query are required".to_string());
    }
    let id = conn
        .insert_id(
            crate::dbq!(db_saved_searches::Q_002),
            params![name, query_string],
        )
        .map_err(|e| format!("Failed to save search: {e}"))?;
    get(conn, id)?.ok_or_else(|| "Failed to read saved search".to_string())
}

pub fn update(
    conn: &Connection,
    id: i64,
    name: &str,
    query_string: &str,
) -> Result<Option<SavedSearch>, String> {
    let name = name.trim();
    let query_string = query_string.trim();
    if name.is_empty() || query_string.is_empty() {
        return Err("Saved search name and query are required".to_string());
    }
    let changed = conn
        .execute(
            crate::dbq!(db_saved_searches::Q_003),
            params![name, query_string, id],
        )
        .map_err(|e| format!("Failed to update saved search: {e}"))?;
    if changed == 0 {
        return Ok(None);
    }
    get(conn, id)
}

pub fn get(conn: &Connection, id: i64) -> Result<Option<SavedSearch>, String> {
    match conn.query_row(
        crate::dbq!(db_saved_searches::Q_004),
        params![id],
        row_to_saved,
    ) {
        Ok(value) => Ok(Some(value)),
        Err(crate::db::pool::DbError::QueryReturnedNoRows) => Ok(None),
        Err(e) => Err(format!("Failed to get saved search: {e}")),
    }
}

pub fn delete(conn: &Connection, id: i64) -> Result<bool, String> {
    Ok(conn
        .execute(crate::dbq!(db_saved_searches::Q_005), params![id])
        .map_err(|e| format!("Failed to delete saved search: {e}"))?
        > 0)
}