fn main() {
    let x = 10;

    // สร้าง raw pointers
    let ptr_const: *const i32 = &x;
    let ptr_mut: *mut i32 = &x as *const i32 as *mut i32;

    unsafe {
        println!("Value via const ptr: {}", *ptr_const);
        println!("Value via mut ptr: {}", *ptr_mut);
    }
}

unsafe fn swap_raw(a: *mut i32, b: *mut i32) {
    let temp = *a;
    *a = *b;
    *b = temp;
}

fn main() {
    let mut x = 10;
    let mut y = 20;

    println!("Before: x={}, y={}", x, y);

    unsafe {
        swap_raw(&mut x, &mut y);
    }

    println!("After: x={}, y={}", x, y);
}

fn split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = slice.len();
    let ptr = slice.as_mut_ptr();

    assert!(mid <= len);

    unsafe {
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

fn main() {
    let mut arr = [1, 2, 3, 4, 5];
    let (left, right) = split_at_mut(&mut arr, 2);

    println!("Left: {:?}", left);   // [1, 2]
    println!("Right: {:?}", right); // [3, 4, 5]
}

static mut COUNTER: i32 = 0;

fn increment() {
    unsafe {
        COUNTER += 1;
    }
}

fn main() {
    increment();
    increment();
    increment();

    unsafe {
        println!("Counter: {}", COUNTER);
    }
}

หมายเหตุ: ไม่แนะนำใน production code! ใช้ Mutex หรือ AtomicI32 แทน

// ประกาศ external function
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("Absolute value of -5: {}", abs(-5));
    }
}

// สร้าง function ให้ C เรียก
#[no_mangle]
pub extern "C" fn rust_function(x: i32) -> i32 {
    x * 2
}