use winit::{window::Window, dpi::PhysicalSize};

mod buffers; use buffers::{NodeBuffer, BrickBuffer, UniformBuffer, RasterBuffer, Vertex};
pub mod camera; use camera::Camera;


pub struct Renderer {
    surface: wgpu::Surface,
    device: wgpu::Device,
    queue: wgpu::Queue,
    swapchain_desc: wgpu::SwapChainDescriptor,
    swapchain: wgpu::SwapChain,
    pipeline: wgpu::RenderPipeline,
    // Buffers
    raster_buffer: RasterBuffer,
    uniform_buffer: UniformBuffer,
    node_buffer: NodeBuffer,
    brick_buffer: BrickBuffer,
    // Camera
    pub camera: Camera,
}

impl Renderer {

    fn create_swapchain(adapter: &wgpu::Adapter, device: &wgpu::Device, surface: &wgpu::Surface, size: PhysicalSize<u32>) -> (wgpu::SwapChainDescriptor, wgpu::SwapChain) {
        let swapchain_desc = wgpu::SwapChainDescriptor {
            usage: wgpu::TextureUsage::RENDER_ATTACHMENT, // render to screen
            format: adapter.get_swap_chain_preferred_format(&surface),
            width: size.width,
            height: size.height,
            present_mode: wgpu::PresentMode::Mailbox, // Fifo = Vsync
        };
        let swapchain = device.create_swap_chain(&surface, &swapchain_desc);
        (swapchain_desc, swapchain)
    }

    fn create_pipeline(device: &wgpu::Device, swapchain_desc: &wgpu::SwapChainDescriptor, bind_group_layouts: &[&wgpu::BindGroupLayout]) -> wgpu::RenderPipeline{
        // Pipeline stuff
        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("Render Pipeline Layout"),
            bind_group_layouts: bind_group_layouts,
            push_constant_ranges: &[],
        });
        let vert_state = wgpu::VertexState { //vert
            module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.vert.spv")),
            entry_point: "main",
            buffers: &[Vertex::desc()],
        };
        let frag_state = wgpu::FragmentState { // frag
            module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.frag.spv")),
            entry_point: "main",
            targets: &[wgpu::ColorTargetState {
                format: swapchain_desc.format,
                alpha_blend: wgpu::BlendState::REPLACE,
                color_blend: wgpu::BlendState::REPLACE,
                write_mask: wgpu::ColorWrite::ALL,
            }],
        };
        let prim_state = wgpu::PrimitiveState { // primitive
            topology: wgpu::PrimitiveTopology::TriangleList,
            strip_index_format: None,
            front_face: wgpu::FrontFace::Cw,
            cull_mode: wgpu::CullMode::Back,
            polygon_mode: wgpu::PolygonMode::Fill,
        };
        let multisample_state = wgpu::MultisampleState { // multisample
            count: 1,
            mask: !0,
            alpha_to_coverage_enabled: false,
        };

        // Create pipeline
        device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("Render Pipeline"), 
            layout: Some(&pipeline_layout),
            vertex: vert_state, 
            fragment: Some(frag_state),
            primitive: prim_state,
            depth_stencil: None,
            multisample: multisample_state,
        })
    }
    
    pub async fn new(window: &Window) -> Self {

        // Create surface and pick device
        let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
        let surface = unsafe { instance.create_surface(window) };

        // Pick adapter (physical gpu)
        let adapter_options = wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, compatible_surface: Some(&surface) };
        let adapter = instance.request_adapter(&adapter_options).await.unwrap();
        println!("Adapter: {}", adapter.get_info().name);

        // Pick device (logical gpu) from adapter 
        let device_desc = wgpu::DeviceDescriptor { features: wgpu::Features::empty(), limits: wgpu::Limits::default(), label: None };
        let (device, queue) = adapter.request_device(&device_desc, None).await.unwrap();

        // Create swapchain
        let (swapchain_desc, swapchain) = Self::create_swapchain(&adapter, &device, &surface, window.inner_size());

        // Cam
        let aspect = swapchain_desc.width as f32 / swapchain_desc.height as f32;
        let camera = Camera::new(aspect, 60.0);

        // Buffers
        let uniform_buffer = UniformBuffer::new(&device);
        let raster_buffer = RasterBuffer::new(&device);
        
        let mut node_buffer = NodeBuffer::new(&device);
        node_buffer.write(&queue);

        let mut brick_buffer = BrickBuffer::new(&device);
        brick_buffer.write(&queue, 0);
        brick_buffer.write(&queue, 1);

        // Pipeline
        let pipeline = Self::create_pipeline(&device, &swapchain_desc, &[&uniform_buffer.bind_layout, &node_buffer.bind_layout, &brick_buffer.bind_layout]);

        // Save values in app
        println!("Initialized");
        Self { surface, device, queue, swapchain_desc, swapchain, pipeline, raster_buffer, uniform_buffer, node_buffer, brick_buffer, camera }
    }

    pub fn resize(&mut self, new_size: Option<PhysicalSize<u32>>) {
        if let Some(size) = new_size {
            // Minimized or manually resized to 0
            if size.width == 0 || size.height == 0 { return }
            // Recreate swapchain
            self.swapchain_desc.width = size.width;
            self.swapchain_desc.height = size.height;
            // Update camera
            self.camera.set_aspect(size.width as f32 / size.height as f32);
        }
        // Recreate swapchain
        self.swapchain = self.device.create_swap_chain(&self.surface, &self.swapchain_desc);
    }

    pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {

        // Update uniform buffer
        self.uniform_buffer.values.update(&self.camera);
        self.queue.write_buffer(&self.uniform_buffer.buffer, 0, bytemuck::cast_slice(&[self.uniform_buffer.values]));

        // Get next frame to render to
        let frame = self.swapchain.get_current_frame()?.output;

        // Create encoder that will build command buffer for us
        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"),});

        // Create render pass
        {
            let ops = wgpu::Operations {
                // Clear command
                load: wgpu::LoadOp::Clear(wgpu::Color {r: 0.1, g: 0.2, b: 0.3, a: 1.0,}),
                // Store command
                store: true,
            };

            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { 
                label: Some("Render Pass"),
                color_attachments: &[ wgpu::RenderPassColorAttachmentDescriptor { attachment: &frame.view, resolve_target: None, ops } ],
                depth_stencil_attachment: None,
            });

            // Data
            render_pass.set_pipeline(&self.pipeline);
            render_pass.set_bind_group(0, &self.uniform_buffer.bind_group, &[]);
            render_pass.set_bind_group(1, &self.node_buffer.bind_group, &[]);
            render_pass.set_bind_group(2, &self.brick_buffer.bind_group, &[]);
            // Vertices and indices
            render_pass.set_vertex_buffer(0, self.raster_buffer.vertex_buffer.slice(..));
            render_pass.set_index_buffer(self.raster_buffer.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
            render_pass.draw_indexed(0..self.raster_buffer.index_len, 0, 0..1);
        }

        // Submit encoder (command buffer)
        self.queue.submit(std::iter::once(encoder.finish()));

        // Return ok
        Ok(())
    }
}