use config::Config;
use serde::{Serialize,Deserialize};
use crate::errors::{LJError,LJResult};
use crate::transformer;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Conf {
    pub laser_id: u8,
    pub debug: bool,
    pub redis_url: String,
    pub dac: DacFamily,
    #[serde(default)]
    pub transformers: Vec<TransformConf>
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum DacFamily {
    #[serde(rename = "helios")] 
    Helios(HeliosConf),
    #[serde(rename = "etherdream")] 
    Etherdream(EtherDreamConf),
    #[serde(rename = "dummy")] 
    Dummy,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct HeliosConf {
    pub id: u8
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct EtherDreamConf {
    pub url: String
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum TransformConf {
    #[serde(rename = "translate")] 
    Translate(transformer::Translate),
    #[serde(rename = "replicate")] 
    Replicate(transformer::Replicate),
    #[serde(rename = "rotate")] 
    Rotate(transformer::Rotate),
    #[serde(rename = "flip_horizontal")] 
    FlipH(transformer::FlipHorizontal),
    #[serde(rename = "flip_vertical")] 
    FlipV(transformer::FlipVertical),    
    #[serde(rename = "grid")] 
    Grid(transformer::Grid),
    #[serde(rename = "homography")] 
    Homography(transformer::Homography)
}


impl Conf {
    pub fn new(path: &str) -> LJResult<Conf> {
	let settings = Config::builder()
            .add_source(config::File::with_name(path))
	    .build()?;
        
	let conf : Conf = settings.try_deserialize().map_err(LJError::Config)?;
	Ok(conf)
    }

    pub fn get_transformers(&self) -> Vec<Box<dyn transformer::Transformers>> {
	let mut v = vec![];
	for t in &self.transformers {
	    let t : Box<dyn transformer::Transformers> = match t {
		TransformConf::Translate(t) => Box::new(*t),
		TransformConf::Replicate(r) => Box::new(*r),
		TransformConf::Rotate(r) => Box::new(*r),
		TransformConf::FlipH(r) => Box::new(*r),
		TransformConf::FlipV(r) => Box::new(*r),		
		TransformConf::Grid(r) => Box::new(*r),
		TransformConf::Homography(r) => Box::new(*r),
	    };
	    v.push(t);
	}
	v
    }

    #[allow(dead_code)]
    pub fn dump() {
	let conf = Conf {
	    laser_id: 0,
	    debug: true,
	    redis_url: "redis://127.0.0.1:6379/".to_string(),
	    dac: DacFamily::Helios(HeliosConf { id: 0 }),
	    transformers: vec![
		TransformConf::Translate(transformer::Translate { x: 2000.0,
								  y: 2000.0 } ),
		TransformConf::Replicate(transformer::Replicate::Until(48))
	    ]
	};
	let s = toml::to_string(&conf).unwrap();
	println!("{}", s);
    }
}