floz-orm 0.1.7

//! INSERT query builder.
//!
//! ```ignore
//! let (sql, params) = InsertQuery::new("users")
//!     .set("name", Value::String("Alice".into()))
//!     .set("age", Value::Short(30))
//!     .returning_all()
//!     .to_sql();
//! // "INSERT INTO users (name, age) VALUES ($1, $2) RETURNING *"
//! ```

use std::fmt::Write;

use crate::error::FlozError;
use crate::value::Value;
use super::quote_table;

/// A single-row INSERT query builder.
#[derive(Debug, Clone)]
pub struct InsertQuery {
    table: String,
    columns: Vec<String>,
    values: Vec<Value>,
    returning: ReturningClause,
    on_conflict: Option<OnConflict>,
}

/// What to return after INSERT.
#[derive(Debug, Clone)]
enum ReturningClause {
    None,
    All,               // RETURNING *
    Cols(Vec<String>), // RETURNING col1, col2
}

/// ON CONFLICT configuration.
#[derive(Debug, Clone)]
struct OnConflict {
    column: String,
    updates: Vec<(String, Value)>,
}

impl InsertQuery {
    /// Create a new INSERT query for the given table.
    pub fn new(table: &str) -> Self {
        Self {
            table: table.to_string(),
            columns: Vec::new(),
            values: Vec::new(),
            returning: ReturningClause::None,
            on_conflict: None,
        }
    }

    /// Set a column value. Chainable.
    pub fn set(mut self, column: &str, value: impl Into<Value>) -> Self {
        self.columns.push(column.to_string());
        self.values.push(value.into());
        self
    }

    /// Add RETURNING * to get the full inserted row back.
    pub fn returning_all(mut self) -> Self {
        self.returning = ReturningClause::All;
        self
    }

    /// Add RETURNING for a single column.
    pub fn returning_col(mut self, column: &str) -> Self {
        self.returning = ReturningClause::Cols(vec![column.to_string()]);
        self
    }

    /// Add RETURNING for multiple columns.
    pub fn returning_cols(mut self, columns: &[&str]) -> Self {
        self.returning = ReturningClause::Cols(
            columns.iter().map(|c| c.to_string()).collect(),
        );
        self
    }

    /// Add ON CONFLICT (column) DO UPDATE SET ...
    pub fn on_conflict(mut self, column: &str) -> Self {
        self.on_conflict = Some(OnConflict {
            column: column.to_string(),
            updates: Vec::new(),
        });
        self
    }

    /// Add a column update for the ON CONFLICT clause. Must call `on_conflict()` first.
    pub fn do_update(mut self, column: &str, value: impl Into<Value>) -> Self {
        if let Some(ref mut oc) = self.on_conflict {
            oc.updates.push((column.to_string(), value.into()));
        }
        self
    }

    /// Render to SQL string + parameters.
    pub fn to_sql(&self) -> (String, Vec<Value>) {
        let mut sql = String::with_capacity(128);
        let mut params = Vec::new();
        let mut idx = 0usize;

        // INSERT INTO table
        write!(sql, "INSERT INTO {} (", quote_table(&self.table)).unwrap();

        // Column list
        for (i, col) in self.columns.iter().enumerate() {
            if i > 0 { sql.push_str(", "); }
            sql.push_str(col);
        }

        // VALUES
        sql.push_str(") VALUES (");
        for (i, val) in self.values.iter().enumerate() {
            if i > 0 { sql.push_str(", "); }
            idx += 1;
            write!(sql, "${}", idx).unwrap();
            params.push(val.clone());
        }
        sql.push(')');

        // ON CONFLICT
        if let Some(ref oc) = self.on_conflict {
            write!(sql, " ON CONFLICT ({}) DO UPDATE SET ", oc.column).unwrap();
            for (i, (col, val)) in oc.updates.iter().enumerate() {
                if i > 0 { sql.push_str(", "); }
                idx += 1;
                write!(sql, "{} = ${}", col, idx).unwrap();
                params.push(val.clone());
            }
        }

        // RETURNING
        match &self.returning {
            ReturningClause::None => {}
            ReturningClause::All => sql.push_str(" RETURNING *"),
            ReturningClause::Cols(cols) => {
                sql.push_str(" RETURNING ");
                for (i, col) in cols.iter().enumerate() {
                    if i > 0 { sql.push_str(", "); }
                    sql.push_str(col);
                }
            }
        }

        (sql, params)
    }
}

