use anyhow::Result;
use vulkan_rs::prelude::*;

use std::{mem, sync::Arc};

use super::rendering::PositionOnlyVertex;

pub struct SingleColorPipeline {
    pipeline: Arc<Pipeline>,
    descriptor_layout: Arc<DescriptorSetLayout>,
}

impl SingleColorPipeline {
    pub fn new(device: Arc<Device>, renderpass: &Arc<RenderPass>) -> Result<Self> {
        let vertex_shader = ShaderModule::from_slice(
            device.clone(),
            include_bytes!("shader/single_color.vert.spv"),
            ShaderType::Vertex,
        )?;
        let fragment_shader = ShaderModule::from_slice(
            device.clone(),
            include_bytes!("shader/single_color.frag.spv"),
            ShaderType::Fragment,
        )?;

        let descriptor_layout = DescriptorSetLayout::builder()
            .add_layout_binding(
                0,
                VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                VK_SHADER_STAGE_FRAGMENT_BIT,
                0,
            )
            .build(device.clone())?;

        let pipeline_layout = PipelineLayout::builder()
            .add_descriptor_set_layout(&descriptor_layout)
            .build(device.clone())?;

        let pipeline = Pipeline::new_graphics()
            .set_vertex_shader(
                vertex_shader.clone(),
                vec![VkVertexInputBindingDescription {
                    binding: 0,
                    stride: mem::size_of::<PositionOnlyVertex>() as u32,
                    inputRate: VK_VERTEX_INPUT_RATE_VERTEX,
                }],
                vec![
                    // position
                    VkVertexInputAttributeDescription {
                        location: 0,
                        binding: 0,
                        format: VK_FORMAT_R32G32B32A32_SFLOAT,
                        offset: 0,
                    },
                ],
            )
            .set_fragment_shader(fragment_shader.clone())
            .input_assembly(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, false)
            .default_depth_stencil(false, false)
            .default_color_blend(vec![VkPipelineColorBlendAttachmentState::default()])
            .default_rasterization(VK_CULL_MODE_NONE, VK_FRONT_FACE_COUNTER_CLOCKWISE)
            .default_multisample(VK_SAMPLE_COUNT_1_BIT)
            .build(device, &pipeline_layout, &renderpass, 0)?;

        Ok(Self {
            descriptor_layout,
            pipeline,
        })
    }

    pub fn pipeline(&self) -> &Arc<Pipeline> {
        &self.pipeline
    }

    pub fn descriptor_layout(&self) -> &Arc<DescriptorSetLayout> {
        &self.descriptor_layout
    }
}