#![allow(dead_code)]

struct Input<'a, T: USBKeyOut> {
    handlers: &'a mut [Box<dyn ProcessKeys<T>>],
    output: T,
}

impl<T: USBKeyOut> Input<'_, T> {

    fn handle_keys(&mut self) -> Result<(), String> {
        Ok(())
    }
}

trait ProcessKeys<T: USBKeyOut> {
    fn process_keys(&mut self, output: &mut T) -> ();
}

trait USBKeyOut {}

struct ToggleMacro<'a, T, F1: FnMut(&mut T)> {
    keycode: u32,
    on_toggle_on: F1,
    state: bool,
    phantom: core::marker::PhantomData<&'a T>,
}
impl<'a, T: USBKeyOut, F1: FnMut(&mut T)> ToggleMacro<'a, T, F1> {
    fn new(trigger: u32, on_toggle_on: F1) -> ToggleMacro<'a, T, F1> {
        ToggleMacro {
            keycode: trigger,
            on_toggle_on,
            state: false,
            phantom: core::marker::PhantomData,
        }
    }
}

impl<T: USBKeyOut, F1: FnMut(&mut T)> ProcessKeys<T>
    for ToggleMacro<'_, T, F1>
{
    fn process_keys(&mut self, output: &mut T) -> () {
        (self.on_toggle_on)(output);
    }
}

#[cfg(test)]
mod tests {

    #[allow(unused_imports)]
    use crate::{Input, ProcessKeys, ToggleMacro, USBKeyOut};

    struct KeyOutCatcher {
    }
    impl USBKeyOut for KeyOutCatcher {}

    #[test]
    fn test_toggle_macro() {
        use core::cell::RefCell;
        let down_counter = RefCell::new(0);
        let _up_counter = RefCell::new(0);
        let t = ToggleMacro::new(
            0xF0000u32,
            |_output: &mut KeyOutCatcher| {
                let mut dc = down_counter.borrow_mut();
                *dc += 1;
            },
        );
        let mut h = [Box::new(t) as Box<dyn ProcessKeys<KeyOutCatcher>>];

        let mut input = Input{handlers: &mut h, output: KeyOutCatcher{}};
        input.handle_keys().unwrap();
        assert!(*down_counter.borrow() == 1);
    }
}