self.consensus.handle_received_sync_message(message, ctx);

use crate::runtime2::inbox2::{DataHeader, DataMessageFancy, MessageFancy, SyncContent, SyncHeader, SyncMessageFancy};

use crate::runtime2::port::{ChannelId, Port, PortIdLocal};

    port_mapping: Vec<(ChannelId, BranchId)>,

}

pub(crate) struct GlobalSolution {

    branches: Vec<(ConnectorId, BranchId)>,

    port_mapping: Vec<(ChannelId, BranchId)>, // TODO: This can go, is debugging info

    solution_combiner: SolutionCombiner,

            solution_combiner: SolutionCombiner::new(),

                let port_desc = ctx.get_port_by_id(port.port_id).unwrap();

                    port_desc.channel_id,

            self.send_or_store_local_solution(local_solution, ctx);

    /// Handles a new data message by handling the data and sync header, and

    /// checking which *existing* branches *can* receive the message. So two

    /// cautionary notes:

    /// 1. A future branch might also be able to receive this message, see the

    ///     `branch_can_receive` function.

    /// 2. We return the branches that *can* receive the message, you still

    ///     have to explicitly call `notify_of_received_message`.

    pub fn handle_new_data_message(&mut self, exec_tree: &ExecTree, message: &DataMessageFancy, ctx: &mut ComponentCtxFancy, target_ids: &mut Vec<BranchId>) {

        self.handle_received_data_header(exec_tree, &message.data_header, target_ids);

        self.handle_received_sync_header(&message.sync_header, ctx);

    }

    /// Handles a new sync message by handling the sync header and the contents

    /// of the message. Returns `Some` with the branch ID of the global solution

    /// if the sync solution has been found.

    pub fn handle_new_sync_message(&mut self, message: SyncMessageFancy, ctx: &mut ComponentCtxFancy) -> Option<BranchId> {

        self.handle_received_sync_header(&message.sync_header, ctx);

        // And handle the contents

        debug_assert_eq!(message.target_component_id, ctx.id);

        match message.content {

            SyncContent::Notification => {

                // We were just interested in the header

                return None;

            },

            SyncContent::LocalSolution(solution) => {

                // We might be the leader, or earlier messages caused us to not

                // be the leader anymore.

                self.send_or_store_local_solution(solution, ctx);

                return None;

            },

            SyncContent::GlobalSolution(solution) => {

                // Take branch of interest and return it.

                let (_, branch_id) = solution.branches.iter()

                    .find(|(connector_id, _)| connector_id == ctx.id)

                    .unwrap();

                return Some(*branch_id);

            }

        }

    }

    /// Checks data header and consults the stored port mapping and the

    /// execution tree to see which branches may receive the data message's

    /// contents.

    fn handle_received_data_header(&mut self, exec_tree: &ExecTree, data_header: &DataHeader, target_ids: &mut Vec<BranchId>) {

        for branch in exec_tree.iter_queue(QueueKind::AwaitingMessage, None) {

            if branch.awaiting_port == data_header.target_port {

                // Found a branch awaiting the message, but we need to make sure

                // the mapping is correct

                if self.branch_can_receive(branch.id, data_header) {

                    target_ids.push(branch.id);

                }

            }

        }

    }

