mod vk;

use wgpu::*;

fn iris_features() -> Features {
    Features::empty()
}

const IRIS_MAX_BUFFER_SIZE: u64 = 1 << 30;

fn iris_limits() -> Limits {
    Limits {
        max_buffer_size: IRIS_MAX_BUFFER_SIZE,
        max_compute_workgroup_storage_size: 0,
        max_compute_invocations_per_workgroup: 0,
        max_compute_workgroup_size_x: 0,
        max_compute_workgroup_size_y: 0,
        max_compute_workgroup_size_z: 0,
        max_compute_workgroups_per_dimension: 0,
        ..Default::default()
    }
}

fn main() {
    vk::report();

    let instance = Instance::new(InstanceDescriptor {
        backends: Backends::from_env().unwrap_or(Backends::PRIMARY),
        ..InstanceDescriptor::new_without_display_handle()
    });

    let adapters = pollster::block_on(instance.enumerate_adapters(Backends::all()));
    println!("adapters: {}", adapters.len());
    for adapter in &adapters {
        let info = adapter.get_info();
        println!(
            "  {:?} {} ({:?})",
            info.backend, info.name, info.device_type
        );
        let down = adapter.get_downlevel_capabilities();
        let limits = adapter.limits();
        println!(
            "    compute shaders: {}  (shader model {:?})",
            down.flags.contains(DownlevelFlags::COMPUTE_SHADERS),
            down.shader_model
        );
        println!(
            "    max compute invocations/workgroup: {}, workgroup storage: {} bytes",
            limits.max_compute_invocations_per_workgroup, limits.max_compute_workgroup_storage_size
        );
    }

    let Some(adapter) = pollster::block_on(instance.request_adapter(&RequestAdapterOptions {
        power_preference: PowerPreference::default(),
        compatible_surface: None,
        force_fallback_adapter: false,
        ..Default::default()
    }))
    .ok() else {
        println!("\nNO ADAPTER");
        std::process::exit(1);
    };

    let info = adapter.get_info();
    println!(
        "\nchosen: {:?} {} ({:?})",
        info.backend, info.name, info.device_type
    );
    println!("driver: {} {}", info.driver, info.driver_info);

    let have = adapter.features();
    println!("\nfeatures iris requires:");
    let mut missing = Features::empty();
    for f in iris_features().iter() {
        let ok = have.contains(f);
        println!(
            "  {:60} {}",
            format!("{f:?}"),
            if ok { "yes" } else { "NO" }
        );
        if !ok {
            missing |= f;
        }
    }

    let limits = adapter.limits();
    println!("\nlimits iris requires:");
    println!(
        "  {:52} want {:>7}  have {:>7}  {}",
        "max_buffer_size",
        IRIS_MAX_BUFFER_SIZE,
        limits.max_buffer_size,
        if limits.max_buffer_size >= IRIS_MAX_BUFFER_SIZE {
            "ok"
        } else {
            "TOO SMALL"
        }
    );

    let wanted = iris_limits();
    match pollster::block_on(adapter.request_device(&DeviceDescriptor {
        required_features: iris_features(),
        required_limits: wanted,
        ..Default::default()
    })) {
        Ok(_) => println!("\nIRIS DEVICE: ok"),
        Err(e) => println!("\nIRIS DEVICE: FAILED -- {e}"),
    }

    if !missing.is_empty() {
        println!("\nmissing features: {missing:?}");
    }
}