#[cfg(test)]                                                                                                                                               
//--------------------------------------------------------------------------------------------------
/* imports */

#[allow(unused_imports)]
use log::{debug, error, info, trace, warn};

use gfx_backend_vulkan as vk_back;

pub mod io;

pub mod subengine;
use subengine::SubenginePipeline;

pub mod controller;
use controller::Controller;

pub mod utils;
//use utils::Rect;

mod renderer;
//use renderer::Renderer;

//mod controller;
//use controller::Controller;

//use crate::engine::{
//    EngineController, 
//    TestEngine,
//};

pub enum Command {
    NoCommand,
    Stop,
    Color{
        r: f32,
        g: f32,
        b: f32,
        a: f32,
    },
}

pub enum Input {
    Close,
    Mouse{
        x: f64,
        y: f64,
    },
}


//--------------------------------------------------------------------------------------------------
/* functions */

/// The main function of the library
pub fn run() -> Result<(), &'static str> {
    use std::{
        iter,
        cell::RefCell,
    };

    use crate::{
        io::WinitWindow,
        renderer::Renderer,
        utils::Rect,
        subengine::{SubengineController, TestSubengine},
    };

    //creating windows
    let window1 = RefCell::new(WinitWindow::new("IV", Rect {w: 1280, h: 720}).unwrap());
    //let window2 = RefCell::new(WinitWindow::new("IV 2", Rect {w: 720, h: 480}).unwrap());

    //creating renderers
    let renderer1 = Renderer::<vk_back::Backend>::new(&mut iter::once(&window1)).unwrap();
    //let renderer2 = Renderer::<vk_back::Backend>::new(&mut iter::once(&window2)).unwrap();

    //creating subengines
    let (test_subengine1, _test_rx1) = TestSubengine::new("run1");
    let test_controller1 = SubengineController::new(test_subengine1);
    //let (test_subengine2, _test_rx2) = TestSubengine::new("run2");
    //let test_controller2 = SubengineController::new(test_subengine2);

    //preparing data
    let inputs = vec![&window1];
    let subengines = vec![vec![test_controller1/*, test_controller2*/]];
    let renderers = vec![(renderer1, &window1)/*, (renderer2, &window2)*/];

    //creating pipeline
    let subengine_pipeline = SubenginePipeline::new(inputs, subengines, renderers);

    //running controller
    let mut controller = Controller::new(vec![subengine_pipeline]);
    loop {
    //for _i in 0..40 {
        controller.run();
    }

    //let engine_pipelines = vec![
    //    EnginePipeline {
    //        Inputs: vec![0,1],
    //        Engines: vec![&color_engine],
    //        Renderers: vec![(1,0)],
    //    },
    //    EnginePipeline {
    //        Inputs: vec![3],
    //        Engines: vec![&color_engine],
    //        Renderers: vec![(1,1),(1,2),(1,3)],
    //}];

    //let controller = Controller::new(renderers, &windows, &windows, engine_pipelines);
    //controller.run();

    //Ok(())
    //let local_state = LocalState::default();
    
//    let color = [0.5, 0.0, 0.0, 1.0];
//    
//    loop {
//        for window in &mut windows {
//            match renderer.draw_clear_frame(window, color) {
//                Err(err) => println!("{}", err),
//                _ => (),
//    }}}
//
    Ok(())
}

//    let (input_tx, input_rx) = mpsc::channel();
//    let mut window_senders = HashMap::with_capacity(1);
//    window_senders.insert(1, input_tx);
//
//    let control_thread = RefCell::new(Some(thread::spawn(move || {
//        #[allow(unused_imports)]
//        use log::{debug, error, info, trace, warn};
//
//        let (cmd_tx, cmd_rx) = mpsc::channel();
//        let render_thread = thread::spawn(move || {
//            #[allow(unused_imports)]
//            use log::{debug, error, info, trace, warn};
//
//            let mut color = [0.0, 0.0, 0.0, 0.0];
//
//            loop 
//
//                //TODO manage errors
//                for window in windows {
//                    let _ = renderer.draw_clear_frame(&mut window, color);
//                }
//
//                match cmd_rx.try_recv().unwrap_or(Command::NoCommand) {
//                    Command::NoCommand => (),
//                    Command::Stop => {
//                        warn!("Stop render thread");
//                        return;
//                    },
//                    Command::Color{r, g, b, a} => {
//                        color = [r, g, b, a];
//                    },
//                }
//            }
//        });
//
//        loop {
//            match input_rx.recv().unwrap() {
//                 Input::Close => {
//                     cmd_tx.send(Command::Stop).unwrap();
//                     //TODO stop event_loop
//                     warn!("wait for render thread");
//                     render_thread.join().unwrap();
//                     warn!("Stop control thread");
//                     return;
//                 },
//                 Input::Mouse{x, y} => {
//                    let pos = Command::Color{
//                        r: (x/1280.0) as f32,
//                        g: (y/720.0) as f32,
//                        b: ((x/1280.0 + y/720.0)/2.0) as f32,
//                        a: 1.0,
//                    };
//                    cmd_tx.send(pos).unwrap();
//                 },
//           }
//        }
//    })));
//   
//    windows[0].event_loop.run(move |event, _, control_flow| {
//        #[allow(unused_imports)]
//        use log::{debug, error, info, trace, warn};
//
//        *control_flow = ControlFlow::Wait;
//
//        //TODO manage errors
//        let input_tx = window_senders.get(&1).unwrap();
//        match event {
//            Event::WindowEvent{window_id: _, event} => match event {
//                WindowEvent::CloseRequested => {
//                    input_tx.send(Input::Close).unwrap();
//                    let handle = control_thread.replace(None).unwrap();
//                    warn!("Wait for control thread");
//                    handle.join().unwrap();
//                    warn!("Stop input thread");
//                    *control_flow = ControlFlow::Exit;
//                },
//                WindowEvent::CursorMoved{position, ..} => {
//                    input_tx
//                        .send(Input::Mouse{
//                            x: position.x, 
//                            y: position.y})
//                        .unwrap();
//                },
//                _ => (),
//            }
//            _ => (),
//        }
//    });
//}
//
//mod tests {                                                                                          
//    #[test]                                                                                          
//    fn it_works() {                                                                                  
//        assert_eq!(2 + 2, 4);                                                                        
//    }                                                                                                
//}