//mod qualib_refacto;
//use qualib_refacto;
//use qualib_refacto::{self, Qualibration as Qualib};

///
/// Configure udev:
/// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
///
mod conf;
mod draw;
mod framerate;
mod logs;
mod point;

mod qualib_refacto;
mod utils;

use qualib_refacto::{annalyse::adding_trackbar, Qualibration, Sequence};

use conf::Conf;
use log::{/*debug,  warn, */ error, info};
use logs::init_logging;
use point::{Color, Point};
use redis::{Client, Commands, Connection};
use std::sync::{
    atomic::{AtomicBool, Ordering},
    Arc,
};

use opencv::highgui;
use opencv::Result;

opencv::opencv_branch_4! {
    #[allow(unused_imports)]
    use opencv::imgproc::LINE_AA;
}
opencv::not_opencv_branch_4! {
    #[allow(unused_imports)]
    use opencv::core::LINE_AA;
}

const DEFAULT_CONF_FILE: &str = "settings.toml";

pub fn main() {
    match run_all() {
        Ok(()) => {}
        Err(err) => {
            error!("Error: {}", err);
        }
    }
}

fn run_all() -> Result<(), Box<dyn std::error::Error>> {
    // Setup configuration file and set up logs
    let filename = DEFAULT_CONF_FILE.to_string();
    let config = Conf::new(&filename);
    init_logging(&config);
    let config = config?;
    let conf2 = config.clone();

    let client = Client::open(config.redis_url.clone())?;
    let mut con: Connection = client.get_connection()?;

    let mut framerate_handler = framerate::Framerate::new(config.framerate)?;

    // Setup handler for interrupt Signals
    let running = Arc::new(AtomicBool::new(true));
    let r = running.clone();
    ctrlc::set_handler(move || {
        let client = Client::open(conf2.redis_url.clone()).unwrap();
        let mut con: Connection = client.get_connection().unwrap();
        let _a: () = con
            .set(
                format!("/pl/{}/{}", conf2.client_id, conf2.laser_id),
                format!("[]"),
            )
            .unwrap();
        r.store(false, Ordering::SeqCst);
    })?;

    info!("*** Starting up ***");
    info!("{:?}", config);

    let mut qualibration = Qualibration::new()?;
    adding_trackbar(&mut qualibration.param, "histogram: 0")?;

    let _a: () = con.set(format!("/kpps/{}", conf2.laser_id), 65535)?;
    let _a: () = con.set(
        format!("/order/{}", conf2.laser_id),
        7, // order to change kpps
    )?;

    while running.load(Ordering::SeqCst) {
        //let _t = framerate_handler.handle_time()?;
        /////////////////
        let key = highgui::wait_key(1)?;
        qualibration.param.key = key;
        if key == 27 {
            break;
        }

        let v = qualibration.draw_sequence();
        if v.is_some() {
            if qualibration.param.capture_mode {
                let pl: Vec<(f32, f32, u32)> = v
                    .unwrap()
                    .iter()
                    .map(|pt| (pt.x, pt.y, u32::from(pt.color)))
                    .collect();

                let _ = con.set(
                    format!("/pl/{}/{}", config.client_id, config.laser_id),
                    format!("{:?}", pl),
                )?;
            }

            qualibration.run_step()?;
        }
        //qualibration.id = next_id;

        //let q_id = qualibration.id.clone();
        //let mut n = 65534;
        //if let Sequence::TakeMultiple(m) = q_id.clone().unwrap_or(Sequence::Finish) {
        //    n = m;
        //};
        //if qualibration.capture_mode
        //    && (q_id != Some(Sequence::WaitSpace)
        //        || q_id != Some(Sequence::PlayLineDotted)
        //        || n != 65534)
        //{
        //    let millis = std::time::Duration::from_millis(400); // TODO: find solution to know when change has been done
        //    std::thread::sleep(millis);
        //}
    }

    let _ = con.set(
        format!("/pl/{}/{}", config.client_id, config.laser_id),
        format!("[]"),
    )?;
    Ok(())
}