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

#[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 ip: 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),
    #[serde(rename = "angle_correction")]
    AngleOptimisation(transformer::AngleOptimisation),
}

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

        dbg!("path:", path);
        //println!("plop");
        dbg!(settings.clone());
        let conf: Conf = settings.try_deserialize().map_err(LJError::Config)?;

        //println!("plum");
        Ok(conf)
    }

    //println!("plop");

    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),
                TransformConf::AngleOptimisation(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);
    }
}