use cyborg::shader;
use cyborg::storage::mesh::*;
use cyborg::{pass, viewport::*, Renderer};
use std::sync::Arc;
use winit::{
    event::*,
    event_loop::{ControlFlow, EventLoop},
    window::WindowBuilder,
};

fn main() {
    let event_loop = EventLoop::new();
    let window = WindowBuilder::new().build(&event_loop).unwrap();
    let mut viewport = pollster::block_on(WinitViewport::from_window(&window));
    let mut renderer = Renderer::new(viewport.device.clone(), viewport.queue.clone());

    let mut flycam = cyborg::camera::Flycam::new(0.002, 10.0, 0.25);
    let mut is_grabbed = false;

    let device = renderer.get_device();
    let layouts = renderer.get_layouts();

    let shader_store = Arc::new(shader::ShaderStore::new(device.to_owned()));

    let shaders_dir = std::env::current_dir().unwrap();
    let shaders_dir = shaders_dir.join("shaders/");
    let shader_watcher = shader::ShaderWatcher::new(shader_store.to_owned(), shaders_dir).unwrap();

    let mesh_forward = shader_watcher.add_file("mesh_forward.wgsl").unwrap();
    let mesh_skinning = shader_watcher.add_file("mesh_skinning.wgsl").unwrap();

    let mesh_shaders = pass::mesh::ShaderInfo {
        store: shader_store.clone(),
        forward: mesh_forward,
        skinning: mesh_skinning,
    };

    let mesh_pass = pass::mesh::MeshPass::new(
        device.to_owned(),
        layouts.to_owned(),
        viewport.get_info(),
        mesh_shaders,
    );
    let debug_pass =
        pass::debug::DebugPass::new(device.to_owned(), layouts.to_owned(), viewport.get_info());

    let example_vertices = vec![
        pass::mesh::Vertex {
            position: [-0.5, 0.5, 0.0],
            tan_frame: 0,
        },
        pass::mesh::Vertex {
            position: [0.5, 0.5, 0.0],
            tan_frame: 0,
        },
        pass::mesh::Vertex {
            position: [0.0, -0.5, 0.0],
            tan_frame: 0,
        },
    ];

    let example_vertices = AttrBuffer {
        id: mesh_pass.get_vertex_attr_id(),
        count: example_vertices.len(),
        data: bytemuck::cast_slice(&example_vertices).to_vec(),
    };

    let example_indices = vec![0u32, 1u32, 2u32];
    let example_indices = AttrBuffer {
        id: mesh_pass.get_index_attr_id(),
        count: example_indices.len(),
        data: bytemuck::cast_slice(&example_indices).to_vec(),
    };

    let mut example_mesh = MeshBuffer::default();
    example_mesh.attributes.push(example_vertices);
    example_mesh.attributes.push(example_indices);
    let example_mesh = mesh_pass.get_mesh_pool().load(example_mesh).unwrap();

    let meshes = mesh_pass.get_meshes().to_owned();

    let r = 8;
    let mut meshes_lock = meshes.write();
    for x in -r..r {
        for y in -r..r {
            for z in -r..r {
                let translation = glam::Vec3::new(x as f32, y as f32, z as f32);
                let transform = glam::Mat4::from_translation(translation);
                meshes_lock.transformed.push(cyborg::scene::TransformedMesh {
                    transform,
                    mesh: example_mesh.clone(),
                });
            }
        }
    }
    drop(meshes_lock);

    let frames_in_flight = renderer.get_frames_in_flight();
    let mut mesh_pass = pass::RenderPassBox::new(Arc::new(mesh_pass), frames_in_flight);
    let mut debug_pass = pass::RenderPassBox::new(Arc::new(debug_pass), frames_in_flight);

    event_loop.run(move |event, _, control_flow| match event {
        Event::RedrawRequested(_) => {
            match viewport.acquire() {
                Err(wgpu::SurfaceError::Lost) => viewport.resize(viewport.size),
                Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
                Err(e) => eprintln!("error: {:?}", e),
                Ok(_) => {
                    let mut passes: Vec<&mut dyn pass::RenderPassBoxTrait> = Vec::new();
                    passes.push(&mut mesh_pass);
                    passes.push(&mut debug_pass);
                    renderer.render(passes.as_mut_slice(), &viewport, &flycam.get_camera());
                    viewport.present();
                }
            }
        }
        Event::MainEventsCleared => {
            shader_watcher.watch();
            flycam.update();
            window.request_redraw();
        }
        Event::DeviceEvent { ref event, .. } => match event {
            DeviceEvent::MouseMotion { delta } => {
                if is_grabbed {
                    flycam.process_mouse(delta.0, delta.1);
                }
            }
            _ => {}
        },
        Event::WindowEvent {
            ref event,
            window_id,
        } if window_id == window.id() => match event {
            WindowEvent::KeyboardInput {
                input:
                    KeyboardInput {
                        virtual_keycode: Some(key),
                        state,
                        ..
                    },
                ..
            } => {
                if *state == ElementState::Pressed && *key == VirtualKeyCode::Escape {
                    if is_grabbed {
                        window.set_cursor_grab(false).unwrap();
                        window.set_cursor_visible(true);
                        is_grabbed = false;
                    }
                } else {
                    flycam.process_keyboard(*key, *state);
                }
            }
            WindowEvent::MouseInput {
                button: MouseButton::Left,
                state: ElementState::Pressed,
                ..
            } => {
                if !is_grabbed {
                    window.set_cursor_grab(true).unwrap();
                    window.set_cursor_visible(false);
                    is_grabbed = true;
                }
            }
            WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
            WindowEvent::Resized(physical_size) => {
                viewport.resize(*physical_size);
            }
            WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                viewport.resize(**new_inner_size);
            }
            _ => {}
        },
        _ => {}
    });
}