Best practices interoperability: Swift 5.10 vs Rust 1.85 in 2026

// Rust 1.85 Image Resizer Library for Swift Interop
// Compiled with: rustc --edition 2021 --crate-type staticlib -O image_resizer.rs
// Dependencies: None (uses stable std only)
// Stabilized features used: extern "swift" ABI, crepr for C-compatible types

#![allow(dead_code)]

use std::os::raw::{c_int, c_uchar, c_uint};
use std::slice;

// Error codes compatible with Swift's Error protocol
pub const RESIZE_SUCCESS: c_int = 0;
pub const RESIZE_INVALID_PTR: c_int = 1;
pub const RESIZE_INVALID_DIMENSIONS: c_int = 2;
pub const RESIZE_BUFFER_TOO_SMALL: c_int = 3;

// Swift-compatible ABI struct for image metadata
// Must match Swift's ImageMetadata struct exactly (field order, alignment)
#[repr(C)]
pub struct ImageMetadata {
    width: c_uint,
    height: c_uint,
    channels: c_uchar, // 3 for RGB, 4 for RGBA
    _padding: [u8; 3], // Align to 4 bytes for Swift ABI compatibility
}

// Resize RGB/RGBA image using nearest-neighbor interpolation
// Exposed to Swift via extern "swift" stabilized in Rust 1.85
#[no_mangle]
#[extern "swift"]
pub unsafe fn resize_image(
    input_ptr: *const c_uchar,
    input_len: c_uint,
    metadata_ptr: *const ImageMetadata,
    output_ptr: *mut c_uchar,
    output_cap: c_uint,
    target_width: c_uint,
    target_height: c_uint,
    error_ptr: *mut c_int,
) -> c_uint {
    // Validate input pointer
    if input_ptr.is_null() {
        if !error_ptr.is_null() {
            *error_ptr = RESIZE_INVALID_PTR;
        }
        return 0;
    }

    // Validate metadata pointer
    if metadata_ptr.is_null() {
        if !error_ptr.is_null() {
            *error_ptr = RESIZE_INVALID_PTR;
        }
        return 0;
    }

    // Dereference metadata safely
    let metadata = &*metadata_ptr;
    let channels = metadata.channels as usize;
    if channels != 3 && channels != 4 {
        if !error_ptr.is_null() {
            *error_ptr = RESIZE_INVALID_DIMENSIONS;
        }
        return 0;
    }

    // Calculate input and target buffer sizes
    let input_size = (metadata.width as usize) * (metadata.height as usize) * channels;
    if input_size > input_len as usize {
        if !error_ptr.is_null() {
            *error_ptr = RESIZE_INVALID_DIMENSIONS;
        }
        return 0;
    }

    let target_size = (target_width as usize) * (target_height as usize) * channels;
    if target_size > output_cap as usize {
        if !error_ptr.is_null() {
            *error_ptr = RESIZE_BUFFER_TOO_SMALL;
        }
        return 0;
    }

    // Create slices from raw pointers (unsafe but validated above)
    let input_slice = slice::from_raw_parts(input_ptr, input_size);
    let output_slice = slice::from_raw_parts_mut(output_ptr, target_size);

    // Nearest-neighbor resizing logic
    let x_ratio = metadata.width as f32 / target_width as f32;
    let y_ratio = metadata.height as f32 / target_height as f32;

    for y in 0..target_height as usize {
        let src_y = (y as f32 * y_ratio) as usize;
        for x in 0..target_width as usize {
            let src_x = (x as f32 * x_ratio) as usize;
            let src_idx = (src_y * metadata.width as usize + src_x) * channels;
            let dst_idx = (y * target_width as usize + x) * channels;

            for c in 0..channels {
                output_slice[dst_idx + c] = input_slice[src_idx + c];
            }
        }
    }

    if !error_ptr.is_null() {
        *error_ptr = RESIZE_SUCCESS;
    }

    target_size as c_uint
}

// Test module to verify FFI logic (not compiled into staticlib)
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_valid_resize() {
        let input = vec![255; 12]; // 2x2 RGB image (2*2*3=12)
        let metadata = ImageMetadata {
            width: 2,
            height: 2,
            channels: 3,
            _padding: [0; 3],
        };
        let mut output = vec![0; 27]; // 3x3 RGB image (3*3*3=27)
        let mut error = 0;

        let result = unsafe {
            resize_image(
                input.as_ptr(),
                input.len() as c_uint,
                &metadata,
                output.as_mut_ptr(),
                output.len() as c_uint,
                3,
                3,
                &mut error,
            )
        };

        assert_eq!(error, RESIZE_SUCCESS);
        assert_eq!(result, 27);
    }
}

