use glutin;
use glutin::GlContext;
use std::sync::mpsc;
use std::thread;
use std::time;

mod gl;

fn main() {
    let start = time::Instant::now();

    let window_dims = glutin::dpi::LogicalSize::new(640.0, 480.0);
    let mut event_loop = glutin::EventsLoop::new();
    let gl_window = glutin::GlWindow::new(
        glutin::WindowBuilder::new()
            .with_title("Continuous event loop")
            .with_dimensions(window_dims),
        glutin::ContextBuilder::new()
            .with_gl(glutin::GlRequest::Specific(glutin::Api::OpenGl, (4, 5)))
            .with_gl_profile(glutin::GlProfile::Core),
        &event_loop,
    )
    .unwrap();

    #[derive(Debug)]
    struct TimedEvent {
        instant: time::Instant,
        event: glutin::Event,
    };

    let (timed_event_tx, timed_event_rx) = mpsc::channel::<TimedEvent>();

    let _guard = thread::spawn(move || {
        let mut should_keep_running = true;

        println!("{:?}", start.elapsed());

        unsafe {
            gl_window.make_current().unwrap();
        }

        println!("{:?}", start.elapsed());

        let gl = gl::Gl::load_with(|symbol| gl_window.get_proc_address(symbol) as *const _);

        println!("{:?}", start.elapsed());

        while should_keep_running {
            // Process input.
            for timed_event in timed_event_rx.try_iter() {
                let TimedEvent { instant, event } = timed_event;
                println!("{:?} {:?}", instant.elapsed(), event);

                use glutin::Event;
                match event {
                    Event::DeviceEvent { event, .. } => {
                        use glutin::DeviceEvent;
                        match event {
                            DeviceEvent::Key(keyboard_input) => {

                                if let Some(virtual_keycode) = keyboard_input.virtual_keycode {
                                    use glutin::VirtualKeyCode;
                                    match virtual_keycode {
                                        VirtualKeyCode::Escape => {
                                            should_keep_running = false;
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    _ => {}
                }
            }

            // Render.
            unsafe {
                gl.ClearColor(0.7, 0.8, 0.9, 1.0);
                gl.Clear(gl::COLOR_BUFFER_BIT);
            }

            // VSync.
            gl_window.swap_buffers().unwrap();
        }
    });

    event_loop.run_forever(|event| {
        match timed_event_tx.send(TimedEvent {
            instant: time::Instant::now(),
            event,
        }) {
            Ok(_) => glutin::ControlFlow::Continue,
            Err(_) => glutin::ControlFlow::Break,
        }
    })
}