#include <time.h>

#include "../../reowolf.h"

#include "../utility.c"

int main(int argc, char** argv) {

	int i, j, forwards, num_options, correct_index;

	forwards = atoi(argv[1]);

	num_options = atoi(argv[2]);

	unsigned char pdl[] = 

	"primitive recv_zero(in a) {  "

	"    while(true) synchronous {"

	"        msg m = get(a);      "

	"        assert(m[0] == 0);   "

	"    }                        "

	"}                            "

	; 

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl, sizeof(pdl)-1);

	printf("Error str `%s`\n", reowolf_error_peek(NULL));

	char logpath[] = "./bench_11.txt";

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	PortId native_putter, native_getter;

	connector_add_port_pair(c, &native_putter, &native_getter);

	for (i=0; i<forwards; i++) {

		// create a forward to tail of chain

		PortId putter, getter;

		connector_add_port_pair(c, &putter, &getter);

		// native ports: {native_putter, native_getter, putter, getter}

		// thread a forward component onto native_tail

		char ident[] = "forward";

		connector_add_component(c, ident, sizeof(ident)-1, (PortId[]){native_getter, putter}, 2);

		// native ports: {native_putter, getter}

		printf("Error str `%s`\n", reowolf_error_peek(NULL));

		native_getter = getter;

	}

	// add "recv_zero" on end of chain

	char ident[] = "recv_zero";

	connector_add_component(c, ident, sizeof(ident)-1, &native_getter, 1);

	connector_connect(c, -1);

	printf("Error str `%s`\n", reowolf_error_peek(NULL));

	clock_t begin = clock();

	char msg = 0;

		for(j=0; j<num_options; j++) {

			msg = j==correct_index ? 0 : 1;

			connector_put_bytes(c, native_putter, &msg, 1);

			if(j+1 < num_options) {

				connector_next_batch(c);

			}

		}	

		connector_sync(c, -1);	

	}

	clock_t end = clock();

	double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

	printf("Time taken: %f\n", time_spent);

	return 0;

}

#!/bin/bash

do

done

/* CBindgen generated */

#ifndef REOWOLF_HEADER_DEFINED

#define REOWOLF_HEADER_DEFINED

#include <stdarg.h>

#include <stdbool.h>

#include <stdint.h>

#include <stdlib.h>

#define RW_BAD_FD -5

#define RW_BAD_SOCKADDR -8

#define RW_CLOSE_FAIL -4

#define RW_CONNECT_FAILED -6

#define RW_LOCK_POISONED -3

#define RW_OK 0

#define RW_TL_ERR -1

#define RW_WOULD_BLOCK -7

#define RW_WRONG_STATE -2

typedef enum {

  EndpointPolarity_Active,

  EndpointPolarity_Passive,

} EndpointPolarity;

typedef enum {

  Polarity_Putter,

  Polarity_Getter,

} Polarity;

typedef struct Arc_ProtocolDescription Arc_ProtocolDescription;

typedef struct Connector Connector;

typedef uint32_t ConnectorId;

typedef uint32_t U32Suffix;

typedef struct {

  ConnectorId connector_id;

  U32Suffix u32_suffix;

} Id;

typedef Id PortId;

typedef struct {

  uint8_t ipv4[4];

  uint16_t port;

} FfiSocketAddr;

/**

 * Given

 * - an initialized connector in setup or connecting state,

 * - a string slice for the component's identifier in the connector's configured protocol description,

 * - a set of ports (represented as a slice; duplicates are ignored) in the native component's interface,

 * the connector creates a new (internal) protocol component C, such that the set of native ports are moved to C.

 * Usable in {setup, communication} states.

 */

int connector_add_component(Connector *connector,

                            const uint8_t *ident_ptr,

                            uintptr_t ident_len,

                            const PortId *ports_ptr,

                            uintptr_t ports_len);

/**

 * Given

 * - an initialized connector in setup or connecting state,

 * - a utf-8 encoded socket address,

 * - the logical polarity of P,

 * - the "physical" polarity in {Active, Passive} of the endpoint through which P's peer will be discovered,

 * returns P, a port newly added to the native interface.

 */

int connector_add_net_port(Connector *connector,

                           PortId *port,

                           FfiSocketAddr addr,

                           Polarity port_polarity,

                           EndpointPolarity endpoint_polarity);

/**

 * Given an initialized connector in setup or connecting state,

 * - Creates a new directed port pair with logical channel putter->getter,

 * - adds the ports to the native component's interface,

 * - and returns them using the given out pointers.

 * Usable in {setup, communication} states.

 */

void connector_add_port_pair(Connector *connector, PortId *out_putter, PortId *out_getter);

/**

 * Given

 * - an initialized connector in setup or connecting state,

 * - a utf-8 encoded BIND socket addresses (i.e., "local"),

 * - a utf-8 encoded CONNECT socket addresses (i.e., "peer"),

 * returns [P, G] via out pointers [putter, getter],

 * - where P is a Putter port that sends messages into the socket

 * - where G is a Getter port that recvs messages from the socket

 */

int connector_add_udp_mediator_component(Connector *connector,

                                         PortId *putter,

                                         PortId *getter,

                                         FfiSocketAddr local_addr,

                                         FfiSocketAddr peer_addr);

/**

 * Connects this connector to the distributed system of connectors reachable through endpoints,

 * Usable in setup state, and changes the state to communication.

 */

