use deadpool_postgres::{Config, Pool, Runtime, Client as PgClient};
use tokio_postgres::NoTls;
use std::env;
use anyhow::{Error, Result};
use log::{info, error};

pub struct Exporter {
    pool : Option<Pool>,
}

impl Exporter {
    fn config_construct() -> Result<Config> {
        let mut cfg = Config::new();
        cfg.host = Some(env::var("DB_HOST")?);
        cfg.dbname = Some(env::var("DB_DBNAME")?);
        cfg.user = Some(env::var("DB_USER")?);
        cfg.password = Some(env::var("DB_PASSWORD")?);
        Ok(cfg)
    }
    fn pool_construct() -> Option<Pool> {
        return match Self::config_construct() {
            Ok(config) => {
                if let Ok(pool) = config.create_pool(Some(Runtime::Tokio1), NoTls) {
                    info!("Connected to PostgreSQL");
                    return Some(pool);
                }
                None
            },
            Err(_) => {
                error!("Bad DB credentials or it's unreachable");
                None
            },
        } 
    } 
    pub fn is_no_connection(&self) -> bool { self.pool.is_none() }
    pub fn init() -> Self {
        Self {
            pool : Self::pool_construct()
        }
    }
    pub async fn get_connection_from_pool(&self) -> Option<PgClient> {
        if let Some(pool) = &self.pool {
            return Some(pool.get().await.ok()?);
        }
        None
    } 
    pub async fn export_data(client: PgClient, metrics: &str) -> Result<()> {
        // client.
        let query = client.prepare_cached("INSERT INTO metrics (body) VALUES ($1);").await?; 
        let _ = client.query(&query, &[&metrics]).await?;
        Ok(())
    }

}