use std::ffi::CString;

pub enum LayersSelector<'a> {
    Nothing,
    SpecificLayers(Vec<&'a str>),
    All,
}

pub fn use_layers(entry: &ash::Entry, selector: LayersSelector) -> Vec<CString> {
    let layers_available = get_layers_available(entry)
        .iter()
        .filter_map(|layer| {
            layer
                .layer_name_as_c_str()
                .and_then(|layer_name| Ok(CString::from(layer_name)))
                .ok()
        })
        .collect::<Vec<_>>();

    match selector {
        LayersSelector::Nothing => Vec::new(),
        LayersSelector::SpecificLayers(layers) => select_layers(&layers_available, &layers),
        LayersSelector::All => layers_available,
    }
}

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

fn select_layers(layers_available: &Vec<CString>, layers_to_select: &[&str]) -> Vec<CString> {
    layers_to_select
        .iter()
        .filter_map(|layer_name| {
            if layers_available.iter().any(|layer_available| {
                layer_available
                    .to_str()
                    .and_then(|layer_available| Ok(layer_available.eq(*layer_name)))
                    .unwrap_or(false)
            }) {
                CString::new(*layer_name).ok()
            } else {
                None
            }
        })
        .collect::<Vec<_>>()
}