/// A bulk INSERT query builder.
///
/// All rows must have the exact same columns. If any row is missing a column
/// that the first row defined, `to_sql()` returns `FlozError::MismatchedBulkInsertColumns`.
#[derive(Debug, Clone)]
pub struct InsertManyQuery {
    table: String,
    /// Each row is a list of (column_name, value) pairs.
    rows: Vec<Vec<(String, Value)>>,
    returning: ReturningClause,
}

impl InsertManyQuery {
    /// Create a new bulk INSERT query.
    pub fn new(table: &str) -> Self {
        Self {
            table: table.to_string(),
            rows: Vec::new(),
            returning: ReturningClause::None,
        }
    }

    /// Add a row. Each row is a slice of (column_name, value) pairs.
    pub fn row(mut self, fields: Vec<(String, Value)>) -> Self {
        self.rows.push(fields);
        self
    }

    /// Add multiple rows at once.
    pub fn rows(mut self, rows: Vec<Vec<(String, Value)>>) -> Self {
        self.rows = rows;
        self
    }

    /// Add RETURNING *.
    pub fn returning_all(mut self) -> Self {
        self.returning = ReturningClause::All;
        self
    }

    /// Render to SQL string + parameters, or error if rows have mismatched columns.
    pub fn to_sql(&self) -> Result<(String, Vec<Value>), FlozError> {
        if self.rows.is_empty() {
            // Empty insert — just produce a valid but no-op statement
            let sql = format!("INSERT INTO {} DEFAULT VALUES", quote_table(&self.table));
            return Ok((sql, Vec::new()));
        }

        // Get column order from first row
        let first_row = &self.rows[0];
        let columns: Vec<&str> = first_row.iter().map(|(c, _)| c.as_str()).collect();
        let col_count = columns.len();

        // Validate all rows have the same columns
        for (row_idx, row) in self.rows.iter().enumerate().skip(1) {
            if row.len() != col_count {
                // Find which column is missing
                let row_cols: Vec<&str> = row.iter().map(|(c, _)| c.as_str()).collect();
                for expected in &columns {
                    if !row_cols.contains(expected) {
                        return Err(FlozError::MismatchedBulkInsertColumns {
                            row: row_idx,
                            column: expected.to_string(),
                        });
                    }
                }
                // If we get here, row has extra columns
                return Err(FlozError::MismatchedBulkInsertColumns {
                    row: row_idx,
                    column: format!("row has {} columns, expected {}", row.len(), col_count),
                });
            }
        }

        let mut sql = String::with_capacity(128);
        let mut params = Vec::new();
        let mut idx = 0usize;

        // INSERT INTO table (col1, col2, ...)
        write!(sql, "INSERT INTO {} (", quote_table(&self.table)).unwrap();
        for (i, col) in columns.iter().enumerate() {
            if i > 0 { sql.push_str(", "); }
            sql.push_str(col);
        }
        sql.push_str(") VALUES ");

        // VALUES ($1, $2), ($3, $4), ...
        for (row_idx, row) in self.rows.iter().enumerate() {
            if row_idx > 0 { sql.push_str(", "); }
            sql.push('(');
            for (i, (_, val)) in row.iter().enumerate() {
                if i > 0 { sql.push_str(", "); }
                idx += 1;
                write!(sql, "${}", idx).unwrap();
                params.push(val.clone());
            }
            sql.push(')');
        }

        // RETURNING
        match &self.returning {
            ReturningClause::None => {}
            ReturningClause::All => sql.push_str(" RETURNING *"),
            ReturningClause::Cols(cols) => {
                sql.push_str(" RETURNING ");
                for (i, col) in cols.iter().enumerate() {
                    if i > 0 { sql.push_str(", "); }
                    sql.push_str(col);
                }
            }
        }

        Ok((sql, params))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn insert_single_column() {
        let (sql, params) = InsertQuery::new("users")
            .set("name", "Alice")
            .to_sql();
        assert_eq!(sql, "INSERT INTO users (name) VALUES ($1)");
        assert_eq!(params, vec![Value::String("Alice".into())]);
    }

    #[test]
    fn insert_multiple_columns() {
        let (sql, params) = InsertQuery::new("users")
            .set("name", "Alice")
            .set("age", 30i16)
            .to_sql();
        assert_eq!(sql, "INSERT INTO users (name, age) VALUES ($1, $2)");
        assert_eq!(params, vec![
            Value::String("Alice".into()),
            Value::Short(30),
        ]);
    }

    #[test]
    fn insert_returning_all() {
        let (sql, _) = InsertQuery::new("users")
            .set("name", "Alice")
            .returning_all()
            .to_sql();
        assert!(sql.ends_with("RETURNING *"));
    }

    #[test]
    fn insert_returning_col() {
        let (sql, _) = InsertQuery::new("users")
            .set("name", "Alice")
            .returning_col("id")
            .to_sql();
        assert!(sql.ends_with("RETURNING id"));
    }

    #[test]
    fn insert_returning_cols() {
        let (sql, _) = InsertQuery::new("users")
            .set("name", "Alice")
            .returning_cols(&["id", "created_at"])
            .to_sql();
        assert!(sql.ends_with("RETURNING id, created_at"));
    }

    #[test]
    fn insert_on_conflict() {
        let (sql, params) = InsertQuery::new("users")
            .set("name", "Alice")
            .set("age", 30i16)
            .on_conflict("name")
            .do_update("age", 31i16)
            .to_sql();
        assert_eq!(
            sql,
            "INSERT INTO users (name, age) VALUES ($1, $2) ON CONFLICT (name) DO UPDATE SET age = $3"
        );
        assert_eq!(params.len(), 3);
    }

    #[test]
    fn insert_on_conflict_multiple_updates() {
        let (sql, params) = InsertQuery::new("users")
            .set("name", "Alice")
            .set("age", 30i16)
            .on_conflict("name")
            .do_update("age", 31i16)
            .do_update("name", "Alice Updated")
            .to_sql();
        assert_eq!(
            sql,
            "INSERT INTO users (name, age) VALUES ($1, $2) ON CONFLICT (name) DO UPDATE SET age = $3, name = $4"
        );
        assert_eq!(params.len(), 4);
    }

    #[test]
    fn insert_schema_qualified() {
        let (sql, _) = InsertQuery::new("auth.users")
            .set("name", "Alice")
            .to_sql();
        assert!(sql.starts_with("INSERT INTO \"auth\".\"users\""));
    }

    // ── InsertMany ──

    #[test]
    fn insert_many_basic() {
        let (sql, params) = InsertManyQuery::new("users")
            .row(vec![
                ("name".into(), Value::String("Alice".into())),
                ("age".into(), Value::Short(30)),
            ])
            .row(vec![
                ("name".into(), Value::String("Bob".into())),
                ("age".into(), Value::Short(25)),
            ])
            .to_sql()
            .unwrap();
        assert_eq!(
            sql,
            "INSERT INTO users (name, age) VALUES ($1, $2), ($3, $4)"
        );
        assert_eq!(params.len(), 4);
    }

    #[test]
    fn insert_many_single_row() {
        let (sql, params) = InsertManyQuery::new("users")
            .row(vec![
                ("name".into(), Value::String("Alice".into())),
            ])
            .to_sql()
            .unwrap();
        assert_eq!(sql, "INSERT INTO users (name) VALUES ($1)");
        assert_eq!(params.len(), 1);
    }

    #[test]
    fn insert_many_returning() {
        let (sql, _) = InsertManyQuery::new("users")
            .row(vec![("name".into(), Value::String("A".into()))])
            .row(vec![("name".into(), Value::String("B".into()))])
            .returning_all()
            .to_sql()
            .unwrap();
        assert!(sql.ends_with("RETURNING *"));
    }

    #[test]
    fn insert_many_ragged_rows_error() {
        let result = InsertManyQuery::new("users")
            .row(vec![
                ("name".into(), Value::String("Alice".into())),
                ("age".into(), Value::Short(30)),
            ])
            .row(vec![
                ("name".into(), Value::String("Bob".into())),
                // Missing "age"!
            ])
            .to_sql();
        assert!(result.is_err());
        match result {
            Err(FlozError::MismatchedBulkInsertColumns { row, column }) => {
                assert_eq!(row, 1);
                assert_eq!(column, "age");
            }
            _ => panic!("Expected MismatchedBulkInsertColumns"),
        }
    }

    #[test]
    fn insert_many_empty() {
        let (sql, params) = InsertManyQuery::new("users")
            .to_sql()
            .unwrap();
        assert_eq!(sql, "INSERT INTO users DEFAULT VALUES");
        assert!(params.is_empty());
    }

    #[test]
    fn insert_many_three_rows() {
        let (sql, params) = InsertManyQuery::new("users")
            .row(vec![("x".into(), Value::Int(1))])
            .row(vec![("x".into(), Value::Int(2))])
            .row(vec![("x".into(), Value::Int(3))])
            .to_sql()
            .unwrap();
        assert_eq!(sql, "INSERT INTO users (x) VALUES ($1), ($2), ($3)");
        assert_eq!(params.len(), 3);
    }
}