use crate::{ffi, Error, Result, Statement};

use std::ffi::CStr;

mod sealed {

use std::ffi::CStr;

/// This trait exists just to ensure that the only impls of `trait BindIndex`

/// that are allowed are ones in this crate.

pub trait Sealed {}

impl Sealed for usize {}

impl Sealed for &str {}

impl Sealed for &CStr {}

}

/// A trait implemented by types that can index into parameters of a statement.

///

/// It is only implemented for `usize` and `&str` and `&CStr`.

pub trait BindIndex: sealed::Sealed {

/// Returns the index of the associated parameter, or `Error` if no such

/// parameter exists.

fn idx(&self, stmt: &Statement<'_>) -> Result<usize>;

}

impl BindIndex for usize {

#[inline]

fn idx(&self, _: &Statement<'_>) -> Result<usize> {

// No validation

Ok(*self)

}

}

impl BindIndex for &'_ str {

fn idx(&self, stmt: &Statement<'_>) -> Result<usize> {

match stmt.parameter_index(self)? {

Some(idx) => Ok(idx),

None => Err(Error::InvalidParameterName(self.to_string())),

}

}

}

/// C-string literal to avoid alloc

impl BindIndex for &CStr {

fn idx(&self, stmt: &Statement<'_>) -> Result<usize> {

let r = unsafe { ffi::sqlite3_bind_parameter_index(stmt.ptr(), self.as_ptr()) };

match r {

0 => Err(Error::InvalidParameterName(

self.to_string_lossy().to_string(),

)),

i => Ok(i as usize),

}

}

}

#[cfg(all(test, not(miri)))]

mod test {

use crate::{ffi, Connection, Error, Result};

#[test]

fn invalid_name() -> Result<()> {

let db = Connection::open_in_memory()?;

let mut stmt = db.prepare("SELECT 1")?;

let err = stmt.raw_bind_parameter(1, 1).unwrap_err();

assert_eq!(

err.sqlite_error_code(),

Some(ffi::ErrorCode::ParameterOutOfRange),

);

let err = stmt.raw_bind_parameter(":p1", 1).unwrap_err();

assert_eq!(err, Error::InvalidParameterName(":p1".to_owned()));

let err = stmt.raw_bind_parameter(c"x", 1).unwrap_err();

assert_eq!(err, Error::InvalidParameterName("x".to_owned()));

Ok(())

}

}