FPS 0.0.3

use n::*;
use n::env::*;
use n::packet::*;
use std;
use std::os::raw::c_void;
use std::ptr::null_mut;

pub trait CstrToString<'a>{
    fn to_str(self, limit: usize) -> &'a str;
}

impl<'a> CstrToString<'a> for *const u8 {
    fn to_str(self, limit: usize) -> &'a str {
        let rust_field_name: &[u8] = unsafe { std::slice::from_raw_parts(self, limit) };
        let cur_limit = std::cmp::min(limit, MAX_FIELD_NAME);
        let mut j = cur_limit;
        for i in 0..cur_limit {
            if rust_field_name[i] == 0 {
                j = i;
                break;
            }
        }
        let known_length_field = &rust_field_name[0..j];
        let ret: &str = std::str::from_utf8(known_length_field).unwrap();
        ret
        // .expect("Wrong utf-8 format");
    }
}

#[no_mangle]
pub extern "C" fn process_packet(packet: *mut c_void, field_name: *const u8) -> *mut c_void {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);
    let rust_packet = *packet_box;
    let mapper = millefeuille_ffi_map!();
    
    if let Some(handler) = mapper(rust_field_name) {
    	let right_packet = handler(rust_packet);
    	Box::into_raw(Box::new(right_packet)) as *mut c_void
    } else {
    	null_mut()
    }
}

#[no_mangle]
pub extern "C" fn wrap_packet(buffer: *mut c_void, length: usize) -> *mut c_void {
    if length > PACKET_BUFFER_SIZE {
        null_mut()
    } else {
        let packet_buffer: Field = unsafe { std::slice::from_raw_parts_mut(buffer as *mut u8, length) };
        let packet_box = Box::new(Packet::new(packet_buffer));
        Box::into_raw(packet_box) as *mut c_void
    }
}

#[no_mangle]
pub extern "C" fn unwrap_packet(packet: *mut c_void) {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    std::mem::drop(packet_box);
}

#[no_mangle]
pub extern "C" fn read_packet_context_u8(packet: *mut c_void, field_name: *const u8) -> u8 {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.get_u8_released(rust_field_name) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn read_packet_context_usize(packet: *mut c_void, field_name: *const u8) -> usize {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.get_usize_released(rust_field_name) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn write_packet_context_u8(packet: *mut c_void, field_name: *const u8, val: u8) -> u8 {
    let mut packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.set_u8_released(rust_field_name, val) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn write_packet_context_usize(packet: *mut c_void, field_name: *const u8, val: usize) -> usize {
    let mut packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.set_usize_released(rust_field_name, val) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn read_packet_context_u16(packet: *mut c_void, field_name: *const u8) -> u16 {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.get_u16_released(rust_field_name) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn write_packet_context_u16(packet: *mut c_void, field_name: *const u8, val: u16) -> u16 {
    let mut packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.set_u16_released(rust_field_name, val) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn read_packet_context_u32(packet: *mut c_void, field_name: *const u8) -> u32 {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.get_u32_released(rust_field_name) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn write_packet_context_u32(packet: *mut c_void, field_name: *const u8, val: u32) -> u32 {
    let mut packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.set_u32_released(rust_field_name, val) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn read_packet_context_u64(packet: *mut c_void, field_name: *const u8) -> u64 {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.get_u64_released(rust_field_name) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn write_packet_context_u64(packet: *mut c_void, field_name: *const u8, val: u64) -> u64 {
    let mut packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);

    let ret = match packet_box.context.set_u64_released(rust_field_name, val) {
        Some(x) => x,
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn read_packet_context_string(packet: *mut c_void, field_name: *const u8, char_buffer: *mut u8, buffer_length: usize) -> usize {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);
    let rust_string_buffer: &mut [u8] = unsafe { std::slice::from_raw_parts_mut(char_buffer, buffer_length) };
    let rust_string_buffer = &mut rust_string_buffer[0..buffer_length];

    let ret = match packet_box.context.get_string_released(rust_field_name) {
        Some(str) => move_field(str.as_bytes(), rust_string_buffer),
        _ => 0,
    };
    if ret < buffer_length {
        rust_string_buffer[ret] = 0;
    }
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn write_packet_context_string(packet: *mut c_void, field_name: *const u8, char_buffer: *const u8, buffer_length: usize) -> usize {
    let mut packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);
    let rust_field_val = char_buffer.to_str(buffer_length);
    packet_box.context.set_string_released(rust_field_name, rust_field_val);
    let ret = rust_field_val.len();
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn read_packet_context_field(packet: *mut c_void, field_name: *const u8, field_buffer: *mut c_void, buffer_length: usize) -> usize {
    let packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);
    let rust_field_buffer: Field = unsafe { std::slice::from_raw_parts_mut(field_buffer as *mut u8, buffer_length) };

    let ret = match packet_box.context.get_field_released(rust_field_name) {
        Some(field) => move_field(field, rust_field_buffer),
        _ => 0,
    };
    std::mem::forget(packet_box);
    ret
}

#[no_mangle]
pub extern "C" fn write_packet_context_field(packet: *mut c_void, field_name: *const u8, field_buffer: *const c_void, buffer_length: usize) -> usize {
    let mut packet_box: Box<Packet> = unsafe { Box::from_raw(packet as *mut Packet) };
    let rust_field_name = field_name.to_str(MAX_FIELD_NAME);
    let rust_field_buffer: ConstField = unsafe { std::slice::from_raw_parts(field_buffer as *const u8, buffer_length) };

    let ret = match packet_box.context.take_field_released(rust_field_name) {
        Some(field) => {
            let len = move_field(rust_field_buffer, field);
            packet_box.context.set_field_released(rust_field_name, field);
            len
        }
        _ => 0,
    };

    std::mem::forget(packet_box);
    ret
}