#[derive(Debug)]

pub enum ComponentCreationError {

    ModuleDoesntExist,

    DefinitionDoesntExist,

    DefinitionNotComponent,

    InvalidNumArguments,

    InvalidArgumentType(usize),

}

    #[deprecated]

    #[deprecated]

    // TODO: Ofcourse, rename this at some point, perhaps even remove it in its

    //  entirety. Find some way to interface with the parameter's types.

    pub(crate) fn new_component_v2(

        &self, module_name: &[u8], identifier: &[u8], arguments: ValueGroup

    ) -> Result<ComponentState, ComponentCreationError> {

        // Find the module in which the definition can be found

        let module_root = self.lookup_module_root(module_name);

        if module_root.is_none() {

            return Err(ComponentCreationError::ModuleDoesntExist);

        }

        let module_root = module_root.unwrap();

        let root = &self.heap[module_root];

        let definition_id = root.get_definition_ident(&heap, identifier);

        if definition_id.is_none() {

            return Err(ComponentCreationError::DefinitionDoesntExist);

        }

        let definition_id = definition_id.unwrap();

        let definition = &self.heap[definition_id];

        if !definition.is_component() {

            return Err(ComponentCreationError::DefinitionNotComponent);

        }

        // Make sure that the types of the provided value group matches that of

        // the expected types.

        let definition = definition.as_component();

        if !definition.poly_vars.is_empty() {

            return Err(ComponentCreationError::DefinitionNotComponent);

        }

        // - check number of arguments

        let expr_data = self.types.get_procedure_expression_data(&definition_id, 0);

        if expr_data.arg_types.len() != arguments.values.len() {

            return Err(ComponentCreationError::InvalidNumArguments);

        }

        // - for each argument try to make sure the types match

        for arg_idx in 0..arguments.values.len() {

            let expected_type = &expr_data.arg_types[arg_idx];

            let provided_value = &arguments.values[arg_idx];

            if !self.verify_same_type(expected_type, 0, &arguments, provided_value) {

                return Err(ComponentCreationError::InvalidArgumentType(arg_idx));

            }

        }

        // By now we're sure that all of the arguments are correct. So create

        // the connector.

        return Ok(ComponentState{

            prompt: Prompt::new(&self.types, &self.heap, def, 0, arguments),

        });

    }

    fn verify_same_type(&self, expected: &ConcreteType, expected_idx: usize, arguments: &ValueGroup, argument: &Value) -> bool {

        use ConcreteTypePart as CTP;

        macro_rules! match_variant {

            ($value:expr, $variant:expr) => {

                if let $variant(_) = $value { true } else { false }

            };

        }

        match &expected.parts[expected_idx] {

            CTP::Void | CTP::Message | CTP::Slice | CTP::Function(_, _) | CTP::Component(_, _) => unreachable!(),

            CTP::Bool => match_variant!(argument, Value::Bool),

            CTP::UInt8 => match_variant!(argument, Value::UInt8),

            CTP::UInt16 => match_variant!(argument, Value::UInt16),

            CTP::UInt32 => match_variant!(argument, Value::UInt32),

            CTP::UInt64 => match_variant!(argument, Value::UInt64),

            CTP::SInt8 => match_variant!(argument, Value::SInt8),

            CTP::SInt16 => match_variant!(argument, Value::SInt16),

            CTP::SInt32 => match_variant!(argument, Value::SInt32),

            CTP::SInt64 => match_variant!(argument, Value::SInt64),

            CTP::Character => match_variant!(argument, Value::Char),

            CTP::String => {

                // Match outer string type and embedded character types

                if let Value::String(heap_pos) = argument {

                    for element in &arguments.regions[*heap_pos as usize] {

                        if let Value::Char(_) = element {} else {

                            return false;

                        }

                    }

                } else {

                    return false;

                }

                return true;

            },

            CTP::Array => {

                if let Value::Array(heap_pos) = argument {

                    let heap_pos = *heap_pos;

                    for element in &arguments.regions[heap_pos as usize] {

                        if !self.verify_same_type(expected, expected_idx + 1, arguments, element) {

                            return false;

                        }

                    }

                    return true;

                } else {

                    return false;

                }

            },

            CTP::Input => match_variant!(argument, Value::Input),

            CTP::Output => match_variant!(argument, Value::Output),

            CTP::Instance(_definition_id, _num_embedded) => {

                todo!("implement full type checking on user-supplied arguments");

                return false;

            },

        }

    }

        let (definition_id, procedure_arguments) = match &self.definition_type {

            DefinitionType::Component(id) => {

                let definition = &ctx.heap[*id];

                (id.upcast(), &definition.parameters)

            },

            DefinitionType::Function(id) => {

                let definition = &ctx.heap[*id];

                (id.upcast(), &definition.parameters)

            },

        debug_assert!(target.arg_types.is_empty()); // makes sure we never queue a procedure's type inferencing twice

        debug_assert!(target.expr_data.is_empty());

        // - Write the arguments to the procedure

        target.arg_types.reserve(procedure_arguments.len());

        for argument_id in procedure_arguments {

            let mut concrete = ConcreteType::default();

            let argument_type = self.var_types.get(argument_id).unwrap();

            argument_type.var_type.write_concrete_type(&mut concrete);

            target.arg_types.push(concrete);

        }

        // - Write the expression data

    pub arg_types: Vec<ConcreteType>,

            arg_types: Vec::new(),

use std::sync::atomic::AtomicBool;

use crate::runtime2::inbox::{PrivateInbox, PublicInbox, OutgoingMessage};

    inbox: HashMap<PortIdLocal, OutgoingMessage>, // TODO: @temporary, remove together with fires()

    pub(crate) fn new_initial_branch(component_state: ComponentState) -> Self {

pub(crate) struct ConnectorPorts {

    pub owned_ports: Vec<PortIdLocal>,

    pub port_mapping: Vec<PortAssignment>

/// threads.

    pub inbox: PublicInbox,

    pub sleeping: AtomicBool,

            inbox: PublicInbox::new(),

            sleeping: AtomicBool::new(false),

// TODO: Do this outside of the connector, create a wrapping struct

    pub inbox: PrivateInbox,

            inbox: PrivateInbox::new(),

                    let message = OutgoingMessage {

    pub outbox: Vec<OutgoingMessage>,

pub(crate) fn find_ports_in_value_group(value_group: &ValueGroup, ports: &mut Vec<PortIdLocal>) {

use super::inbox::PublicInbox;

use super::scheduler::Router;

use std::sync::{Barrier, RwLock, RwLockReadGuard};

use std::sync::atomic::AtomicBool;

/// A kind of token that, once obtained, allows mutable access to a connector.

/// We're trying to use move semantics as much as possible: the owner of this

/// key is the only one that may execute the connector's code.

pub(crate) struct ConnectorKey {

    pub index: u32, // of connector

}

impl ConnectorKey {

    /// Downcasts the `ConnectorKey` type, which can be used to obtain mutable

    /// access, to a "regular ID" which can be used to obtain immutable access.

    #[inline]

    pub fn downcast(&self) -> ConnectorId {

        return ConnectorId(self.index);

    }

    /// Turns the `ConnectorId` into a `ConnectorKey`, marked as unsafe as it

    /// bypasses the type-enforced `ConnectorKey`/`ConnectorId` system

    #[inline]

    pub unsafe fn from_id(id: ConnectorId) -> ConnectorKey {

        return ConnectorKey{ index: id.0 };

    }

}

/// A kind of token that allows shared access to a connector. Multiple threads

/// may hold this

#[derive(Copy, Clone)]

pub(crate) struct ConnectorId(u32);

impl ConnectorId {

    // TODO: Like the other `new_invalid`, maybe remove

    #[inline]

    pub fn new_invalid() -> ConnectorId {

        return ConnectorId(u32::MAX);

    }

}

pub struct ScheduledConnector {

    pub connector: Connector,

    pub public: ConnectorPublic,

    pub router: Router

    connectors: RawVec<*mut ScheduledConnector>,

    pub(crate) fn get_shared(&self, connector_id: ConnectorId) -> &'static ConnectorPublic {

            let connector = lock.connectors.get(connector_id.0 as usize);

    pub(crate) fn get_mut(&self, key: &ConnectorKey) -> &'static mut ScheduledConnector {

        let connector = ScheduledConnector{

            connector,

            public: ConnectorPublic::new(),

            router: Router::new(),

        };

    pub(crate) fn create_channel(&self, creating_connector: Option<ConnectorId>) -> Channel {

        fn reserve_port(lock: &mut std::sync::RwLockWriteGuard<'_, PortStoreInner>, kind: PortKind, creating_connector: Option<ConnectorId>) -> u32 {

            let (ownership, connector_id) = if creating_connector.is_some() {

                (PortOwnership::Owned, creating_connector.unwrap())

            } else {

                (PortOwnership::Unowned, ConnectorId::new_invalid())

            };

///     This includes the `should_exit` and `did_exit` pair!

    pub should_exit: AtomicBool,    // signal threads to exit

            should_exit: AtomicBool::new(false),

/**

inbox.rs

Contains various types of inboxes and message types for the connectors. There

are two kinds of inboxes:

The `PublicInbox` is a simple message queue. Messages are put in by various

threads, and they're taken out by a single thread. These messages may contain

control messages and may be filtered or redirected by the scheduler.

The `PrivateInbox` is a temporary storage for all messages that are received

within a certain sync-round.

**/

use super::connector::{BranchId, PortIdLocal};

use super::global_store::ConnectorId;

pub struct OutgoingMessage {

/// A message that has been delivered (after being imbued with the receiving

/// port by the scheduler) to a connector.

pub struct DataMessage {

    pub sending_connector: ConnectorId,

/// A control message. These might be sent by the scheduler to notify eachother

/// of asynchronous state changes.

pub struct ControlMessage {

    pub id: u32, // generic identifier, used to match request to response

    pub sender: ConnectorId,

    pub content: ControlMessageVariant,

}

pub enum ControlMessageVariant {

    ChangePortPeer(PortIdLocal, ConnectorId), // specified port has a new peer, sent to owner of said port

    Ack, // acknowledgement of previous control message, matching occurs through control message ID.

}

/// Generic message in the `PublicInbox`, handled by the scheduler (which takes

/// out and handles all control message and potential routing). The correctly

/// addressed `Data` variants will end up at the connector.

pub enum Message {

    Data(DataMessage),

    Control(ControlMessage),

}

/// The public inbox of a connector. The thread running the connector that owns

/// this inbox may retrieved from it. Non-owning threads may only put new

/// messages inside of it.

// TODO: @Optimize, lazy concurrency. Probably ringbuffer with read/write heads.

//  Should behave as a MPSC queue.

pub struct PublicInbox {

    messages: Mutex<VecDeque<Message>>,

impl PublicInbox {

    pub fn new() -> Self {

        Self{

            messages: Mutex::new(VecDeque::new()),

        }

    }

    pub fn insert_message(&self, message: Message) {

        let mut lock = self.messages.lock().unwrap();

        lock.push_back(message);

    }

    pub fn take_message(&self) -> Option<Message> {

        let mut lock = self.messages.lock().unwrap();

        return lock.pop_front();

    }

    pub fn is_empty(&self) -> bool {

        let lock = self.messages.lock().unwrap();

        return lock.is_empty();

    }

}

pub struct PrivateInbox {

    messages: Vec<DataMessage>,

    len_read: usize,

impl PrivateInbox {

            messages: Vec::new(),

            len_read: 0,

    pub fn insert_message(&mut self, message: DataMessage) {

        for existing in self.messages.iter() {

        self.messages.push(message);

            messages: &self.messages,

            max_index: self.len_read,

    pub fn next_message(&mut self) -> Option<&DataMessage> {

        if self.len_read == self.messages.len() {

        let to_return = &self.messages[self.len_read];

        self.len_read += 1;

        return Some(to_return);

        self.len_read = 0;

    messages: &'i Vec<DataMessage>,

    type Item = &'m DataMessage;

            let cur_message = &self.messages[self.next_index];

        let message = &self.messages[self.next_index];

// Structure of module

mod inbox;

// Imports

use std::sync::Arc;

use std::thread::{self, JoinHandle};

use crate::protocol::eval::*;

use crate::{common::Id, PortId, ProtocolDescription};

use global_store::GlobalStore;

use scheduler::Scheduler;

use crate::protocol::ComponentCreationError;

use crate::runtime2::connector::{Branch, Connector, find_ports_in_value_group};

// Runtime API

pub struct Runtime {

    global_store: Arc<GlobalStore>,

    protocol_description: Arc<ProtocolDescription>,

    schedulers: Vec<JoinHandle<()>>

}

impl Runtime {

    pub fn new(num_threads: usize, protocol_description: Arc<ProtocolDescription>) -> Runtime {

        // Setup global state

        assert!(num_threads > 0, "need a thread to run connectors");

        let global_store = Arc::new(GlobalStore::new());

        // Launch threads

        let mut schedulers = Vec::with_capacity(num_threads);

        for _ in 0..num_threads {

            let mut scheduler = Scheduler::new(global_store.clone(), protocol_description.clone());

            let thread = thread::spawn(move || {

                scheduler.run();

            });

            schedulers.push(thread);

        }

        // Move innards into runtime struct

        return Runtime{

            global_store,

            protocol_description,

            schedulers,

        }

    }

    /// Returns (putter port, getter port)

    pub fn create_channel(&self) -> (Value, Value) {

        let channel = self.global_store.ports.create_channel(None);

        let putter_value = Value::Output(PortId(Id{

            connector_id: u32::MAX,

            u32_suffix: channel.putter_id,

        }));

        let getter_value = Value::Input(PortId(Id{

            connector_id: u32::MAX,

            u32_suffix: channel.getter_id,

        }));

        return (putter_value, getter_value);

    }

    pub fn create_connector(&mut self, module: &str, procedure: &str, values: ValueGroup) -> Result<(), ComponentCreationError> {

        // TODO: Remove component creation function from PD, should not be concerned with it

        // Create the connector and mark the ports as now owned by the

        // connector

        let mut port_ids = Vec::new();

        find_ports_in_value_group(&values, &mut port_ids);

        let component_state = self.protocol_description.new_component_v2(module.as_bytes(), procedure.as_bytes(), values)?;

        let connector = Connector::new(0, Branch::new_initial_branch(component_state), port_ids.clone());

        let connector_key = self.global_store.connectors.create(connector);

        for port_id in port_ids {

            let port = self.global_store.ports.get(&connector_key, port_id);

            port.owning_connector = connector_key.downcast();

            port.peer_connector

            // TODO: Note that we immediately need to notify the other side of the connector that

            //  the port has moved!

        }

    }

}

impl Drop for Runtime {

    fn drop(&mut self) {

    }

}

use super::global_store::ConnectorId;