extern crate wgpu_engine;
extern crate winit;

use wgpu_engine::renderer::renderer_builder::RendererBuilder;
use wgpu_engine::renderer::shader::Shader;
use wgpu_engine::ShaderKind;
use winit::dpi::LogicalSize;
use winit::event::Event;
use winit::event::WindowEvent;
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;
use wgpu_engine::math::mat4::Mat4;
use wgpu_engine::renderer::mesh::Mesh;
use wgpu_engine::renderer::Renderer;

#[repr(C)]
pub struct Vertex {
    position: [f32; 4],
    uv: [f32; 2],
    normal: [f32; 3]
}

impl Vertex {
    pub fn new(position: [f32; 3], uv: [f32; 2], normal: [f32; 3]) -> Vertex {
        Vertex {
            position: [position[0], position[1], position[2], 1.0],
            uv,
            normal
        }
    }
}

#[repr(C)]
struct UniformBuffer {
    projection: Mat4,
    view: Mat4,
    model: Mat4
}

fn main() {
    let mut event_loop = EventLoop::new();
    let window = WindowBuilder::new()
        .with_title("Engine")
        .with_inner_size(LogicalSize::new(640, 480))
        .with_visible(true)
        .build(&event_loop).unwrap();

    let mut renderer: Renderer<_, Vertex> = RendererBuilder::new(&window)
        .add_vertex_shader(&Shader::new_from_source(include_str!("../shaders/vert.glsl"), ShaderKind::Vertex))
        .add_fragment_shader(&Shader::new_from_source(include_str!("../shaders/frag.glsl"), ShaderKind::Fragment))
        .set_culling(wgpu_engine::wgpu::FrontFace::Ccw, wgpu_engine::wgpu::CullMode::Back)
        .add_vertex_attribute(0, wgpu_engine::wgpu::VertexFormat::Float4)
        .add_vertex_attribute(1, wgpu_engine::wgpu::VertexFormat::Float2)
        .add_vertex_attribute(2, wgpu_engine::wgpu::VertexFormat::Float3)
        .add_texture(1)
        .set_sampler_location(2)
        .set_uniform_location(0)
        .build().unwrap();

    let projection = Mat4::perspective(std::f32::consts::FRAC_PI_2, 640.0 / 480.0, 100.0, 0.1);
    let view = Mat4::identity();
    let model = Mat4::identity();

    renderer.fill_uniform_buffer(
        &UniformBuffer {
            projection,
            view,
            model
        }
    );

    event_loop.run(move |event, _, control_flow| {
        *control_flow = ControlFlow::Poll;
        match event {
            Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => *control_flow = ControlFlow::Exit,
            Event::MainEventsCleared => window.request_redraw(),
            Event::RedrawRequested(_) => {

            },
            _ => ()
        }
    });
}