use bevy_app::{App, AppLabel, Last, Plugin, SubApp};
use bevy_ecs::{
    schedule::{IntoScheduleConfigs, Schedule, ScheduleLabel, SystemSet},
    system::{Commands, Res},
    world::World,
};
use engine_vulkan::{
    VulkanCommandBufferAllocator, VulkanDescriptorSetAllocator, VulkanDevice, VulkanGraphicsQueue,
    VulkanInstance, VulkanMemoryAllocator,
};
use engine_window::raw_handle::WindowWrapper;
use window::WindowRenderPlugin;

pub mod window;

#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
pub enum RenderSystems {
    ManageViews,
    Prepare,
    Queue,
    Render,
    Present,
}

#[derive(ScheduleLabel, Debug, Hash, PartialEq, Eq, Clone, Default)]
pub struct Render;

impl Render {
    pub fn base_schedule() -> Schedule {
        use RenderSystems::*;

        let mut schedule = Schedule::new(Self);

        schedule.configure_sets((ManageViews, Prepare, Queue, Render, Present).chain());

        schedule
    }
}

#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, AppLabel)]
pub struct RenderApp;

pub struct RenderPlugin;

impl Plugin for RenderPlugin {
    fn build(&self, _app: &mut App) {}

    fn ready(&self, app: &App) -> bool {
        let world = app.world();

        world.get_resource::<WindowWrapper>().is_some()
            && world.get_resource::<VulkanInstance>().is_some()
            && world.get_resource::<VulkanDevice>().is_some()
            && world.get_resource::<VulkanGraphicsQueue>().is_some()
            && world.get_resource::<VulkanMemoryAllocator>().is_some()
            && world
                .get_resource::<VulkanCommandBufferAllocator>()
                .is_some()
            && world
                .get_resource::<VulkanDescriptorSetAllocator>()
                .is_some()
    }

    fn finish(&self, app: &mut App) {
        let mut render_app = SubApp::new();
        render_app.update_schedule = Some(Render.intern());
        render_app.add_schedule(Render::base_schedule());

        extract_app_resources(app.world_mut(), render_app.world_mut());

        app.insert_sub_app(RenderApp, render_app);

        app.add_plugins(WindowRenderPlugin);
    }
}

fn extract_app_resources(world: &mut World, render_world: &mut World) {
    let window_wrapper = world
        .get_resource::<WindowWrapper>()
        .expect("Failed to get WindowWrapper. Check is WindowPlugin is added before RenderPlugin.");

    let vulkan_instance = world.get_resource::<VulkanInstance>().expect(
        "Failed to get Vulkan instance. Check is VulkanPlugin is added before RenderPlugin.",
    );

    let vulkan_device = world
        .get_resource::<VulkanDevice>()
        .expect("Failed to get Vulkan device. Check is VulkanPlugin is added before RenderPlugin.");

    let vulkan_graphics_queue = world.get_resource::<VulkanGraphicsQueue>().expect(
        "Failed to get Vulkan graphics queue. Check is VulkanPlugin is added before RenderPlugin.",
    );

    let vulkan_memory_allocator = world
        .get_resource::<VulkanMemoryAllocator>()
        .expect("Failed to get Vulkan memory allocator. Check is VulkanPlugin is added before RenderPlugin.");

    let vulkan_command_buffer_allocator = world
        .get_resource::<VulkanCommandBufferAllocator>()
        .expect("Failed to get Vulkan command buffer allocator. Check is VulkanPlugin is added before RenderPlugin.");

    let vulkan_descriptor_set_allocator = world
        .get_resource::<VulkanDescriptorSetAllocator>()
        .expect("Failed to get Vulkan descriptor set allocator. Check is VulkanPlugin is added before RenderPlugin.");

    render_world.insert_resource(vulkan_instance.clone());
    render_world.insert_resource(vulkan_device.clone());
    render_world.insert_resource(vulkan_graphics_queue.clone());
    render_world.insert_resource(vulkan_memory_allocator.clone());
    render_world.insert_resource(vulkan_command_buffer_allocator.clone());
    render_world.insert_resource(vulkan_descriptor_set_allocator.clone());
    render_world.insert_resource(window_wrapper.clone());
}