#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

                           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.

    }

}

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

#[no_mangle]

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

    drop(Box::from_raw(pd))

}

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

#[no_mangle]

pub unsafe extern "C" fn protocol_description_clone(

    pd: &Arc<ProtocolDescription>,

) -> *mut Arc<ProtocolDescription> {

    Box::into_raw(Box::new(pd.clone()))

}

///////////////////// CONNECTOR //////////////////////////

#[no_mangle]

pub unsafe extern "C" fn connector_new_logging_with_id(

    pd: &Arc<ProtocolDescription>,

    path_ptr: *const u8,

    path_len: usize,

    connector_id: ConnectorId,

) -> *mut Connector {

    StoredError::tl_clear();

    let path_bytes = &*slice_from_raw_parts(path_ptr, path_len);

    let path_str = match std::str::from_utf8(path_bytes) {

        Ok(path_str) => path_str,

        Err(err) => {

            StoredError::tl_debug_store(&err);

            return std::ptr::null_mut();

        }

    };

    match std::fs::File::create(path_str) {

        Ok(file) => {

            let file_logger = Box::new(FileLogger::new(connector_id, file));

            let c = Connector::new(file_logger, pd.clone(), connector_id);

            Box::into_raw(Box::new(c))

        }

        Err(err) => {

            StoredError::tl_debug_store(&err);

            std::ptr::null_mut()

        }

    }

}

#[no_mangle]

pub unsafe extern "C" fn connector_new_logging(

    pd: &Arc<ProtocolDescription>,

    path_ptr: *const u8,

    path_len: usize,

) -> *mut Connector {

    connector_new_logging_with_id(pd, path_ptr, path_len, Connector::random_id())

}

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

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

#[no_mangle]

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

}

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

/// Usable in {setup, communication} states.

#[no_mangle]

pub unsafe extern "C" fn connector_destroy(connector: *mut Connector) {

    drop(Box::from_raw(connector))

}

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

#[no_mangle]

pub unsafe extern "C" fn connector_add_port_pair(

    connector: &mut Connector,

    out_putter: *mut PortId,

    out_getter: *mut PortId,

) {

    let [o, i] = connector.new_port_pair();

    if !out_putter.is_null() {

        out_putter.write(o);

    }

    if !out_getter.is_null() {

        out_getter.write(i);

    }

}

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

#[no_mangle]

pub unsafe extern "C" fn connector_add_component(

    connector: &mut Connector,

    ident_ptr: *const u8,

    ident_len: usize,

    ports_ptr: *const PortId,

    ports_len: usize,

) -> c_int {

    StoredError::tl_clear();

    match connector.add_component(

        &*slice_from_raw_parts(ident_ptr, ident_len),

        &*slice_from_raw_parts(ports_ptr, ports_len),

    ) {

        Ok(()) => RW_OK,

        Err(err) => {

            StoredError::tl_debug_store(&err);

            RW_TL_ERR

        }

    }

}

/// Given

use crate::common::*;

#[derive(Debug)]

pub enum ConnectError {

    BindFailed(SocketAddr),

    UdpConnectFailed(SocketAddr),

    PollInitFailed,

    Timeout,

    PollFailed,

    AcceptFailed(SocketAddr),

    AlreadyConnected,

    PortPeerPolarityMismatch(PortId),

    NetEndpointSetupError(SocketAddr, NetEndpointError),

    SetupAlgMisbehavior,

}

#[derive(Eq, PartialEq, Copy, Clone, Debug)]

pub enum AddComponentError {

    DuplicatePort(PortId),

    NoSuchComponent,

    NonPortTypeParameters,

    CannotMovePort(PortId),

    WrongNumberOfParamaters { expected: usize },

    UnknownPort(PortId),

    WrongPortPolarity { port: PortId, expected_polarity: Polarity },

    DuplicateMovedPort(PortId),

}

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

#[derive(Debug, Clone)]

pub enum UnrecoverableSyncError {

    PollFailed,

    BrokenNetEndpoint { index: usize },

    BrokenUdpEndpoint { index: usize },

    MalformedStateError(MalformedStateError),

}

#[derive(Debug, Clone)]

pub enum SyncError {

    NotConnected,

    InconsistentProtoComponent(ComponentId),

    RoundFailure,

    Unrecoverable(UnrecoverableSyncError),

}

#[derive(Debug, Clone)]

pub enum MalformedStateError {

    PortCannotPut(PortId),

    GetterUnknownFor { putter: PortId },

}

#[derive(Debug, Clone)]

pub enum NetEndpointError {

    MalformedMessage,

    BrokenNetEndpoint,

}

#[derive(Debug)]

pub enum PortOpError {

    WrongPolarity,

    const BOTH: Interest = Interest::READABLE.add(Interest::WRITABLE);

    const RETRY_PERIOD: Duration = Duration::from_millis(200);

    // The data for a net endpoint's setup in progress

    struct NetTodo {