use diesel::prelude::*;
use diesel::pg::PgConnection;
use diesel::result::Error;
use dotenvy::dotenv;
use std::env;
use serde::{Serialize};
use diesel_derive_enum::DbEnum;


#[derive(Debug, PartialEq, DbEnum, Serialize)]
#[db_enum(existing_type_path = "crate::schema::sql_types::DidTargetType")]
pub enum DidTargetType {
    #[db_enum(rename ="URL")]
    Url,
    #[db_enum(rename ="MOH")]
    Moh,
    #[db_enum(rename ="EXTERNAL_NUMBER")]
    ExternalNumber,
    #[db_enum(rename ="NO_SERVICE")]
    NoService,
    #[db_enum(rename ="NIGHT_MODE")]
    NightMode,
    #[db_enum(rename ="CUSTOME_MESSAGE")]
    CustomMessage
}

#[derive(Queryable, Selectable, Serialize)]
#[diesel(table_name = crate::schema::dids)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct Did {
    pub id: i32,
    pub did: String,
    pub target_type: DidTargetType,
    pub target: Option<String>,
    pub active: bool
}

#[derive(Insertable)]
#[diesel(table_name = crate::schema::dids)]
pub struct NewDid<'a> {
    pub did: &'a str,
    pub target_type: DidTargetType,
    pub target: Option<&'a str>,
    pub active: bool
}

pub fn connect() -> PgConnection {
    dotenv().ok();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    PgConnection::establish(&database_url)
        .unwrap_or_else(|_| panic!("Error connecting to database"))
}

pub fn add_did() -> Result<Did, Error> {
    use crate::schema::dids;

    let mut conn = connect();
    let new_did = NewDid {
        did: "123456",
        target_type: DidTargetType::Url,
        target: Some("123456"),
        active: true
    };

    let did = diesel::insert_into(dids::table)
        .values(&new_did)
        .returning(Did::as_returning())
        .get_result(&mut conn)?;

    Ok(did)
}

pub fn list_did() ->Result<Vec<Did>, Error> {
    use crate::schema::dids::dsl::*;
    let mut conn = connect();

    let res = dids
        .load(&mut conn)?;

    Ok(res)
}