// Swift 5.10 Code Calling Rust 1.85 Image Resizer Library
// Compiled with: swiftc -O -import-objc-header BridgingHeader.h main.swift
// BridgingHeader.h includes: #include "image_resizer.h" (generated from Rust lib)
// Uses Swift 5.10 C++ Interop and @_cdecl attribute for FFI

import Foundation

// Match Rust's ImageMetadata struct exactly (field order, alignment, padding)
@_cdecl("ImageMetadata") // Ensure C-compatible ABI
struct ImageMetadata {
    let width: UInt32
    let height: UInt32
    let channels: UInt8
    private let _padding: (UInt8, UInt8, UInt8) // 3 bytes padding for 4-byte alignment

    init(width: UInt32, height: UInt32, channels: UInt8) {
        self.width = width
        self.height = height
        self.channels = channels
        self._padding = (0, 0, 0)
    }
}

// Error enum matching Rust's error codes
enum ResizeError: Error, Equatable {
    case invalidPointer
    case invalidDimensions
    case bufferTooSmall
    case unknown(code: Int32)

    init(rustCode: Int32) {
        switch rustCode {
        case 1: self = .invalidPointer
        case 2: self = .invalidDimensions
        case 3: self = .bufferTooSmall
        default: self = .unknown(code: rustCode)
        }
    }
}

// Rust FFI function declarations (linked from staticlib)
@_silgen_name("resize_image")
func resize_image(
    _ inputPtr: UnsafePointer,
    _ inputLen: UInt32,
    _ metadataPtr: UnsafePointer,
    _ outputPtr: UnsafeMutablePointer,
    _ outputCap: UInt32,
    _ targetWidth: UInt32,
    _ targetHeight: UInt32,
    _ errorPtr: UnsafeMutablePointer
) -> UInt32

// Wrapper class for type-safe image resizing
class RustImageResizer {
    private let resizerQueue = DispatchQueue(label: "com.example.rustresizer", qos: .userInitiated)

    func resize(
        input: Data,
        metadata: ImageMetadata,
        targetWidth: UInt32,
        targetHeight: UInt32
    ) throws -> Data {
        // Validate input
        guard !input.isEmpty else {
            throw ResizeError.invalidPointer
        }

        // Calculate required output size
        let channels = Int(metadata.channels)
        let outputSize = Int(targetWidth * targetHeight) * channels
        guard outputSize > 0 else {
            throw ResizeError.invalidDimensions
        }

        var output = Data(capacity: outputSize)
        output.count = outputSize // Allocate memory
        var errorCode: Int32 = 0

        // Call Rust FFI in dispatch queue to avoid blocking main thread
        let resultSize = resizerQueue.sync {
            input.withUnsafeBytes { inputBytes in
                output.withUnsafeMutableBytes { outputBytes in
                    guard let inputBase = inputBytes.baseAddress?.assumingMemoryBound(to: UInt8.self),
                          let outputBase = outputBytes.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
                        errorCode = 1 // Invalid pointer
                        return 0
                    }

                    return resize_image(
                        inputBase,
                        UInt32(input.count),
                        &metadata,
                        outputBase,
                        UInt32(outputSize),
                        targetWidth,
                        targetHeight,
                        &errorCode
                    )
                }
            }
        }

        // Check for errors
        if errorCode != 0 {
            throw ResizeError(rustCode: errorCode)
        }

        // Truncate output to actual result size
        output.count = Int(resultSize)
        return output
    }
}

// Example usage
let resizer = RustImageResizer()
let inputImage = Data(repeating: 0xFF, count: 12) // 2x2 RGB image
let metadata = ImageMetadata(width: 2, height: 2, channels: 3)

do {
    let resized = try resizer.resize(
        input: inputImage,
        metadata: metadata,
        targetWidth: 3,
        targetHeight: 3
    )
    print("Resized image size: \(resized.count) bytes")
} catch {
    print("Resize failed: \(error)")
}

// Rust 1.85 Shared Memory Buffer Writer for Swift Interop
// Compiled with: rustc --edition 2021 --crate-type cdylib -O shared_mem.rs
// Uses Unix shared memory (shm_open) for zero-copy interop with Swift
// Stabilized features: std::os::unix::shm, extern "swift" for buffer descriptor

#![allow(dead_code)]

use std::os::raw::{c_int, c_uchar, c_uint};
use std::os::unix::io::RawFd;
use std::ptr;
use std::sync::atomic::{AtomicU32, Ordering};

// Shared memory buffer header (must match Swift's SharedBufferHeader)
#[repr(C, align(8))]
pub struct SharedBufferHeader {
    magic: u32, // 0x53485242 ("SHRB" = Shared Rust Buffer)
    version: u32, // 1 for this implementation
    data_len: AtomicU32, // Current length of data in buffer
    cap: u32, // Total buffer capacity
    _padding: [u8; 4], // Align to 8 bytes
}

