torsh_ffi/

csharp.rs

//! C# P/Invoke bindings for ToRSh
//!
//! This module provides C#-compatible FFI bindings using Platform Invoke (P/Invoke).
//! C# can call these functions directly through DllImport attributes.

#![allow(dead_code)]

use crate::c_api::*;
use std::ffi::CStr;
use std::os::raw::{c_char, c_float, c_int, c_void};
use std::ptr;

/// C#-specific wrapper for tensor creation with marshaling hints
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_new(
    data: *const c_void,
    shape: *const c_int,
    ndim: c_int,
    dtype: c_int,
) -> *mut TorshTensor {
    // Convert C# int to usize for shape
    let shape_vec: Vec<usize> = std::slice::from_raw_parts(shape, ndim as usize)
        .iter()
        .map(|&x| x as usize)
        .collect();

    // Convert C# int to TorshDType
    let torsh_dtype = match dtype {
        0 => TorshDType::F32,
        1 => TorshDType::F64,
        2 => TorshDType::I32,
        3 => TorshDType::I64,
        4 => TorshDType::U8,
        _ => TorshDType::F32, // Default fallback
    };

    torsh_tensor_new(data, shape_vec.as_ptr(), shape_vec.len(), torsh_dtype)
}

/// C#-specific wrapper for tensor creation from float array
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_from_float_array(
    data: *const c_float,
    _data_len: c_int,
    shape: *const c_int,
    ndim: c_int,
) -> *mut TorshTensor {
    // Convert C# int to usize for shape
    let shape_vec: Vec<usize> = std::slice::from_raw_parts(shape, ndim as usize)
        .iter()
        .map(|&x| x as usize)
        .collect();

    torsh_tensor_new(
        data as *const c_void,
        shape_vec.as_ptr(),
        shape_vec.len(),
        TorshDType::F32,
    )
}

/// C#-specific wrapper for tensor creation from double array
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_from_double_array(
    data: *const c_float, // Note: Using c_float for simplicity, should be c_double
    _data_len: c_int,
    shape: *const c_int,
    ndim: c_int,
) -> *mut TorshTensor {
    let shape_vec: Vec<usize> = std::slice::from_raw_parts(shape, ndim as usize)
        .iter()
        .map(|&x| x as usize)
        .collect();

    torsh_tensor_new(
        data as *const c_void,
        shape_vec.as_ptr(),
        shape_vec.len(),
        TorshDType::F64,
    )
}

/// C#-specific wrapper for tensor creation from int array
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_from_int_array(
    data: *const c_int,
    _data_len: c_int,
    shape: *const c_int,
    ndim: c_int,
) -> *mut TorshTensor {
    let shape_vec: Vec<usize> = std::slice::from_raw_parts(shape, ndim as usize)
        .iter()
        .map(|&x| x as usize)
        .collect();

    torsh_tensor_new(
        data as *const c_void,
        shape_vec.as_ptr(),
        shape_vec.len(),
        TorshDType::I32,
    )
}

/// C#-specific wrapper for tensor addition
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_add(
    a: *mut TorshTensor,
    b: *mut TorshTensor,
) -> *mut TorshTensor {
    // Perform in-place addition
    let error = torsh_tensor_add(a, b, a);
    if error != TorshError::Success {
        return std::ptr::null_mut();
    }
    a
}

/// C#-specific wrapper for tensor subtraction
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_subtract(
    a: *mut TorshTensor,
    b: *mut TorshTensor,
) -> *mut TorshTensor {
    // Perform in-place subtraction
    let error = torsh_tensor_sub(a, b, a);
    if error != TorshError::Success {
        return std::ptr::null_mut();
    }
    a
}

/// C#-specific wrapper for tensor multiplication
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_multiply(
    a: *mut TorshTensor,
    b: *mut TorshTensor,
) -> *mut TorshTensor {
    // Perform in-place multiplication
    let error = torsh_tensor_mul(a, b, a);
    if error != TorshError::Success {
        return std::ptr::null_mut();
    }
    a
}

/// C#-specific wrapper for matrix multiplication
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_matmul(
    a: *mut TorshTensor,
    b: *mut TorshTensor,
) -> *mut TorshTensor {
    // Perform in-place matrix multiplication
    let error = torsh_tensor_matmul(a, b, a);
    if error != TorshError::Success {
        return std::ptr::null_mut();
    }
    a
}

