///
/// Configure udev:
/// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
///

mod redis_ctrl;

use helios_dac::{Frame,
		 Point,
		 DeviceStatus,
		 // Coordinate,
		 Color};
use helios_dac::NativeHeliosDacController;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;

use redis_ctrl::{RedisCtrl,Order};

const CENTER : (u16,u16) = (2000, 2000);


pub fn main() -> Result<(), Box<dyn std::error::Error>> {
    let running = Arc::new(AtomicBool::new(true));
    let r = running.clone();

    ctrlc::set_handler(move || {
        r.store(false, Ordering::SeqCst);
    }).expect("Error setting Ctrl-C handler");
    
    let mut rs = match RedisCtrl::new() {
	Ok(rs) => rs,
	Err(err) => {
	    println!("Unable to connect to redis: {:?}", err);
	    return Ok(())
	}
    };

    
    let controller = NativeHeliosDacController::new()?;
    let devices = controller.list_devices()?;
    
    let Some(device) = devices.into_iter().next() else {
	println!("Unable to find an helios device");
	return Ok(());
    };
    
    let mut device = device.open()?;
    
    while running.load(Ordering::SeqCst) {
	let order = rs.get_order(0)?;
	if order != Order::Draw {
	    println!("{:?}", order);
	}

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

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

fn get_next_frame(
    speed: u32,
    rs: &mut RedisCtrl
) -> Result<Frame, Box<dyn std::error::Error>> {

    let line = rs.get("/pl/0/0")?;
    let line : Vec<Point> = line.iter()
	.map(tuple_to_point)
	.collect();
    
    let mut line2 = vec![];
    while line2.len() < 48 {
	for p in &line {
	    line2.push(*p);
	}
    }
    
    Ok(Frame::new(speed, line2))
}

fn tuple_to_point(tpl: &(f32,f32,u32)) -> Point {
    let (x, y, col) = tpl;
    
    let r = (col >> 16) as u8 ;
    let g = ((col >> 8) & 255) as u8 ;
    let b = (col & 255) as u8 ;
    
    let x = CENTER.0 + *x as u16;
    let y = CENTER.1 + *y as u16;

    if x >= 4096 || y >= 4096 {
	println!("WARN: coordinate out of range: {} {}", x, y);
    }
    let x = x.clamp(0, 4095);
    let y = y.clamp(0, 4095);
    
    Point {
        coordinate: (x, y).into(),
        color: Color::new(r, g, b),
        intensity: 0xFF
    }
}