use crate::runtime2::inbox::{OutgoingMessage, SolutionMessage};

    PrivateInbox, PublicInbox, OutgoingDataMessage, DataMessage, SyncMessage,

    /// Accepts a synchronous message and combines it with the locally stored

    /// solution(s).

    pub fn insert_sync_message(&mut self, message: SyncMessage, global: &GlobalStore, results: &mut RunDeltaState) {

        debug_assert!(!message.to_visit.contains(&self.id)); // own ID already removed

        debug_assert!(message.constraints.iter().any(|v| v.connector_id == self.id)); // we have constraints

        // TODO: Optimize, use some kind of temp workspace vector

        let mut execution_path_branch_ids = Vec::new();

        if self.sync_finished_last_handled != 0 {

            // We have some solutions to match against

            let constraints_index = message.constraints

                .iter()

                .position(|v| v.connector_id == self.id)

                .unwrap();

            let constraints = &message.constraints[constraints_index].constraints;

            debug_assert!(!constraints.is_empty());

            // Note that we only iterate over the solutions we've already

            // handled ourselves, not necessarily

            let mut branch_index = self.sync_finished.first;

            'branch_loop: loop {

                // Load solution branch

                let branch = &self.branches[branch_index as usize];

                execution_path_branch_ids.clear();

                self.branch_ids_of_execution_path(BranchId::new(branch_index), &mut execution_path_branch_ids);

                // Check if the branch matches all of the applied constraints

                for constraint in constraints {

                    match constraint {

                        SyncBranchConstraint::SilentPort(silent_port_id) => {

                            let port_index = self.ports.get_port_index(*silent_port_id);

                            if port_index.is_none() {

                                // Nefarious peer

                                continue 'branch_loop;

                            }

                            let port_index = port_index.unwrap();

                            let mapping = self.ports.get_port(branch_index, port_index);

                            debug_assert!(mapping.is_assigned);

                            if mapping.num_times_fired != 0 {

                                // Not silent, constraint not satisfied

                                continue 'branch_loop;

                            }

                        },

                        SyncBranchConstraint::BranchNumber(expected_branch_id) => {

                            if !execution_path_branch_ids.contains(expected_branch_id) {

                                // Not the expected execution path, constraint not satisfied

                                continue 'branch_loop;

                            }

                        },

                        SyncBranchConstraint::PortMapping(port_id, expected_branch_id) => {

                            let port_index = self.ports.get_port_index(*port_id);

                            if port_index.is_none() {

                                // Nefarious peer

                                continue 'branch_loop;

                            }

                            let port_index = port_index.unwrap();

                            let mapping = self.ports.get_port(branch_index, port_index);

                            if mapping.last_registered_branch_id != expected_branch_id {

                                // Not the expected interaction on this port, constraint not satisfied

                                continue 'branch_loop;

                            }

                        },

                    }

                }

                // If here, then all of the external constraints were satisfied

                // for the current branch. But the branch itself also imposes

                // constraints. So while building up the new solution, make sure

                // that those are satisfied as well.

                // TODO: Code below can probably be merged with initial solution

                //  generation.

                // - clone old solution so we can add to it

                let mut new_solution = message.clone();

                // - determine the initial port mapping

                let num_ports = self.ports.num_ports();

                let mut new_solution_mapping = Vec::with_capacity(num_ports);

                for port_index in 0..self.ports.num_ports() {

                    let port_id = self.ports.get_port_id(port_index);

                    let mapping = self.ports.get_port(branch_index, port_index);

                    new_solution_mapping.push((port_id, mapping.last_registered_branch_id));

                }

                // - replace constraints with a local solution

                new_solution.constraints.remove(constraints_index);

                new_solution.local_solutions.push(SyncConnectorSolution{

                    connector_id: self.id,

                    terminating_branch_id: BranchId::new(branch_index),

                    execution_branch_ids: execution_path_branch_ids.clone(),

                    final_port_mapping: new_solution_mapping,

                });

                // - do a second pass on the ports to generate and add the

                //   constraints that should be applied to other connectors

                for port_index in 0..self.ports.num_ports() {

                    let port_id = self.ports.get_port_id(port_index);

                    let (peer_connector_id, peer_port_id, peer_is_getter) = {

                        let key = unsafe{ ConnectorKey::from_id(self.id) };

                        let port = global.ports.get(&key, port_id);

                        (port.peer_connector, port.peer_id, port.kind == PortKind::Putter)

                    };

                    let mapping = self.ports.get_port(branch_index, port_index);

                    let constraint = if mapping.num_times_fired == 0 {

                        SyncBranchConstraint::SilentPort(peer_port_id)

                    } else {

                        if peer_is_getter {

                            SyncBranchConstraint::PortMapping(peer_port_id, mapping.last_registered_branch_id)

                        } else {

                            SyncBranchConstraint::BranchNumber(mapping.last_registered_branch_id)

                        }

                    };

                    match new_solution.add_or_check_constraint(peer_connector_id, constraint) {

                        None => continue 'branch_loop,

                        Some(false) => continue 'branch_loop,

                        Some(true) => {},

                    }

                }

                // If here, then the newly generated solution is completely

                // compatible.

                Self::submit_sync_solution(new_solution, results);

                // Consider the next branch

                if branch_index == self.sync_finished_last_handled {

                    // At the end of the previously handled solutions

                    break;

                }

                debug_assert!(branch.next_branch_in_queue.is_some()); // because we cannot be at the end of the queue

                branch_index = branch.next_branch_in_queue.unwrap();

            }

        }

                // Retrieve first element in queue

                loop {

                    let branch_id = BranchId::new(next_id);

                    let branch = &self.branches[next_id as usize];

                    let branch_next = branch.next_branch_in_queue;

                    // Turn local solution into a message and send it along

                    // TODO: Like `ports` access, also revise the construction of this `key`, should not be needed

                    let connector_key = unsafe{ ConnectorKey::from_id(self.id) };

                    let solution_message = self.generate_initial_solution_for_branch(branch_id, &connector_key, global);

                    if let Some(valid_solution) = solution_message {

                        Self::submit_sync_solution(valid_solution, results);

                    } else {

                        // Branch is actually invalid, but we only just figured

                        // it out. We need to mark it as invalid to prevent

                        // future use

                        Self::remove_branch_from_queue(&mut self.branches, &mut self.sync_finished, branch_id);

                        if branch_id == self.sync_finished_last_handled {

                            self.sync_finished_last_handled = self.sync_finished.last;

                        }

                        let branch = &mut self.branches[next_id as usize];

                        branch.sync_state = SpeculativeState::Inconsistent;

                    }

                    match branch_next {

                        Some(id) => next_id = id,

                        None => break,

                    }

                }

                self.sync_finished_last_handled = next_id;

                    let message = OutgoingDataMessage {

                    results.outbox.push(OutgoingMessage::Data(message));

    /// Removes branch from linked-list queue. Walks through the entire list to

    /// find the element (!). Assumption is that this is not called often.

    fn remove_branch_from_queue(

        branches: &mut Vec<Branch>, queue: &mut BranchQueue, to_delete: BranchId,

    ) {

        debug_assert!(to_delete.is_valid()); // we're deleting a valid item

        debug_assert!(queue.first != 0 && queue.last != 0); // queue isn't empty to begin with

        // Retrieve branch and its next element

        let branch_to_delete = &mut branches[to_delete.index as usize];

        let branch_next_index_option = branch_to_delete.next_branch_in_queue;

        let branch_next_index_unwrapped = branch_next_index_option.unwrap_or(0);

        branch_to_delete.next_branch_in_queue = None;

        // Walk through all elements in queue to find branch to delete

        let mut prev_index = 0;

        let mut next_index = queue.first;

        while next_index != 0 {

            if next_index == to_delete.index {

                // Found the element we're going to delete

                // - check if at the first element or not

                if prev_index == 0 {

                    queue.first = branch_next_index_unwrapped;

                } else {

                    let prev_branch = &mut branches[prev_index as usize];

                    prev_branch.next_branch_in_queue = branch_next_index_option;

                }

                // - check if at last element or not (also takes care of "no elements left in queue")

                if branch_next_index_option.is_none() {

                    queue.last = prev_index;

                }

                return;

            }

            prev_index = next_index;

        }

        // If here, then we didn't find the element

        panic!("branch does not exist in provided queue");

    }

    fn submit_sync_solution(partial_solution: SyncMessage, results: &mut RunDeltaState) {

        if partial_solution.to_visit.is_empty() {

            // Solution is completely consistent

            let mut full_solution = SolutionMessage{

                local_solutions: Vec::with_capacity(partial_solution.local_solutions.len()),

            };

            for local_solution in &partial_solution.local_solutions {

                full_solution.local_solutions.push((local_solution.connector_id, local_solution.terminating_branch_id));

            }

            results.outbox.push(OutgoingMessage::Solution(full_solution));

        } else {

            // Still have connectors to visit

            results.outbox.push(OutgoingMessage::Sync(partial_solution));

        }

    }

pub struct OutgoingDataMessage {

pub enum OutgoingMessage {

    Data(OutgoingDataMessage),

    Sync(SyncMessage),

    Solution(SolutionMessage),

}

#[derive(Clone)]

#[derive(Clone)]

#[derive(Clone)]

#[derive(Clone)]

            self.add_constraint(connector_id, constraint);

pub struct SolutionMessage {

    pub local_solutions: Vec<(ConnectorId, BranchId)>,

}

    Solution(SolutionMessage),  // solution message, finishing a sync round

                        },

                        Message::Sync(message) => {

                            scheduled.connector

                        },

                        Message::Solution(solution) => {