/// C#-specific wrapper for ReLU activation
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_relu(tensor: *mut TorshTensor) -> *mut TorshTensor {
    // Create output tensor (we'll reuse input tensor as output for simplicity)
    let result = torsh_tensor_relu(tensor as *const TorshTensor, tensor);
    match result {
        crate::c_api::TorshError::Success => tensor,
        _ => std::ptr::null_mut(),
    }
}

/// C#-specific wrapper for getting tensor shape with int output
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_get_shape(
    tensor: *mut TorshTensor,
    shape: *mut c_int,
    max_dims: c_int,
    actual_dims: *mut c_int,
) -> c_int {
    let mut temp_shape = vec![0usize; max_dims as usize];
    let mut ndim = 0usize;

    let result = torsh_tensor_shape(tensor, temp_shape.as_mut_ptr(), &mut ndim);

    if result == TorshError::Success {
        *actual_dims = ndim as c_int;

        // Copy shape data, converting usize to c_int
        for i in 0..std::cmp::min(ndim, max_dims as usize) {
            *shape.add(i) = temp_shape[i] as c_int;
        }

        0 // Success
    } else {
        1 // Error
    }
}

/// C#-specific wrapper for getting tensor data as float array
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_get_float_data(
    tensor: *mut TorshTensor,
    data: *mut c_float,
    max_elements: c_int,
    actual_elements: *mut c_int,
) -> c_int {
    // Note: This is a simplified implementation
    // In practice, you would need to determine the actual size first
    let result = torsh_tensor_data(tensor as *const TorshTensor);

    if !result.is_null() {
        // Copy data from result to the output buffer
        // This is simplified - in practice would check actual tensor size
        let src_data = std::slice::from_raw_parts(result as *const c_float, max_elements as usize);
        let dst_data = std::slice::from_raw_parts_mut(data, max_elements as usize);
        dst_data.copy_from_slice(src_data);
        *actual_elements = max_elements; // Simplified - should be actual count
        0 // Success
    } else {
        1 // Error
    }
}

/// C#-specific wrapper for tensor cleanup
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_dispose(tensor: *mut TorshTensor) {
    torsh_tensor_free(tensor)
}

/// C#-specific wrapper for creating a linear layer
#[no_mangle]
pub unsafe extern "C" fn csharp_linear_new(
    in_features: c_int,
    out_features: c_int,
    bias: c_int, // 0 = false, 1 = true
) -> *mut TorshModule {
    torsh_linear_new(in_features as usize, out_features as usize, bias != 0)
}

/// C#-specific wrapper for linear layer forward pass
#[no_mangle]
pub unsafe extern "C" fn csharp_linear_forward(
    module: *mut TorshModule,
    input: *mut TorshTensor,
) -> *mut TorshTensor {
    // For simplicity, we'll reuse the input tensor as output
    // In a real implementation, you might want to create a new tensor
    let result = torsh_linear_forward(
        module as *const TorshModule,
        input as *const TorshTensor,
        input,
    );
    match result {
        crate::c_api::TorshError::Success => input,
        _ => std::ptr::null_mut(),
    }
}

/// C#-specific wrapper for module cleanup
#[no_mangle]
pub unsafe extern "C" fn csharp_module_dispose(module: *mut TorshModule) {
    torsh_module_free(module)
}

/// C#-specific wrapper for SGD optimizer
#[no_mangle]
pub unsafe extern "C" fn csharp_sgd_new(
    learning_rate: c_float,
    momentum: c_float,
) -> *mut TorshOptimizer {
    torsh_sgd_new(learning_rate, momentum)
}

/// C#-specific wrapper for Adam optimizer
#[no_mangle]
pub unsafe extern "C" fn csharp_adam_new(
    learning_rate: c_float,
    beta1: c_float,
    beta2: c_float,
    epsilon: c_float,
) -> *mut TorshOptimizer {
    torsh_adam_new(learning_rate, beta1, beta2, epsilon)
}

