pub mod instance;
pub mod render;

pub mod frame_counter;

pub use instance::EngineInstance;
use instance::{window::Resolution, Window};

use ash::vk;

pub const WINDOW_WIDTH: u32 = 1280;
pub const WINDOW_HEIGHT: u32 = 720;

pub const DEFAULT_RES: Resolution = Resolution {
    width: WINDOW_WIDTH,
    height: WINDOW_HEIGHT,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    env_logger::init();

    let window = Window::init(DEFAULT_RES.clone())?;
    let mut instance = EngineInstance::init(&window)?;

    render::render_loop(&window, &mut instance, move |e| {
        let next_image = (e.swapchain.current_image + 1) % e.swapchain.amount_of_images as usize;

        unsafe {
            e.device
                .wait_for_fences(
                    &[e.swapchain.may_begin_drawing[e.swapchain.current_image]],
                    true,
                    std::u64::MAX,
                )
                .expect("fence-waiting");

            e.device
                .reset_fences(&[e.swapchain.may_begin_drawing[e.swapchain.current_image]])
                .expect("resetting fences");
        }

        let (image_index, _) = unsafe {
            e.swapchain
                .swapchain_loader
                .acquire_next_image(
                    e.swapchain.swapchain,
                    std::u64::MAX,
                    e.swapchain.image_available[e.swapchain.current_image],
                    vk::Fence::null(),
                )
                .expect("image acquisition trouble")
        };

        let semaphores_available = [e.swapchain.image_available[e.swapchain.current_image]];
        let waiting_stages = [vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT];
        let semaphores_finished = [e.swapchain.rendering_finished[e.swapchain.current_image]];
        let commandbuffers = [e.commandbuffers[image_index as usize]];
        let submit_info = [vk::SubmitInfo::default()
            .wait_semaphores(&semaphores_available)
            .wait_dst_stage_mask(&waiting_stages)
            .command_buffers(&commandbuffers)
            .signal_semaphores(&semaphores_finished)];

        let queue = e.queues.graphics_queue.as_ref().unwrap().queue;
        unsafe {
            e.device
                .queue_submit(
                    queue,
                    &submit_info,
                    e.swapchain.may_begin_drawing[e.swapchain.current_image],
                )
                .expect("queue submission");
        };

        let swapchains = [e.swapchain.swapchain];
        let indices = [image_index];
        let present_info = vk::PresentInfoKHR::default()
            .wait_semaphores(&semaphores_finished)
            .swapchains(&swapchains)
            .image_indices(&indices);
        unsafe {
            e.swapchain
                .swapchain_loader
                .queue_present(queue, &present_info)
                .expect("queue presentation");
        };

        let frameid = e.framecount.frame_count();
        let frametime = e.framecount.new_frame();
        println!("frame {}: {} ms", frameid, frametime.as_secs_f32() * 1000.0);

        e.swapchain.current_image = next_image;
    })?;

    Ok(())
}