use bevy_app::App;
use bevy_ecs::resource::Resource;
use engine_window::raw_handle::WindowWrapper;
use std::sync::Arc;
use vulkano::image::view::ImageView;
use vulkano::image::{Image, ImageUsage};
use vulkano::pipeline::graphics::viewport::Viewport;
use vulkano::swapchain::{Surface, Swapchain, SwapchainCreateInfo};
use vulkano::sync::{self, GpuFuture};
use vulkano::{Validated, VulkanError};
use winit::window::Window;

use crate::{VulkanDevice, VulkanInstance};

#[derive(Resource)]
pub struct WindowRenderContext {
    pub window: Arc<Window>,
    pub swapchain: Arc<Swapchain>,
    pub attachment_image_views: Vec<Arc<ImageView>>,
    pub viewport: Viewport,
    pub recreate_swapchain: bool,
    pub previous_frame_end: Option<Box<dyn GpuFuture + Send + Sync>>,
}

impl From<&App> for WindowRenderContext {
    fn from(app: &App) -> Self {
        let world = app.world();
        let window_handle = world
            .get_resource::<WindowWrapper>()
            .expect("Failed to find window handle");
        let vulkan_instance = world
            .get_resource::<VulkanInstance>()
            .expect("Failed to find vulkan instance");
        let vulkan_device = world
            .get_resource::<VulkanDevice>()
            .expect("Failed to find vulkan device");

        let window_size = window_handle.0.inner_size();

        let surface = Surface::from_window(vulkan_instance.0.clone(), window_handle.0.clone())
            .expect("Failed to create surface");

        let (swapchain, images) = {
            let surface_capabilities = vulkan_device
                .0
                .physical_device()
                .surface_capabilities(&surface, Default::default())
                .unwrap();

            let (image_format, _) = vulkan_device
                .0
                .physical_device()
                .surface_formats(&surface, Default::default())
                .unwrap()[0];

            Swapchain::new(
                vulkan_device.0.clone(),
                surface,
                SwapchainCreateInfo {
                    // 2 because with some graphics driver, it crash on fullscreen because fullscreen need to min image to works.
                    min_image_count: surface_capabilities.min_image_count.max(2),
                    image_format,
                    image_extent: window_size.into(),
                    image_usage: ImageUsage::COLOR_ATTACHMENT,
                    composite_alpha: surface_capabilities
                        .supported_composite_alpha
                        .into_iter()
                        .next()
                        .unwrap(),

                    ..Default::default()
                },
            )
            .unwrap()
        };

        let attachment_image_views = window_size_dependent_setup(&images);

        let viewport = Viewport {
            offset: [0.0, 0.0],
            extent: window_size.into(),
            depth_range: 0.0..=1.0,
        };

        let recreate_swapchain = false;
        let previous_frame_end = Some(sync::now(vulkan_device.0.clone()).boxed_send_sync());

        Self {
            window: window_handle.0.clone(),
            swapchain,
            attachment_image_views,
            viewport,
            recreate_swapchain,
            previous_frame_end,
        }
    }
}

impl WindowRenderContext {
    pub fn update_swapchain(&mut self) -> Result<(), Validated<VulkanError>> {
        if !self.recreate_swapchain {
            return Ok(());
        }

        let window_size = self.window.inner_size();
        let (new_swapchain, new_images) = self.swapchain.recreate(SwapchainCreateInfo {
            image_extent: window_size.into(),
            ..self.swapchain.create_info()
        })?;

        self.swapchain = new_swapchain;
        self.attachment_image_views = window_size_dependent_setup(&new_images);
        self.viewport.extent = window_size.into();
        self.recreate_swapchain = false;

        Ok(())
    }
}

fn window_size_dependent_setup(images: &[Arc<Image>]) -> Vec<Arc<ImageView>> {
    images
        .iter()
        .map(|image| ImageView::new_default(image.clone()).unwrap())
        .collect::<Vec<_>>()
}