extern crate glium;
extern crate model_converter;

use std::env;
use std::process::exit;

use glium::Display;
use glium::glutin;
use glium::glutin::{
    EventsLoop,
    WindowBuilder,
};

use glium::glutin::Event;
use glium::glutin::WindowEvent;
use glium::glutin::VirtualKeyCode;


use model_converter::math::vector::Vector3;
use model_converter::parser::parse_into_model;
use model_converter::renderer::Renderer;
use model_converter::renderer::controls::OrbitControls;
use model_converter::renderer::camera::Camera;
use model_converter::model::Model;

fn main() {

    let mut model = Model::new();
    let mut inputs = vec![];
    let mut iterator = env::args();

    // Skip the name of the program
    iterator.next();

    while let Some(argument) = iterator.next() {
        match argument.as_ref() {
            "-i" | "--input" => {
                if let Some(path) = iterator.next() {
                    inputs.push(path);
                } else {
                    eprintln!("Expecting path after {}", argument);
                    exit(-1);
                }
            },

            arg => {
                eprintln!("Argument unkown: {}", arg);
                exit(-1);
            },
        }
    }

    for input in inputs {
        if let Err(e) = parse_into_model(&input, &mut model) {
            eprintln!("Error while parsing file: {}", e);
            exit(1);
        }
    }

    model.center_and_scale();

    let mut events_loop = EventsLoop::new();
    let window = WindowBuilder::new().with_visibility(false);
    let context = glutin::ContextBuilder::new().with_depth_buffer(24);
    let display = Display::new(window, context, &events_loop).unwrap();
    let mut renderer = Renderer::new(display);

    let mut closed = false;

    renderer.add_model(&model);

    let mut camera = Camera::new(
        Vector3::new( 0.0, 0.0, 0.0),
        Vector3::new( 0.0, 0.0, 0.0),
        Vector3::new( 0.0, 1.0, 0.0),
    );

    let mut controls = OrbitControls::around(&model, &mut camera);

    renderer.show();

    while !closed {

        events_loop.poll_events(|ev| {

            use model_converter::renderer::controls::Controls;
            controls.manage_event(&ev, &mut camera);

            match ev {
                // Close window
                Event::WindowEvent {
                    event: WindowEvent::Closed, ..
                } => closed = true,

                // Escape key
                Event::WindowEvent {
                    event: WindowEvent::KeyboardInput {
                        input: glutin::KeyboardInput {
                            virtual_keycode: Some(VirtualKeyCode::Escape), ..
                        }, ..
                    }, ..
                } => closed = true,

                _ => (),
            }
        });


        let mut target = renderer.draw();
        renderer.render(&camera, &mut target);
        target.finish().unwrap();

    }
}