use chrono::Utc;
use sqlx::postgres::PgRow;
use sqlx::Column;
use sqlx::Row;
use sqlx::TypeInfo;

use crate::error;

#[derive(Debug)]
pub struct Col<T> {
    name: String,
    sql_type: String,
    value: Option<T>,
}

#[derive(Debug)]
pub enum ColType {
    I8(Col<i8>),
    String(Col<String>),
    Bool(Col<bool>),
    I16(Col<i16>),
    I32(Col<i32>),
    I64(Col<i64>),
    F32(Col<f32>),
    F64(Col<f64>),
    DateTime(Col<chrono::DateTime<Utc>>),
}

impl ColType {
    pub fn new(row: &PgRow, idx: usize) -> error::Result<Self> {
        let column = row.columns().get(idx).unwrap();
        let sql_type = column.type_info().name();
        let name = String::from(column.name());

        match sql_type {
            "BOOL" => {
                let value: Option<bool> = row.try_get(idx)?;
                Ok(ColType::Bool(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            "VARCHAR" | "char(n)" | "TEXT" | "NAME" => {
                let value: Option<String> = row.try_get(idx)?;
                Ok(ColType::String(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            "CHAR" => {
                let value: Option<i8> = row.try_get(idx)?;
                Ok(ColType::I8(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            "SMALLSERIAL" | "SMALLINT" => {
                let value: Option<i16> = row.try_get(idx)?;
                Ok(ColType::I16(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            "INT" | "INT4" | "SERIAL" => {
                let value: Option<i32> = row.try_get(idx)?;
                Ok(ColType::I32(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            "INT8" | "BIGSERIAL" | "BIGINT" => {
                let value: Option<i64> = row.try_get(idx)?;
                Ok(ColType::I64(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            "FLOAT4" | "REAL" => {
                let value: Option<f32> = row.try_get(idx)?;
                Ok(ColType::F32(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            "FLOAT8" | "double precision" => {
                let value: Option<f64> = row.try_get(idx)?;
                Ok(ColType::F64(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            "TIMESTAMP" | "TIMESTAMPTZ" => {
                // with-chrono feature is needed for this
                let value: Option<chrono::DateTime<Utc>> = row.try_get(idx)?;
                Ok(ColType::DateTime(Col {
                    sql_type: String::from(sql_type),
                    value,
                    name,
                }))
            }
            &_ => panic!("{} Type not found!", sql_type),
        }
    }
}