///
/// Configure udev:
/// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
///
mod redis_ctrl;
mod conf;
mod errors;
mod point;
mod transformer;

use helios_dac::{
    self,
    NativeHeliosDacController,
    NativeHeliosDac,
    DeviceStatus,
    Frame,
};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use redis_ctrl::{RedisCtrl,Order};
use conf::Conf;
use errors::{LJError,LJResult};
use point::Point;
use transformer::{Transformers,Translate,Replicate};
use log::{LevelFilter,info,/* warn, */ error};
use env_logger::Builder;

const DEFAULT_CONF_FILE : &str = "settings.toml";
const CENTER : (f32,f32) = (2000.0, 2000.0);

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

fn run_all() -> LJResult<()> {
    let filename = std::env::args().nth(1).unwrap_or_else(|| {
	DEFAULT_CONF_FILE.to_string()
    });
    
    let config = Conf::new(&filename);
    init_logging(&config);
    let config = config?;
    info!("*** Starting up ***");
    
    let mut rs = RedisCtrl::new(&config.redis_url)?;
    
    let running = Arc::new(AtomicBool::new(true));
    let r = running.clone();
    ctrlc::set_handler(move || {
        r.store(false, Ordering::SeqCst);
    })?;

    let mut device = get_helios_device()?;

    let transformers : Vec<Box<dyn Transformers>> = vec![
	Box::new(Translate::new(CENTER.0, CENTER.1)),
	Box::new(Replicate::Until(48))
    ];
        
    while running.load(Ordering::SeqCst) {
	let order = rs.get_order(config.laser_id)?;
	if order != Order::Draw {
	    info!("Order: {:?}", order);
	}

	let frame = get_next_frame(&config, 1000, &transformers,
				   &mut rs, order == Order::Black)?;
	
	while let Ok(DeviceStatus::NotReady) = device.status() {
	}
        device.write_frame(frame)?;
    }

    info!("Exiting, stoping device.");
    device.stop()?;
    Ok(())
}

fn init_logging(config: &LJResult<Conf>) {
    if let Ok(ref config) = config {
	if config.debug {
	    let mut builder = Builder::from_default_env();
	    builder
		.filter(None, LevelFilter::Info)
		.init();
	    info!("Debug mode enabled from configuration file");
	    return;
	}
    }
    info!("Logging level inherited from env");
    env_logger::init();
}

fn get_helios_device() -> LJResult<NativeHeliosDac> {
    let controller = NativeHeliosDacController::new()?;
    let devices = controller.list_devices()?;
    let Some(device) = devices.into_iter().next() else {
	return Err(Box::new(LJError::HeliosDeviceMissing));
    };
    let device = device.open()?;
    Ok(device)
}

fn get_next_frame(
    config: &Conf,
    speed: u32,
    transformers: &[Box<dyn Transformers>],
    rs: &mut RedisCtrl,
    _black: bool
) -> LJResult<Frame> {

    
    let line = rs.get(&format!("/pl/{}/0", config.laser_id))?;
    let mut line: Vec<Point> = line.into_iter().map(| tpl | tpl.into()).collect();
    for transformer in transformers {
	line = transformer.apply(&line);
    }

    info!("Line: {:?}", line);
    
    let line2 : Vec<helios_dac::Point> = line.into_iter().map(| p | p.into()).collect();
    Ok(Frame::new(speed, line2))
}