extern crate vrtue;
use vrtue::*;

extern crate env_logger;
#[macro_use] extern crate gfx;
extern crate gl;
#[macro_use] extern crate log;
extern crate piston_window;

use gfx::Device;
use gfx::traits::FactoryExt;
use piston_window::{PistonWindow, Window, WindowSettings};

pub type ColorFormat = gfx::format::Srgba8;
//pub type DepthFormat = gfx::format::DepthStencil;

gfx_defines!{
    vertex Vertex {
        pos: [f32; 2] = "a_pos",
        color: [f32; 3] = "a_color",
    }

    pipeline pipe {
        vbuf: gfx::VertexBuffer<Vertex> = (),
        pixcolor: gfx::RenderTarget<ColorFormat> = "pixcolor",
    }
}

const TRIANGLE: [Vertex; 3] = [
    Vertex { pos: [ -0.5, -0.5 ], color: [1.0, 0.0, 0.0] },
    Vertex { pos: [  0.5, -0.5 ], color: [0.0, 1.0, 0.0] },
    Vertex { pos: [  0.0,  0.5 ], color: [0.0, 0.0, 1.0] }
];

fn main() {
    env_logger::init().expect("env logger");
    let mut vr = vr::VR::new().expect("VR init");
    let render_size = vr.recommended_render_target_size();

    let mut window: PistonWindow =
        WindowSettings::new("Hello Virtual World!", [512; 2])
            .exit_on_esc(true)
            .vsync(false)
            //.vsync(true)
        .build().expect("Building Window");

    /*
    let _sysleft = system.projection_matrix(vr::Eye::Left, 0.01, 1000.0);
    let _eyeleft = system.eye_to_head_transform(vr::Eye::Left);
    let _sysright = system.projection_matrix(vr::Eye::Right, 0.01, 1000.0);
    let _eyeright = system.eye_to_head_transform(vr::Eye::Right);
     */
    let pso = window.factory.create_pipeline_simple(VERTEX_SHADER_SRC,
                                                    FRAGMENT_SHADER_SRC,
                                                    pipe::new())
        .expect("create pipeline");

    let (tex_left, tgt_left) = vr::create_eyebuffer(&mut window.factory, render_size)
        .expect("create left renderbuffer");
    let (tex_right, tgt_right) = vr::create_eyebuffer(&mut window.factory, render_size)
        .expect("create right renderbuffer");
    let (vertex_buffer, slice) = window.factory.create_vertex_buffer_with_slice(&TRIANGLE, ());

    let pipe_monitor = pipe::Data {
        vbuf: vertex_buffer.clone(),
        pixcolor: window.output_color.clone(),
    };
    let pipe_left = pipe::Data {
        vbuf: vertex_buffer.clone(),
        pixcolor: tgt_left,
    };
    let pipe_right = pipe::Data {
        vbuf: vertex_buffer.clone(),
        pixcolor: tgt_right,
    };

    let mut frame = 0;
    window.window.swap_buffers(); frame += 1; // To contain setup calls to Frame 0 in apitrace
    'main:
    //while let Some(_) = window.next() {
    loop {
        info!("Frame #{}", frame);
        let _now = std::time::SystemTime::now();

        // Get the current sensor state
        let _poses = vr.poses();
        trace!("\t{:?} got pose", _now.elapsed());
        if frame % 90 == 0 {
            warn!("\t#{}: poses: {:?}\n", frame, _poses.poses[0]);
        }
        frame += 1;

        for pass in [(Some((vr::Eye::Left, &tex_left)),   &pipe_left),
                     (Some((vr::Eye::Right, &tex_right)), &pipe_right),
                     (None,                               &pipe_monitor),]
            .into_iter() {
                info!("\tpass for eye: {:?}", pass.0);
                window.encoder.clear(&pass.1.pixcolor, [0.1, 0.5, 0.1, 1.0]);
                window.encoder.draw(&slice, &pso, pass.1);
                window.encoder.flush(&mut window.device);

                // Submit eye textures
                if let Some((eye, tex)) = pass.0 {
                    vr.submit(eye, tex);
                    trace!("\t\t{:?} submit {:?}", _now.elapsed(), eye);
                } else {
                    window.window.swap_buffers();
                }
            }
        window.device.cleanup();

        // handle window events
        while let Some(ev) = window.poll_event() {
            match ev {
                piston_window::Input::Text(_) => break 'main,
                _ => debug!("\t{:?}", ev)
            }
        }
    }

    info!("shutting down");
}

/*
fn gl_debug(device: &mut gfx_device_gl::Device, msg: &'static [u8; 6]) {
    unsafe {
        device.with_gl_naked(|gl| {
            gl.DebugMessageInsert(gl::DEBUG_SOURCE_APPLICATION,
                                  gl::DEBUG_TYPE_OTHER,
                                  0,
                                  gl::DEBUG_SEVERITY_LOW,
                                  msg.len() as i32,
                                  ::std::mem::transmute(msg));
        });
    }
}

fn check_err(device: &mut gfx_device_gl::Device) {
    unsafe {
        device.with_gl_naked(|gl| {
            let err: gl::types::GLenum = gl.GetError();
            if err != gl::NO_ERROR {
                panic!("GL Error! {:?}", err);
            }
        });
    }
}
*/

const VERTEX_SHADER_SRC: &'static [u8] = br#"
    #version 140

    in vec2 a_pos;
    in vec3 a_color;
    out vec3 v_color;

    void main() {
        v_color = a_color;
        gl_Position = vec4(a_pos, 0.0, 1.0);
    }
"#;

const FRAGMENT_SHADER_SRC: &'static [u8] = br#"
    #version 140

    in vec3 v_color;
    out vec4 pixcolor;

    void main() {
        pixcolor = vec4(v_color, 1.0);
    }
"#;