/// C#-specific wrapper for optimizer step with simplified parameter handling
#[no_mangle]
pub unsafe extern "C" fn csharp_optimizer_step(
    optimizer: *mut TorshOptimizer,
    _parameters: *mut *mut TorshTensor,
    _gradients: *mut *mut TorshTensor,
    _param_count: c_int,
) -> c_int {
    // Note: C API only takes optimizer, additional parameters are ignored for now
    let result = torsh_optimizer_step(optimizer);

    match result {
        TorshError::Success => 0,
        _ => 1,
    }
}

/// C#-specific wrapper for optimizer cleanup
#[no_mangle]
pub unsafe extern "C" fn csharp_optimizer_dispose(optimizer: *mut TorshOptimizer) {
    torsh_optimizer_free(optimizer)
}

/// C#-specific wrapper for getting last error as string
#[no_mangle]
pub unsafe extern "C" fn csharp_get_last_error(buffer: *mut c_char, buffer_size: c_int) -> c_int {
    let error_ptr = torsh_get_last_error();

    if error_ptr.is_null() {
        return 0; // No error
    }

    let error_cstr = CStr::from_ptr(error_ptr);
    let error_bytes = error_cstr.to_bytes();

    let copy_len = std::cmp::min(error_bytes.len(), (buffer_size - 1) as usize);

    if copy_len > 0 {
        ptr::copy_nonoverlapping(error_bytes.as_ptr(), buffer as *mut u8, copy_len);
        *buffer.add(copy_len) = 0; // Null terminator
    }

    error_bytes.len() as c_int
}

/// C#-specific wrapper for clearing last error
#[no_mangle]
pub unsafe extern "C" fn csharp_clear_last_error() {
    torsh_clear_last_error()
}

/// C#-specific wrapper for version information
#[no_mangle]
pub unsafe extern "C" fn csharp_get_version(buffer: *mut c_char, buffer_size: c_int) -> c_int {
    let version_ptr = torsh_version();

    if version_ptr.is_null() {
        return 0;
    }

    let version_cstr = CStr::from_ptr(version_ptr);
    let version_bytes = version_cstr.to_bytes();

    let copy_len = std::cmp::min(version_bytes.len(), (buffer_size - 1) as usize);

    if copy_len > 0 {
        ptr::copy_nonoverlapping(version_bytes.as_ptr(), buffer as *mut u8, copy_len);
        *buffer.add(copy_len) = 0; // Null terminator
    }

    version_bytes.len() as c_int
}

/// C#-specific wrapper for CUDA availability check
#[no_mangle]
pub unsafe extern "C" fn csharp_cuda_is_available() -> c_int {
    torsh_cuda_is_available()
}

/// C#-specific wrapper for CUDA device count
#[no_mangle]
pub unsafe extern "C" fn csharp_cuda_device_count() -> c_int {
    torsh_cuda_device_count()
}

/// C#-specific helper for creating zero tensors
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_zeros(
    shape: *const c_int,
    ndim: c_int,
    dtype: c_int,
) -> *mut TorshTensor {
    let shape_vec: Vec<usize> = std::slice::from_raw_parts(shape, ndim as usize)
        .iter()
        .map(|&x| x as usize)
        .collect();

    let total_elements: usize = shape_vec.iter().product();
    let zeros_data = vec![0.0f32; total_elements];

    let torsh_dtype = match dtype {
        0 => TorshDType::F32,
        1 => TorshDType::F64,
        2 => TorshDType::I32,
        3 => TorshDType::I64,
        4 => TorshDType::U8,
        _ => TorshDType::F32,
    };

    torsh_tensor_new(
        zeros_data.as_ptr() as *const c_void,
        shape_vec.as_ptr(),
        shape_vec.len(),
        torsh_dtype,
    )
}

