version = "0.1.4"

use super::*;

use core::cell::RefCell;

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

#[derive(Default)]

struct StoredError {

    // invariant: len is zero IFF its occupied

    // contents are 1+ bytes because we also store the NULL TERMINATOR

    buf: Vec<u8>,

}

impl StoredError {

    const NULL_TERMINATOR: u8 = 0;

    fn clear(&mut self) {

        // no null terminator either!

        self.buf.clear();

    }

    fn store<E: Debug>(&mut self, error: &E) {

        write!(&mut self.buf, "{:?}", error);

        self.buf.push(Self::NULL_TERMINATOR);

    }

    fn tl_store<E: Debug>(error: &E) {

        STORED_ERROR.with(|stored_error| {

            let mut stored_error = stored_error.borrow_mut();

            stored_error.clear();

            stored_error.store(error);

        })

    }

    fn tl_clear() {

        STORED_ERROR.with(|stored_error| {

            let mut stored_error = stored_error.borrow_mut();

            stored_error.clear();

        })

    }

    fn tl_raw_peek() -> (*const u8, usize) {

        STORED_ERROR.with(|stored_error| {

            let stored_error = stored_error.borrow();

            match stored_error.buf.len() {

                0 => (core::ptr::null(), 0), // no error!

                n => {

                    // stores an error of length n-1 AND a NULL TERMINATOR

                    (stored_error.buf.as_ptr(), n - 1)

                }

            }

        })

    }

}

thread_local! {

    static STORED_ERROR: RefCell<StoredError> = RefCell::new(StoredError::default());

}

type ErrorCode = i32;

//////////////////////////////////////

/// Returns length (via out pointer) and pointer (via return value) of the last Reowolf error.

/// - pointer is NULL iff there was no last error

/// - data at pointer is null-delimited

/// - len does NOT include the length of the null-delimiter

#[no_mangle]

pub unsafe extern "C" fn reowolf_error_peek(len: *mut usize) -> *const u8 {

    let (err_ptr, err_len) = StoredError::tl_raw_peek();

    len.write(err_len);

    err_ptr

}

#[no_mangle]

pub unsafe extern "C" fn protocol_description_parse(

    pdl: *const u8,

    pdl_len: usize,

    pd: *mut Arc<ProtocolDescription>,

) -> ErrorCode {

    StoredError::tl_clear();

    let slice: *const [u8] = std::slice::from_raw_parts(pdl, pdl_len);

    let slice: &[u8] = &*slice;

    match ProtocolDescription::parse(slice) {

        Ok(new) => {

            pd.write(Arc::new(new));

            0

        }

        Err(err) => {

            StoredError::tl_store(&err);

            -1

        }

    }

}

#[no_mangle]

pub unsafe extern "C" fn protocol_description_destroy(pd: Arc<ProtocolDescription>) {

    drop(pd)

}

#[no_mangle]

pub unsafe extern "C" fn protocol_description_clone(

    pd: &Arc<ProtocolDescription>,

) -> Arc<ProtocolDescription> {

    pd.clone()

}

// #[no_mangle]

// pub extern "C" fn connector_new(pd: *const Arc<ProtocolDescription>) -> *mut Connector {

//     Box::into_raw(Box::new(Connector::default()))

// }

// /// Creates and returns Reowolf Connector structure allocated on the heap.

// #[no_mangle]

// pub extern "C" fn connector_with_controller_id(controller_id: ControllerId) -> *mut Connector {

//     Box::into_raw(Box::new(Connector::Unconfigured(Unconfigured { controller_id })))

// }

mod ffi;