use std::path::Component;

use crate::collections::VecSet;

use crate::protocol::eval::ValueGroup;

use crate::runtime2::branch::{BranchId, ExecTree, QueueKind};

use crate::runtime2::ConnectorId;

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

use crate::runtime2::inbox::SyncMessage;

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

use crate::runtime2::scheduler::ComponentCtxFancy;

use super::inbox2::PortAnnotation;

struct BranchAnnotation {

    port_mapping: Vec<PortAnnotation>,

}

pub(crate) struct LocalSolution {

    component: ConnectorId,

    final_branch_id: BranchId,

    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

}

// -----------------------------------------------------------------------------

// Consensus

// -----------------------------------------------------------------------------

/// The consensus algorithm. Currently only implemented to find the component

/// with the highest ID within the sync region and letting it handle all the

/// local solutions.

            self.send_or_store_local_solution(local_solution, ctx);

            last_branch_id = Some(branch.id);

        }

        self.last_finished_handled = last_branch_id;

    }

    pub fn end_sync(&mut self, branch_id: BranchId, final_ports: &mut Vec<PortIdLocal>) {

        debug_assert!(self.is_in_sync());

        // TODO: Handle sending and receiving ports

        final_ports.clear();

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

        for port in &branch.port_mapping {

            final_ports.push(port.port_id);

        }

    }

    // --- Handling messages

    /// Prepares a message for sending. Caller should have made sure that

    /// sending the message is consistent with the speculative state.

    pub fn handle_message_to_send(&mut self, branch_id: BranchId, source_port_id: PortIdLocal, content: &ValueGroup, ctx: &mut ComponentCtxFancy) -> (SyncHeader, DataHeader) {

        debug_assert!(self.is_in_sync());

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

        if cfg!(debug_assertions) {

            let port = branch.port_mapping.iter()

                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);

                }

            }

        } else if sync_header.highest_component_id < self.highest_connector_id {

            // Sender has lower leader ID, so it should know about our higher

            // one.

            let message = SyncMessageFancy{

                sync_header: self.create_sync_header(ctx),

                target_component_id: sync_header.sending_component_id,

                content: SyncContent::Notification

            };

            ctx.submit_message(MessageFancy::Sync(message));

        } // else: exactly equal, so do nothing

    }

    fn send_or_store_local_solution(&mut self, solution: LocalSolution, ctx: &mut ComponentCtxFancy) {

        if self.highest_connector_id == ctx.id {

            // We are the leader

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

            }

        } else {

            // Someone else is the leader

            let message = SyncMessageFancy{

                sync_header: self.create_sync_header(ctx),

                target_component_id: self.highest_connector_id,

                content: SyncContent::LocalSolution(solution),

            };

            ctx.submit_message(MessageFancy::Sync(message));

        }

    }

}

impl SolutionCombiner {

    fn new() -> Self {

        return Self{

            local: Vec::new(),

        };

    }

    /// Adds a new local solution to the global solution storage. Will check the

    /// new local solutions for matching against already stored local solutions

    /// of peer connectors.

        let component_id = solution.component;

        let solution = MatchedLocalSolution{

            final_branch_id: solution.final_branch_id,

            port_mapping: solution.port_mapping,

            matches: Vec::new(),

        };

        // Create an entry for the solution for the particular component

        let component_exists = self.local.iter_mut()

            .enumerate()

            .find(|(_, v)| v.component == component_id);

        let (component_index, solution_index, new_component) = match component_exists {

                None => {

                    // Create a new entry

                    cur_solution.matches.push(new_component_match);

                }

            }

        }

        return self.check_new_solution(component_index, solution_index);

    }

    /// Checks if, starting at the provided local solution, a global solution

    /// can be formed.

        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

                            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

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

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

            let component = &self.local[component_index];

            let solution = &component.solutions[solution_index];

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

        }

    }

    /// Simple test if a solution is at all possible. If this returns true it

    /// does not mean there actually is a solution.

    fn can_have_solution(&self) -> bool {

        for component in &self.local {

            if !component.all_peers_present {

                return false;

            }

        }

        return true;