#[unsafe(no_mangle)]
extern "C" fn panic() -> ! {
    panic!("Called panic from external code.");
}

#[repr(C)]
struct FFISlice {
    ptr: *const u8,
    len: usize,
}

impl FFISlice {
    fn as_slice(&self) -> &[u8] {
        unsafe { core::slice::from_raw_parts(self.ptr, self.len) }
    }
    fn as_str(&self) -> &str {
        unsafe { core::str::from_utf8_unchecked(self.as_slice()) }
    }
}

unsafe extern "C" {
    unsafe fn int_to_str2(value: isize, buffer: *mut u8, buffer_len: usize, radix: u8) -> FFISlice;
    unsafe fn str_to_int(s: *const u8, len: usize, radix: u8) -> isize;
}

fn main() {
    let value = 1234567890isize;
    let mut buffer = [0u8; 32];
    unsafe {
        let slice = int_to_str2(value, buffer.as_mut_ptr(), buffer.len(), 10);
        let s = slice.as_str();
        println!("Integer: {}, String: {}", value, s);
        assert_eq!(s, format!("{value}"));

        let slice = int_to_str2(0 - value, buffer.as_mut_ptr(), buffer.len(), 10);
        let s = slice.as_str();
        println!("Integer: {}, String: {}", 0 - value, s);
        assert_eq!(s, format!("{}", 0 - value));

        let slice = int_to_str2(value, buffer.as_mut_ptr(), buffer.len(), 16);
        let s = slice.as_str();
        println!("Integer: {:x}, String: {}", value, s);
        assert_eq!(s, format!("{value:x}"));

        let slice = int_to_str2(value, buffer.as_mut_ptr(), buffer.len(), 8);
        let s = slice.as_str();
        println!("Integer: {:o}, String: {}", value, s);
        assert_eq!(s, format!("{value:o}"));

        let value = 235isize;
        let slice = int_to_str2(value, buffer.as_mut_ptr(), buffer.len(), 2);
        let s = slice.as_str();
        println!("Integer: {:b}, String: {}", value, s);
        assert_eq!(s, format!("{value:b}"));

        let s = "1234567890";
        let parsed = str_to_int(s.as_ptr(), s.len(), 10);
        println!("String: {}, Integer: {}", s, parsed);
        assert_eq!(parsed, 1234567890isize);

        let s = "499602d2";
        let parsed = str_to_int(s.as_ptr(), s.len(), 16);
        println!("String: {}, Integer: {}", s, parsed);
        assert_eq!(parsed, 1234567890isize);

        let s = "11145401322";
        let parsed = str_to_int(s.as_ptr(), s.len(), 8);
        println!("String: {}, Integer: {}", s, parsed);
        assert_eq!(parsed, 1234567890isize);
        let s = "11101011";
        let parsed = str_to_int(s.as_ptr(), s.len(), 2);
        println!("String: {}, Integer: {}", s, parsed);
        assert_eq!(parsed, 235isize);

        let s = "9999999999999999999999999999999999999999";
        let parsed = str_to_int(s.as_ptr(), s.len(), 10);
        println!("String: {}, Integer: {}", s, parsed);
        assert_eq!(parsed, isize::MAX);
    }
}