int connector_connect(Connector *connector, int64_t timeout_millis);

/**

 * Destroys the given a pointer to the connector on the heap, freeing its resources.

 * Usable in {setup, communication} states.

 */

void connector_destroy(Connector *connector);

int connector_get(Connector *connector, PortId port);

const uint8_t *connector_gotten_bytes(Connector *connector, PortId port, uintptr_t *out_len);

/**

 * Initializes `out` with a new connector using the given protocol description as its configuration.

 * The connector uses the given (internal) connector ID.

 */

Connector *connector_new(const Arc_ProtocolDescription *pd);

Connector *connector_new_logging(const Arc_ProtocolDescription *pd,

                                 const uint8_t *path_ptr,

                                 uintptr_t path_len);

Connector *connector_new_logging_with_id(const Arc_ProtocolDescription *pd,

                                         const uint8_t *path_ptr,

                                         uintptr_t path_len,

                                         ConnectorId connector_id);

intptr_t connector_next_batch(Connector *connector);

void connector_print_debug(Connector *connector);

/**

 * Convenience function combining the functionalities of

 * "payload_new" with "connector_put_payload".

 */

int connector_put_bytes(Connector *connector,

                        PortId port,

                        const uint8_t *bytes_ptr,

                        uintptr_t bytes_len);

intptr_t connector_sync(Connector *connector, int64_t timeout_millis);

/**

 * Given an initialized protocol description, initializes `out` with a clone which can be independently created or destroyed.

 */

Arc_ProtocolDescription *protocol_description_clone(const Arc_ProtocolDescription *pd);

/**

 * Destroys the given initialized protocol description and frees its resources.

 */

void protocol_description_destroy(Arc_ProtocolDescription *pd);

/**

 * Parses the utf8-encoded string slice to initialize a new protocol description object.

 * - On success, initializes `out` and returns 0

 * - On failure, stores an error string (see `reowolf_error_peek`) and returns -1

 */

Arc_ProtocolDescription *protocol_description_parse(const uint8_t *pdl, uintptr_t pdl_len);

/**

 * 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

 * If len is NULL, it will not written to.

 */

const uint8_t *reowolf_error_peek(uintptr_t *len);

#endif /* REOWOLF_HEADER_DEFINED */

use crate::{common::*, runtime::*};

use core::{cell::RefCell, convert::TryFrom};

use std::os::raw::c_int;

use std::slice::from_raw_parts as slice_from_raw_parts;

#[cfg(all(target_os = "linux", feature = "ffi_pseudo_socket_api"))]

/// cbindgen:ignore

pub mod pseudo_socket_api;

// Temporary simplfication: ignore ipv6. To revert, just refactor this structure and its usages

#[repr(C)]

pub struct FfiSocketAddr {

    pub ipv4: [u8; 4],

    pub port: u16,

}

impl Into<SocketAddr> for FfiSocketAddr {

    fn into(self) -> SocketAddr {

        (self.ipv4, self.port).into()

    }

}

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

#[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 debug_store<E: Debug>(&mut self, error: &E) {

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

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

    }

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

        STORED_ERROR.with(|stored_error| {

            let mut stored_error = stored_error.borrow_mut();

            stored_error.clear();

            stored_error.debug_store(error);

        })

    }

    fn bytes_store(&mut self, bytes: &[u8]) {

        let _ = self.buf.write_all(bytes);

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

    }

    fn tl_bytes_store(bytes: &[u8]) {

        STORED_ERROR.with(|stored_error| {

            let mut stored_error = stored_error.borrow_mut();

            stored_error.clear();

            stored_error.bytes_store(bytes);

        })

    }

    fn tl_clear() {

        STORED_ERROR.with(|stored_error| {

            let mut stored_error = stored_error.borrow_mut();

            stored_error.clear();

        })

    }

    fn tl_bytes_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());

}

pub const RW_OK: c_int = 0;

pub const RW_TL_ERR: c_int = -1;

pub const RW_WRONG_STATE: c_int = -2;

pub const RW_LOCK_POISONED: c_int = -3;

pub const RW_CLOSE_FAIL: c_int = -4;

pub const RW_BAD_FD: c_int = -5;

pub const RW_CONNECT_FAILED: c_int = -6;

pub const RW_WOULD_BLOCK: c_int = -7;

pub const RW_BAD_SOCKADDR: c_int = -8;

///////////////////// REOWOLF //////////////////////////

/// 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

/// If len is NULL, it will not written to.

#[no_mangle]

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

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

    if !len.is_null() {

        len.write(err_len);

    }

    err_ptr

}

///////////////////// PROTOCOL DESCRIPTION //////////////////////////

/// Parses the utf8-encoded string slice to initialize a new protocol description object.

/// - On success, initializes `out` and returns 0

/// - On failure, stores an error string (see `reowolf_error_peek`) and returns -1

#[no_mangle]

pub unsafe extern "C" fn protocol_description_parse(

    pdl: *const u8,

    pdl_len: usize,

) -> *mut Arc<ProtocolDescription> {

    StoredError::tl_clear();

    match ProtocolDescription::parse(&*slice_from_raw_parts(pdl, pdl_len)) {

        Ok(new) => Box::into_raw(Box::new(Arc::new(new))),

        Err(err) => {