// Initialize shared memory buffer
#[no_mangle]
#[extern "swift"]
pub unsafe fn shm_init(
    shm_name_ptr: *const c_uchar,
    shm_name_len: c_uint,
    cap: c_uint,
    fd_ptr: *mut RawFd,
    error_ptr: *mut c_int,
) -> *mut SharedBufferHeader {
    const SUCCESS: c_int = 0;
    const INVALID_PTR: c_int = 1;
    const SHM_OPEN_FAILED: c_int = 2;
    const TRUNC_FAILED: c_int = 3;
    const MMAP_FAILED: c_int = 4;

    // Validate input pointers
    if shm_name_ptr.is_null() || fd_ptr.is_null() {
        if !error_ptr.is_null() {
            *error_ptr = INVALID_PTR;
        }
        return ptr::null_mut();
    }

    // Convert shared memory name to Rust str
    let shm_name_slice = slice::from_raw_parts(shm_name_ptr, shm_name_len as usize);
    let shm_name = match std::str::from_utf8(shm_name_slice) {
        Ok(s) => s,
        Err(_) => {
            if !error_ptr.is_null() {
                *error_ptr = INVALID_PTR;
            }
            return ptr::null_mut();
        }
    };

    // Open shared memory segment (O_CREAT | O_RDWR)
    let fd = match std::os::unix::shm::shm_open(
        shm_name,
        std::os::unix::prelude::O_CREAT | std::os::unix::prelude::O_RDWR,
        0o644,
    ) {
        Ok(fd) => fd,
        Err(_) => {
            if !error_ptr.is_null() {
                *error_ptr = SHM_OPEN_FAILED;
            }
            return ptr::null_mut();
        }
    };

    // Set shared memory size to header + cap
    let total_size = std::mem::size_of::() + cap as usize;
    if std::os::unix::prelude::ftruncate(fd, total_size as i64).is_err() {
        if !error_ptr.is_null() {
            *error_ptr = TRUNC_FAILED;
        }
        return ptr::null_mut();
    }

    // Map shared memory into process address space
    let header_ptr = std::os::unix::prelude::mmap(
        ptr::null_mut(),
        total_size,
        std::os::unix::prelude::PROT_READ | std::os::unix::prelude::PROT_WRITE,
        std::os::unix::prelude::MAP_SHARED,
        Some(fd),
        0,
    ) as *mut SharedBufferHeader;

    if header_ptr.is_null() {
        if !error_ptr.is_null() {
            *error_ptr = MMAP_FAILED;
        }
        return ptr::null_mut();
    }

    // Initialize header
    ptr::write(
        header_ptr,
        SharedBufferHeader {
            magic: 0x53485242,
            version: 1,
            data_len: AtomicU32::new(0),
            cap,
            _padding: [0; 4],
        },
    );

    // Write fd to output pointer
    *fd_ptr = fd;

    if !error_ptr.is_null() {
        *error_ptr = SUCCESS;
    }

    header_ptr
}

// Write data to shared buffer (thread-safe via atomic data_len)
#[no_mangle]
#[extern "swift"]
pub unsafe fn shm_write(
    header_ptr: *mut SharedBufferHeader,
    data_ptr: *const c_uchar,
    data_len: c_uint,
) -> c_int {
    const SUCCESS: c_int = 0;
    const INVALID_PTR: c_int = 1;
    const BUFFER_FULL: c_int = 2;

    if header_ptr.is_null() || data_ptr.is_null() {
        return INVALID_PTR;
    }

    let header = &*header_ptr;
    let current_len = header.data_len.load(Ordering::Acquire);
    let new_len = current_len + data_len;

    if new_len > header.cap {
        return BUFFER_FULL;
    }

    // Copy data to shared buffer (after header)
    let dest_ptr = (header_ptr as *mut u8).add(std::mem::size_of::());
    let src_slice = slice::from_raw_parts(data_ptr, data_len as usize);
    ptr::copy_nonoverlapping(src_slice.as_ptr(), dest_ptr.add(current_len as usize), data_len as usize);

    // Update data length atomically
    header.data_len.store(new_len, Ordering::Release);

    SUCCESS
}

// Example extern "swift" function declaration
#[no_mangle]
#[extern "swift"]
pub unsafe fn process_data(input: *const u8, len: u32) -> u32 {
    // ... implementation
}

// Swift 5.10 C++ Interop struct mapping
import Cxx

@_cdecl("RustStruct")
struct RustStruct {
    let id: UInt32
    let value: Float
    // Matches Rust's #[repr(C)] struct exactly
}

// Shared memory buffer header
#[repr(C, align(8))]
pub struct SharedBufferHeader {
    magic: u32, // Validation magic number
    version: u32,
    data_len: AtomicU32,
    cap: u32,
}