//! Postgres RDBC Driver
//!
//! This crate implements an RDBC Driver for the `postgres` crate.
//!
//! The RDBC (Rust DataBase Connectivity) API is loosely based on the ODBC and JDBC standards.
//!
//! ```rust,no_run
//! use crate::*;
//! use rdbc::postgres::PostgresDriver;
//! use rdbc::Driver;
//!
//! let driver = PostgresDriver::new();
//! let mut conn = driver.connect("postgres://postgres:password@localhost:5433").unwrap();
//! let mut stmt = conn.prepare("SELECT a FROM b WHERE c = ?").unwrap();
//! let mut rs = stmt.execute_query(&[Value::Int32(123)]).unwrap();
//! while rs.next() {
//!   println!("{:?}", rs.get_string(1));
//! }
//! ```

use postgres::rows::Rows;
use postgres::{Connection, TlsMode};

use sqlparser::dialect::PostgreSqlDialect;
use sqlparser::tokenizer::{Token, Tokenizer, Word};

use postgres::types::Type;
use crate::{Column, Error, ResultSet};

pub struct PostgresDriver {}

impl PostgresDriver {
    pub fn new() -> Self {
        PostgresDriver {}
    }
}

impl crate::Driver for PostgresDriver {
    fn connect(&self, url: &str) -> crate::Result<Box<dyn crate::Connection>> {
        let c = postgres::Connection::connect(url, TlsMode::None).map_err(to_rdbc_err)?;
        Ok(Box::new(PConnection::new(c)))
    }
}

struct PConnection {
    conn: Connection,
}

impl PConnection {
    pub fn new(conn: Connection) -> Self {
        Self { conn }
    }
}

impl crate::Connection for PConnection {
    fn create(&mut self, sql: &str) -> crate::Result<Box<dyn crate::Statement + '_>> {
        self.prepare(sql)
    }

    fn prepare(&mut self, sql: &str) -> crate::Result<Box<dyn crate::Statement + '_>> {
        // translate SQL, mapping ? into $1 style bound param placeholder
        let dialect = PostgreSqlDialect {};
        let mut tokenizer = Tokenizer::new(&dialect, sql);
        let tokens = tokenizer.tokenize().unwrap();
        let mut i = 0;
        let tokens: Vec<Token> = tokens
            .iter()
            .map(|t| match t {
                Token::Char(c) if *c == '?' => {
                    i += 1;
                    Token::Word(Word {
                        value: format!("${}", i),
                        quote_style: None,
                        keyword: "".to_owned(),
                    })
                }
                _ => t.clone(),
            })
            .collect();
        let sql = tokens
            .iter()
            .map(|t| format!("{}", t))
            .collect::<Vec<String>>()
            .join("");

        Ok(Box::new(PStatement {
            conn: &self.conn,
            sql,
        }))
    }

    fn is_valid(&mut self) -> bool {
        return self.conn.query("",&[]).is_ok();
    }
}

struct PStatement<'a> {
    conn: &'a Connection,
    sql: String,
}

impl<'a> crate::Statement for PStatement<'a> {
    fn execute_query(
        &mut self,
        params: &[crate::Value],
    ) -> crate::Result<Box<dyn crate::ResultSet + '_>> {
        let params = to_postgres_value(params);
        let params: Vec<&dyn postgres::types::ToSql> = params.iter().map(|v| v.as_ref()).collect();
        let rows = self
            .conn
            .query(&self.sql, params.as_slice())
            .map_err(to_rdbc_err)?;
        let meta = rows
            .columns()
            .iter()
            .map(|c| crate::Column::new(c.name(), to_rdbc_type(c.type_())))
            .collect();

        Ok(Box::new(PResultSet { meta, i: 0, rows }))
    }

    fn execute_update(&mut self, params: &[crate::Value]) -> crate::Result<u64> {
        let params = to_postgres_value(params);
        let params: Vec<&dyn postgres::types::ToSql> = params.iter().map(|v| v.as_ref()).collect();
        self.conn
            .execute(&self.sql, params.as_slice())
            .map_err(to_rdbc_err)
    }
}

struct PResultSet {
    meta: Vec<Column>,
    i: usize,
    rows: Rows,
}

macro_rules! impl_resultset_fns {
    ($($fn: ident -> $ty: ty),*) => {
        $(
            fn $fn(&self, i: u64) -> crate::Result<Option<$ty>> {
                Ok(self.rows.get(self.i - 1).get(i as usize))
            }
        )*
    }
}

impl crate::ResultSet for PResultSet {
    fn meta_data(&self) -> crate::Result<Box<dyn crate::ResultSetMetaData>> {
        Ok(Box::new(self.meta.clone()))
    }

    fn next(&mut self) -> bool {
        if self.i < self.rows.len() {
            self.i = self.i + 1;
            true
        } else {
            false
        }
    }

    impl_resultset_fns! {
        get_i8 -> i8,
        get_i16 -> i16,
        get_i32 -> i32,
        get_i64 -> i64,
        get_f32 -> f32,
        get_f64 -> f64,
        get_string -> String,
        get_bytes -> Vec<u8>
    }

    fn get_date(&self, i: u64) -> Result<Option<String>, Error> {
        return self.get_string(i);
    }
}

/// Convert a Postgres error into an RDBC error
fn to_rdbc_err(e: postgres::error::Error) -> crate::Error {
    crate::Error::General(format!("{:?}", e))
}

fn to_rdbc_type(ty: &Type) -> crate::DataType {
    match ty.name() {
        "varchar" | "text" => crate::DataType::Utf8,

        "bool" | "boolean" => crate::DataType::Bool,

        "bytea" => crate::DataType::Byte,

        "char" | "character" => crate::DataType::Char,

        "int" | "int2" | "int4" | "int8" | "bigint" | "bigserial" | "serial8" => crate::DataType::Integer,

        "real" | "float4" => crate::DataType::Float,

        "float8" | "double precision" => crate::DataType::Double,

        "numeric" | "decimal" => crate::DataType::Decimal,

        "date" => crate::DataType::Date,

        "time" | "timetz" => crate::DataType::Time,

        "timestamp" | "timestamptz" => crate::DataType::Datetime,

        _ => crate::DataType::Utf8,
    }
}

fn to_postgres_value(values: &[crate::Value]) -> Vec<Box<dyn postgres::types::ToSql>> {
    values
        .iter()
        .map(|v| match v {
            crate::Value::String(s) => Box::new(s.clone()) as Box<dyn postgres::types::ToSql>,
        })
        .collect()
}

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


    fn execute(sql: &str, values: &Vec<crate::Value>) -> crate::Result<u64> {
        println!("Executing '{}' with {} params", sql, values.len());
        let driver: Arc<dyn crate::Driver> = Arc::new(PostgresDriver::new());
        let mut conn = driver.connect("postgres://rdbc:secret@127.0.0.1:5433")?;
        let mut stmt = conn.prepare(sql)?;
        stmt.execute_update(values)
    }
}