/// C#-specific helper for creating ones tensors
#[no_mangle]
pub unsafe extern "C" fn csharp_tensor_ones(
    shape: *const c_int,
    ndim: c_int,
    dtype: c_int,
) -> *mut TorshTensor {
    let shape_vec: Vec<usize> = std::slice::from_raw_parts(shape, ndim as usize)
        .iter()
        .map(|&x| x as usize)
        .collect();

    let total_elements: usize = shape_vec.iter().product();
    let ones_data = vec![1.0f32; total_elements];

    let torsh_dtype = match dtype {
        0 => TorshDType::F32,
        1 => TorshDType::F64,
        2 => TorshDType::I32,
        3 => TorshDType::I64,
        4 => TorshDType::U8,
        _ => TorshDType::F32,
    };

    torsh_tensor_new(
        ones_data.as_ptr() as *const c_void,
        shape_vec.as_ptr(),
        shape_vec.len(),
        torsh_dtype,
    )
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_csharp_tensor_creation() {
        let data = vec![1.0f32, 2.0, 3.0, 4.0];
        let shape = vec![2i32, 2i32];

        unsafe {
            let tensor = csharp_tensor_from_float_array(
                data.as_ptr(),
                data.len() as c_int,
                shape.as_ptr(),
                shape.len() as c_int,
            );

            assert!(!tensor.is_null());

            // Test shape retrieval
            let mut retrieved_shape = vec![0i32; 2];
            let mut actual_dims = 0i32;
            let result =
                csharp_tensor_get_shape(tensor, retrieved_shape.as_mut_ptr(), 2, &mut actual_dims);

            assert_eq!(result, 0); // Success
            assert_eq!(actual_dims, 2);
            assert_eq!(retrieved_shape, shape);

            // Clean up
            csharp_tensor_dispose(tensor);
        }
    }

    #[test]
    fn test_csharp_tensor_operations() {
        let data1 = vec![1.0f32, 2.0, 3.0, 4.0];
        let data2 = vec![5.0f32, 6.0, 7.0, 8.0];
        let shape = vec![2i32, 2i32];

        unsafe {
            let tensor1 = csharp_tensor_from_float_array(
                data1.as_ptr(),
                data1.len() as c_int,
                shape.as_ptr(),
                shape.len() as c_int,
            );

            let tensor2 = csharp_tensor_from_float_array(
                data2.as_ptr(),
                data2.len() as c_int,
                shape.as_ptr(),
                shape.len() as c_int,
            );

            assert!(!tensor1.is_null());
            assert!(!tensor2.is_null());

            // Test addition
            let result = csharp_tensor_add(tensor1, tensor2);
            assert!(!result.is_null());

            // Clean up
            csharp_tensor_dispose(tensor1);
            csharp_tensor_dispose(tensor2);
            csharp_tensor_dispose(result);
        }
    }

    #[test]
    fn test_csharp_zeros_ones() {
        let shape = vec![3i32, 3i32];

        unsafe {
            // Test zeros creation
            let zeros = csharp_tensor_zeros(shape.as_ptr(), shape.len() as c_int, 0);
            assert!(!zeros.is_null());

            // Test ones creation
            let ones = csharp_tensor_ones(shape.as_ptr(), shape.len() as c_int, 0);
            assert!(!ones.is_null());

            // Clean up
            csharp_tensor_dispose(zeros);
            csharp_tensor_dispose(ones);
        }
    }

    #[test]
    fn test_csharp_linear_layer() {
        unsafe {
            // Test linear layer creation
            let linear = csharp_linear_new(4, 2, 1);
            assert!(!linear.is_null());

            // Test with dummy input
            let input_data = vec![1.0f32, 2.0, 3.0, 4.0];
            let input_shape = vec![1i32, 4i32];

            let input_tensor = csharp_tensor_from_float_array(
                input_data.as_ptr(),
                input_data.len() as c_int,
                input_shape.as_ptr(),
                input_shape.len() as c_int,
            );

            let output = csharp_linear_forward(linear, input_tensor);
            assert!(!output.is_null());

            // Clean up
            csharp_tensor_dispose(input_tensor);
            csharp_tensor_dispose(output);
            csharp_module_dispose(linear);
        }
    }

    #[test]
    fn test_csharp_optimizers() {
        unsafe {
            // Test SGD optimizer creation
            let sgd = csharp_sgd_new(0.01, 0.9);
            assert!(!sgd.is_null());

            // Test Adam optimizer creation
            let adam = csharp_adam_new(0.001, 0.9, 0.999, 1e-8);
            assert!(!adam.is_null());

            // Clean up
            csharp_optimizer_dispose(sgd);
            csharp_optimizer_dispose(adam);
        }
    }
}