    fn handle_received_sync_header(&mut self, sync_header: &SyncHeader, ctx: &mut ComponentCtxFancy) {

            if let Some(global_solution) = self.solution_combiner.add_solution_and_check_for_global_solution(solution) {

            }

        for local_solution in self.solution_combiner.drain() {

    port_mapping: Vec<(ChannelId, BranchId)>,

    involved_channels: Vec<ChannelId>,

pub(crate) struct SolutionCombiner {

impl SolutionCombiner {

    fn add_solution_and_check_for_global_solution(&mut self, solution: LocalSolution) -> Option<Vec<(ConnectorId, BranchId)>> {

                        involved_channels: matching_ports,

                num_ports_in_peers += peer.involved_channels.len();

                let mut num_ports_in_peers = component_match.involved_channels.len();

                    num_ports_in_peers += existing_peer.involved_channels.len();

                    involved_channels: component_match.involved_channels.clone(),

        return self.check_new_solution(component_index, solution_index);

    fn check_new_solution(&self, component_index: usize, solution_index: usize) -> Option<Vec<(ConnectorId, BranchId)>> {

        if !self.can_have_solution() {

            return None;

        }

        // By now we're certain that all peers are present. So once our

        // backtracking solution stack is as long as the number of components,

        // then we have found a global solution.

        let mut check_stack = Vec::new();

        let mut check_from = 0;

        check_stack.push((component_index, solution_index));

        'checking_loop: while check_from < check_stack.len() {

            // Prepare for next iteration

            let new_check_from = check_stack.len();

            // Go through all entries on the checking stack. Each entry

            // corresponds to a component's solution. We check that one against

            // previously added ones on the stack, and if they're not already

            // added we push them onto the check stack.

            for check_idx in check_from..new_check_from {

                // Take the current solution

                let (component_index, solution_index) = check_stack[check_idx];

                debug_assert!(!self.local[component_index].solutions.is_empty());

                let cur_solution = &self.local[component_index].solutions[solution_index];

                // Go through the matches and check if they're on the stack or

                // should be added to the stack.

                for cur_match in &cur_solution.matches {

                    let mut is_already_on_stack = false;

                    let mut has_same_solution = false;

                    for existing_check_idx in 0..check_from {

                        let (existing_component_index, existing_solution_index) = check_stack[existing_check_idx];

                        if existing_component_index == cur_match.target_index {

                            // Already lives on the stack, so the match MUST

                            // contain the same solution index if the checked

                            // local solution is agreeable with the (partially

                            // determined) global solution.

                            is_already_on_stack = true;

                            if cur_match.match_indices.contains(&existing_solution_index) {

                                has_same_solution = true;

                                break;

                            }

                        }

                    }

                    if is_already_on_stack {

                        if !has_same_solution {

                            // We have an inconsistency, so we need to go back

                            // in our stack, and try the next solution

                            let (last_component_index, last_solution_index) = check_stack[check_from];

                            check_stack.truncate(check_from);

                            if check_stack.is_empty() {

                                // The starting point does not yield a valid

                                // solution

                                return None;

                            }

                            // Try the next one

                            let last_component = &self.local[last_component_index];

                            let new_solution_index = last_solution_index + 1;

                            if new_solution_index >= last_component.solutions.len() {

                                // No more things to try, again: no valid

                                // solution

                                return None;

                            }

                            check_stack.push((last_component_index, new_solution_index));

                            continue 'checking_loop;

                        } // else: we're fine, the solution is agreeable

                    } else {

                        check_stack.push((cur_match.target_index, 0))

                    }

                }

            }

            check_from = new_check_from;

        }

        // Because of our earlier checking if we can have a solution at

        // all (all components have a peer), and the exit condition of the while

        // loop: if we're here, then we have a global solution

        debug_assert_eq!(check_stack.len(), self.local.len());

        let mut global_solution = Vec::with_capacity(check_stack.len());

        for (component_index, solution_index) in check_stack {

            let component = &self.local[component_index];

            let solution = &component.solutions[solution_index];

            global_solution.push((component.component, solution.final_branch_id));

        }

        return Some(global_solution);

    /// Turns the entire (partially resolved) global solution back into local

    /// solutions to ship to another component.

    // TODO: Don't do this, kind of wasteful since a lot of processing has

    //  already been performed.

    fn drain(&mut self) -> Vec<LocalSolution> {

        let mut reserve_len = 0;

        for component in &self.local {

            reserve_len += component.solutions.len();

        }

        let mut solutions = Vec::with_capacity(reserve_len);

        for component in self.local.drain(..) {

            for solution in component.solutions {

                solutions.push(LocalSolution{

                    component: component.component,

                    final_branch_id: solution.final_branch_id,

                    port_mapping: solution.port_mapping,

                });

            }

        }

        return solutions;

    }

use crate::runtime2::consensus::{GlobalSolution, LocalSolution};

    GlobalSolution(GlobalSolution), // broadcasting to everyone

    Notification, // just a notification (so purpose of message is to send the SyncHeader)

use crate::runtime2::port::{ChannelId, Port, PortState};

        let channel_id = ChannelId::new(getter_id);

            channel_id,

            channel_id,

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

pub struct ChannelId {

    pub index: u32,

}

impl ChannelId {

    pub fn new(id: u32) -> Self {

        return Self{ index: id };

    }

}

    pub channel_id: ChannelId,