use std::ffi::CString;

pub fn use_layers(
    entry: &ash::Entry,
    layers_to_select: Vec<&str>,
) -> Vec<CString> {
    let layers_available = get_layers_available(entry);

    log_layers_available(&layers_available);

    let selected_layers = select_layers(&layers_available, &layers_to_select);

    log_layers_wanted(&layers_to_select, &selected_layers);

    selected_layers
        .iter()
        .map(|sl| CString::new(sl.clone().as_bytes()).unwrap())
        .collect::<Vec<_>>()
}

fn get_layers_available(entry: &ash::Entry) -> Vec<ash::vk::LayerProperties> {
    unsafe { entry.enumerate_instance_layer_properties().unwrap_or_default() }
}

fn log_layers_available(layers_available: &[ash::vk::LayerProperties]) {
    log::info!("Available layers ({}):", layers_available.len());
    for l in layers_available {
        log::info!(
            "\t{:?}\tImplementation version: {}\tVulkan Version: {}\tDescription: {:?}",
            l.layer_name_as_c_str().unwrap_or_default(),
            l.implementation_version,
            print_version(l.spec_version),
            l.description_as_c_str().unwrap_or_default()
        );
    }
    log::info!(""); // Add blank line
}

fn select_layers(
    layers_available: &[ash::vk::LayerProperties],
    layers_to_select: &[&str],
) -> Vec<String> {
    layers_available
        .iter()
        .filter_map(|l| {
            let layer_name = l
                .layer_name_as_c_str()
                .unwrap_or_default()
                .to_string_lossy();
            layers_to_select
                .iter()
                .find(|&&ln| ln == layer_name)
                .map(|_| layer_name.into_owned())
        })
        .collect()
}

fn log_layers_wanted(layers_to_select: &[&str], selected_layers: &[String]) {
    log::info!("Layers wanted ({}):", layers_to_select.len());
    for ol in layers_to_select {
        let selected = selected_layers.iter().any(|sl| sl == ol);
        log::info!("\t{:?}\tSelected: {}", ol, selected);
    }
    log::info!(""); // Add blank line
}

pub fn print_version(version: u32) -> String {
    format!(
        "{}.{}.{}",
        ash::vk::api_version_major(version),
        ash::vk::api_version_minor(version),
        ash::vk::api_version_patch(version)
    )
}