use std::collections::HashMap;

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

use crate::{PortId, ProtocolDescription};

use crate::protocol::{ComponentState, RunContext, RunResult};

use crate::protocol::eval::{Prompt, Value, ValueGroup};

use super::global_store::ConnectorId;

use super::inbox::{

    PrivateInbox, PublicInbox, OutgoingMessage, DataMessage, SyncMessage,

    SyncBranchConstraint, SyncConnectorSolution

};

use super::port::PortIdLocal;

    }

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

    }

        if self.in_sync {

            // When in speculative mode we might have generated new sync

            // solutions, we need to turn them into proposed solutions here.

            if self.sync_finished_last_handled != self.sync_finished.last {

                let mut next_id;

                if self.sync_finished_last_handled == 0 {

                    debug_assert!(last_handled.next_branch_in_queue.is_some()); // because "last handled" != "last in queue"

                    next_id = last_handled.next_branch_in_queue.unwrap();

                }

                // Transform branch into proposed global solution

            }

        } else {

            return scheduling;

        }

    }

    /// Runs the connector in synchronous mode. Potential changes to the global

    /// system's state are added to the `RunDeltaState` object by the connector,

    /// where it is the caller's responsibility to immediately take care of

    /// those changes. The return value indicates when (and if) the connector

    /// needs to be scheduled again.

        debug_assert!(self.in_sync);

        debug_assert!(!self.sync_active.is_empty());

        let branch = Self::pop_branch(&mut self.branches, &mut self.sync_active);

        // Run the branch to the next blocking point

        } else {

            return ConnectorScheduling::Later;

        }

    }

    /// Runs the connector in non-synchronous mode.

        debug_assert!(!self.in_sync);

        debug_assert!(self.sync_active.is_empty() && self.sync_pending_get.is_empty() && self.sync_finished.is_empty());

        debug_assert!(self.branches.len() == 1);

        let branch = &mut self.branches[0];

        debug_assert!(branch.sync_state == SpeculativeState::RunningNonSync);

    // Helpers for generating and handling sync messages (and the solutions that

    // are described by those sync messages)

    /// Generates the initial solution for a finished sync branch. If initial

    /// local solution is valid, then the appropriate message is returned.

    /// Otherwise the initial solution is inconsistent.

        // Retrieve branchg

        debug_assert!(branch_id.is_valid()); // because we're supposed to be in sync mode

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

        debug_assert_eq!(branch.sync_state, SpeculativeState::ReachedSyncEnd);

        // Set up storage (this is also the storage for all of the connectors

        let mut sync_message = SyncMessage::new(initial_local_solution, approximate_peers);

        // Turn local port mapping into constraints on other connectors

        // - constraints on other components due to transferred ports

        for port_delta in &branch.ports_delta {

            // For transferred ports we always have two constraints: one for the

            // sender and one for the receiver, ensuring it was not used.

            // TODO: This will fail if a port is passed around multiple times.

            //  maybe a special "passed along" entry in `ports_delta`.

            if !sync_message.check_constraint(self.id, SyncBranchConstraint::SilentPort(port_delta.port_id)) {

                return None;

            }

        }

        // - constraints on other components due to owned ports

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

            let port = self.ports.get_port(branch_id.index, port_index);

        }

    }

    fn branch_ids_of_execution_path(&self, leaf_branch_id: BranchId, parents: &mut Vec<BranchId>) {

        debug_assert!(parents.is_empty());

        let mut next_branch_id = leaf_branch_id;