use crate::{
    DBPlatform,
    Dao,
    DataError,
    DbError,
    Rows,
    Value,
};

/// an interface executing sql statement and getting the results as generic DAO values
/// without any further conversion.
pub struct DaoManager(pub DBPlatform);

impl DaoManager {
    pub fn begin_transaction(&mut self) -> Result<(), DbError> { self.0.begin_transaction() }

    pub fn commit_transaction(&mut self) -> Result<(), DbError> { self.0.commit_transaction() }

    pub fn rollback_transaction(&mut self) -> Result<(), DbError> { self.0.rollback_transaction() }

    pub fn execute_sql_with_return(
        &mut self,
        sql: &str,
        params: &[&Value],
    ) -> Result<Rows, DbError> {
        let rows = self.0.execute_sql_with_return(sql, params)?;
        Ok(rows)
    }

    pub fn execute_sql_with_records_return(
        &mut self,
        sql: &str,
        params: &[&Value],
    ) -> Result<Vec<Dao>, DbError> {
        let rows = self.0.execute_sql_with_return(sql, params)?;
        let daos: Vec<Dao> = rows.iter().collect();
        Ok(daos)
    }

    pub fn execute_sql_with_one_return(
        &mut self,
        sql: &str,
        params: &[&Value],
    ) -> Result<Dao, DbError> {
        let record: Result<Option<Dao>, DbError> =
            self.execute_sql_with_maybe_one_return(sql, params);
        match record {
            Ok(record) => {
                match record {
                    Some(record) => Ok(record),
                    None => Err(DbError::DataError(DataError::ZeroRecordReturned)),
                }
            }
            Err(e) => Err(e),
        }
    }

    pub fn execute_sql_with_maybe_one_return(
        &mut self,
        sql: &str,
        params: &[&Value],
    ) -> Result<Option<Dao>, DbError> {
        let result: Result<Vec<Dao>, DbError> = self.execute_sql_with_records_return(sql, params);
        match result {
            Ok(mut result) => {
                match result.len() {
                    0 => Ok(None),
                    1 => Ok(Some(result.remove(0))),
                    _ => Err(DbError::DataError(DataError::MoreThan1RecordReturned)),
                }
            }
            Err(e) => Err(e),
        }
    }
}