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

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

use super::{pipeline::SingleColorPipeline, rfactor_data::RFactorData};
use crate::write_log;

pub struct Rendering {
    swapchain: Arc<Swapchain>,
    pipeline: SingleColorPipeline,
    render_target: RenderTarget,
    images: Vec<Arc<Image>>,
    submit_info: SubmitInfo,
}

impl Rendering {
    pub fn new(
        device: Arc<Device>,
        queue: Arc<Mutex<Queue>>,
        swapchain: Arc<Swapchain>,
    ) -> Result<Self> {
        write_log("-> Rendering ctor: begin");
        let vk_images = swapchain.vk_images()?;
        write_log(format!(
            "-> Rendering ctor: vk images ({})",
            vk_images.len()
        ));
        let images = match swapchain.wrap_images(&vk_images, &queue) {
            Ok(images) => images,
            Err(err) => {
                write_log(format!("-> Rendering ctor: failed wrapper: {:?}", err));
                return Err(err);
            }
        };
        write_log("-> Rendering ctor: wrapped images");

        let render_target = RenderTarget::builder()
            .add_sub_pass(
                SubPass::builder(swapchain.width(), swapchain.height())
                    .set_prepared_targets(&images, 0, [0.0, 0.0, 0.0, 1.0], false)
                    .build(&device, &queue)?,
            )
            .build(&device)?;

        write_log("-> Rendering ctor: created render_target");

        Ok(Self {
            swapchain,
            pipeline: SingleColorPipeline::new(device, render_target.render_pass())?,
            render_target,
            images,
            submit_info: SubmitInfo::default(),
        })
    }

    pub fn swapchain(&self) -> &Arc<Swapchain> {
        &self.swapchain
    }

    pub fn render(
        &mut self,
        device: Arc<Device>,
        queue: Arc<Mutex<Queue>>,
        swapchain: Arc<Swapchain>,
        rfactor_data: &RFactorData,
    ) -> Result<VkSubmitInfo> {
        write_log(" ================== vulkan layer enter rendering ==================");

        let image_index = self.swapchain.current_index();

        let viewport = [VkViewport {
            x: 0.0,
            y: 0.0,
            width: swapchain.width() as f32,
            height: swapchain.height() as f32,
            minDepth: 0.0,
            maxDepth: 1.0,
        }];

        let scissor = [VkRect2D {
            offset: VkOffset2D { x: 0, y: 0 },
            extent: VkExtent2D {
                width: swapchain.width(),
                height: swapchain.height(),
            },
        }];

        let command_buffer = CommandBuffer::new_primary().build(device, queue)?;

        write_log(" ================== vulkan layer created command buffer ==================");

        {
            let mut recorder = command_buffer.begin(VkCommandBufferBeginInfo::new(
                VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
            ))?;

            write_log(" ================== vulkan layer begin command buffer ==================");

            self.render_target
                .begin(&recorder, VK_SUBPASS_CONTENTS_INLINE, image_index as usize);

            recorder.bind_pipeline(self.pipeline.pipeline())?;
            recorder.set_scissor(&scissor);
            recorder.set_viewport(&viewport);

            // // recorder.bind_vertex_buffer();

            self.render_target.end(&recorder);
        }

        self.submit_info = SubmitInfo::default()
            .add_wait_stage(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT)
            .add_command_buffer(command_buffer);

        Ok(self.submit_info.as_vk_submit())
    }
}