ecto_libsql

/// Database metadata and introspection functions
///
/// This module provides functions to query database metadata and state information,
/// such as the number of affected rows, last inserted row IDs, and autocommit mode.
use crate::constants::*;
use crate::utils::{safe_lock, safe_lock_arc};
use rustler::NifResult;

/// Get the rowid of the last inserted row in the current connection.
///
/// In SQLite, every row has an implicit `rowid` column (unless WITHOUT ROWID is used).
/// This function returns the rowid of the most recently inserted row, which is useful
/// for retrieving auto-generated IDs.
///
/// Returns 0 if no inserts have occurred in this session.
///
/// # Arguments
/// - `conn_id`: Database connection ID
///
/// # Examples
/// ```elixir
/// {:ok, _} = EctoLibSql.execute("INSERT INTO users (name) VALUES (?)", ["Alice"])
/// rowid = EctoLibSql.last_insert_rowid(conn_id)  # Returns the ID of the inserted user
/// ```
#[rustler::nif(schedule = "DirtyIo")]
pub fn last_insert_rowid(conn_id: &str) -> NifResult<i64> {
    let conn_map = safe_lock(&CONNECTION_REGISTRY, "last_insert_rowid conn_map")?;

    if let Some(client) = conn_map.get(conn_id) {
        let client = client.clone();
        drop(conn_map); // Release lock before async operation

        let result = TOKIO_RUNTIME.block_on(async {
            let client_guard = safe_lock_arc(&client, "last_insert_rowid client")?;
            let conn_guard = safe_lock_arc(&client_guard.client, "last_insert_rowid conn")?;

            Ok::<i64, rustler::Error>(conn_guard.last_insert_rowid())
        })?;

        Ok(result)
    } else {
        Err(rustler::Error::Term(Box::new("Invalid connection ID")))
    }
}

/// Get the number of rows affected by the last statement execution.
///
/// This returns the number of rows modified by the most recent INSERT, UPDATE, or DELETE
/// statement. For SELECT statements or other statements that don't modify data, returns 0.
///
/// Useful for verifying that the expected number of rows were affected by DML operations.
///
/// # Arguments
/// - `conn_id`: Database connection ID
///
/// # Examples
/// ```elixir
/// {:ok, _} = EctoLibSql.execute("UPDATE users SET active = 1 WHERE age > 18")
/// changes = EctoLibSql.changes(conn_id)  # Returns number of updated rows
/// ```
#[rustler::nif(schedule = "DirtyIo")]
pub fn changes(conn_id: &str) -> NifResult<u64> {
    let conn_map = safe_lock(&CONNECTION_REGISTRY, "changes conn_map")?;

    if let Some(client) = conn_map.get(conn_id) {
        let client = client.clone();
        drop(conn_map); // Release lock before async operation

        let result = TOKIO_RUNTIME.block_on(async {
            let client_guard = safe_lock_arc(&client, "changes client")?;
            let conn_guard = safe_lock_arc(&client_guard.client, "changes conn")?;

            Ok::<u64, rustler::Error>(conn_guard.changes())
        })?;

        Ok(result)
    } else {
        Err(rustler::Error::Term(Box::new("Invalid connection ID")))
    }
}

/// Get the total number of rows affected since this connection was opened.
///
/// Unlike `changes()` which returns only the last statement's impact, this returns
/// the cumulative total of all rows modified (INSERT, UPDATE, DELETE) since the
/// connection was established.
///
/// This is useful for connection-level metrics and monitoring.
///
/// # Arguments
/// - `conn_id`: Database connection ID
///
/// # Examples
/// ```elixir
/// total = EctoLibSql.total_changes(conn_id)  # Cumulative rows affected
/// ```
#[rustler::nif(schedule = "DirtyIo")]
pub fn total_changes(conn_id: &str) -> NifResult<u64> {
    let conn_map = safe_lock(&CONNECTION_REGISTRY, "total_changes conn_map")?;

    if let Some(client) = conn_map.get(conn_id) {
        let client = client.clone();
        drop(conn_map); // Release lock before async operation

        let result = TOKIO_RUNTIME.block_on(async {
            let client_guard = safe_lock_arc(&client, "total_changes client")?;
            let conn_guard = safe_lock_arc(&client_guard.client, "total_changes conn")?;

            Ok::<u64, rustler::Error>(conn_guard.total_changes())
        })?;

        Ok(result)
    } else {
        Err(rustler::Error::Term(Box::new("Invalid connection ID")))
    }
}

/// Check if the connection is in autocommit mode.
///
/// SQLite starts in autocommit mode by default, where each statement is committed
/// immediately unless inside an explicit transaction.
///
/// Returns `true` if in autocommit mode, `false` if inside a transaction.
///
/// # Arguments
/// - `conn_id`: Database connection ID
///
/// # Examples
/// ```elixir
/// is_auto = EctoLibSql.is_autocommit(conn_id)  # Returns true outside transactions
/// ```
#[rustler::nif(schedule = "DirtyIo")]
pub fn is_autocommit(conn_id: &str) -> NifResult<bool> {
    let conn_map = safe_lock(&CONNECTION_REGISTRY, "is_autocommit conn_map")?;

    if let Some(client) = conn_map.get(conn_id) {
        let client = client.clone();
        drop(conn_map); // Release lock before async operation

        let result = TOKIO_RUNTIME.block_on(async {
            let client_guard = safe_lock_arc(&client, "is_autocommit client")?;
            let conn_guard = safe_lock_arc(&client_guard.client, "is_autocommit conn")?;

            Ok::<bool, rustler::Error>(conn_guard.is_autocommit())
        })?;

        Ok(result)
    } else {
        Err(rustler::Error::Term(Box::new("Invalid connection ID")))
    }
}