/*

Change the definition of these macros to control the logging level statically

*/

macro_rules! log {

    (@BENCH, $logger:expr, $($arg:tt)*) => {{

        // if let Some(w) = $logger.line_writer() {

        //     let _ = writeln!(w, $($arg)*);

        // }

    }};

    (@MARK, $logger:expr, $($arg:tt)*) => {{

    }};

    (@ENDPT, $logger:expr, $($arg:tt)*) => {{

        // ignore

    }};

    ($logger:expr, $($arg:tt)*) => {{

    }};

}

            cu.logger(),

            "Announcing decision {:?} through child endpoints {:?}",

            &msg,

            &comm.neighborhood.children

        );

        log!(@MARK, cu.logger(), "forwarding decision!");

        for &child in comm.neighborhood.children.iter() {

            comm.endpoint_manager.send_to_comms(child, &msg)?;

        }

        let ret = match decision {

            Decision::Failure => {

                // dropping {branching_proto_components, branching_native}

                Err(Se::RoundFailure)

            }

            Decision::Success(predicate) => {

                // commit changes to component states

                cu.proto_components.clear();

                cu.proto_components.extend(

                    // consume branching proto components

                    branching_proto_components

                        .into_iter()

                        .map(|(id, bpc)| (id, bpc.collapse_with(&predicate))),

                );

                // commit changes to ports and id_manager

                    assert_eq!(Putter, rctx.current_state.port_info.get(&putter).unwrap().polarity);

                    // overwrite assignment

                    let var = rctx.current_state.spec_var_for(putter);

                    let was = predicate.assigned.insert(var, SpecVal::FIRING);

                    if was == Some(SpecVal::SILENT) {

                        log!(cu.logger(), "Proto component {:?} tried to PUT on port {:?} when pred said var {:?}==Some(false). inconsistent!",

                            proto_component_id, putter, var);

                        // discard forever

                        drop((predicate, branch));

                    } else {

                        // keep in "unblocked"

                        branch.inner.did_put_or_get.insert(putter);

                        let msg = SendPayloadMsg { predicate: predicate.clone(), payload };

                        rctx.putter_push(cu, putter, msg);

                        drainer.add_input(predicate, branch);

                    }

                }

                B::SyncBlockEnd => {

                    // make concrete all variables

                    for (port, port_info) in rctx.current_state.port_info.iter() {

                        if port_info.owner != proto_component_id {

                            continue;

                        }

                        let var = rctx.current_state.spec_var_for(*port);

            Entry::Vacant(ev) => {

                // no existing branch present. We insert it no problem. (The most common case)

                ev.insert(branch);

            }

            Entry::Occupied(mut eo) => {

                // Oh dear, there is already a branch with this predicate.

                // Rather than choosing either branch, we MERGE them.

                // This means keeping the existing one in-place, and giving it the UNION of the inboxes

                let old = eo.get_mut();

                for (k, v) in branch.inner.inbox.drain() {

                    old.inner.inbox.insert(k, v);

                }

            }

        }

    }

    fn collapse_with(self, solution_predicate: &Predicate) -> ComponentState {

        let BranchingProtoComponent { branches } = self;

        for (branch_predicate, branch) in branches {

            if branch.ended && branch_predicate.assigns_subset(solution_predicate) {

                let ProtoComponentBranch { state, .. } = branch;

                return state;

            }

        }

        panic!("ProtoComponent had no branches matching pred {:?}", solution_predicate);

        cu: &mut impl CuUndecided,

        subtree_id: SubtreeId,

        predicate: Predicate,

    ) {

        log!(cu.logger(), "++ new component solution {:?} {:?}", subtree_id, &predicate);

        let index = self.subtree_id_to_index[&subtree_id];

        let left = 0..index;

        let right = (index + 1)..self.subtree_solutions.len();

        let Self { subtree_solutions, new_local, old_local, .. } = self;

        let was_new = subtree_solutions[index].insert(predicate.clone());

        if was_new {

            let set_visitor = left.chain(right).map(|index| &subtree_solutions[index]);

            Self::elaborate_into_new_local_rec(cu, predicate, set_visitor, old_local, new_local);

        }

    }

    fn elaborate_into_new_local_rec<'a, 'b>(

        cu: &mut impl CuUndecided,

        partial: Predicate,

        mut set_visitor: impl Iterator<Item = &'b HashSet<Predicate>> + Clone,

        old_local: &'b HashSet<Predicate>,

        new_local: &'a mut HashSet<Predicate>,

    ) {

        if let Some(set) = set_visitor.next() {

impl<'a, K: Eq + Hash, V> CyclicDrainInner<'a, K, V> {

    fn add_input(&mut self, k: K, v: V) {

        self.swap.insert(k, v);

    }

    fn add_output(&mut self, k: K, v: V) {

        self.output.insert(k, v);

    }

}

impl NonsyncProtoContext<'_> {

    pub fn new_component(&mut self, moved_ports: HashSet<PortId>, state: ComponentState) {

        // called by a PROTO COMPONENT. moves its own ports.

        // 1. sanity check: this component owns these ports

        // sanity check

        for port in moved_ports.iter() {

            assert_eq!(

                self.proto_component_id,

                self.current_state.port_info.get(port).unwrap().owner

            );

        }

        // 2. create new component

        let new_cid = self.current_state.id_manager.new_component_id();

        self.unrun_components.push((new_cid, state));

        // 3. update ownership of moved ports

        for port in moved_ports.iter() {

            self.current_state.port_info.get_mut(port).unwrap().owner = new_cid;

        }

        // 3. create a new component

    }

    pub fn new_port_pair(&mut self) -> [PortId; 2] {

        // adds two new associated ports, related to each other, and exposed to the proto component

        let mut new_cid_fn = || self.current_state.id_manager.new_port_id();

        let [o, i] = [new_cid_fn(), new_cid_fn()];

        self.current_state.port_info.insert(

        log!(

            self.logger,

            "Component {:?} port pair (out->in) {:?} -> {:?}",

            self.proto_component_id,

            o,

            i

        );

        [o, i]

    }

}

impl ProtoComponentBranch {

    fn feed_msg(&mut self, getter: PortId, payload: Payload) {

    }

}

impl<'a, K: Eq + Hash + 'static, V: 'static> CyclicDrainer<'a, K, V> {

    fn new(

        input: &'a mut HashMap<K, V>,

        swap: &'a mut HashMap<K, V>,

        output: &'a mut HashMap<K, V>,

    ) -> Self {

        Self { input, inner: CyclicDrainInner { swap, output } }

    }

    fn cyclic_drain<E>(

        self,

    c.put(p1, Payload::from(b"HELLO" as &[_])).unwrap();

    c.sync(SEC1).unwrap();

    c.put(p0, Payload::from(b"HEY" as &[_])).unwrap();

    c.put(p1, Payload::from(b"HELLO" as &[_])).unwrap();

    c.sync(SEC1).unwrap_err();

}

#[test]

fn sequencer3_prim() {

    let test_log_path = Path::new("./logs/sequencer3_prim");

    let pdl = b"

        int i = 0;

        while(true) synchronous {

            out to = a;

            if     (i==1) to = b;

            else if(i==2) to = c;

            if(fires(to)) {

                put(to, create(0));

                i = (i + 1)%3;

            }

        }

    }

    ";

    let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();

    let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));

    let [p0, g0] = c.new_port_pair();

    let [p1, g1] = c.new_port_pair();

    let [p2, g2] = c.new_port_pair();

    c.connect(None).unwrap();

        // setup three sync batches. sync. return which succeeded

        c.get(g0).unwrap();

        c.next_batch().unwrap();

        c.get(g1).unwrap();

        c.next_batch().unwrap();

        c.get(g2).unwrap();

        c.sync(None).unwrap()

    };

    const TEST_ROUNDS: usize = 50;

    // check that the batch index for rounds 0..TEST_ROUNDS are [0, 1, 2, 0, 1, 2, ...]

    for expected_batch_idx in (0..=2).cycle().take(TEST_ROUNDS) {

    }

}

#[test]

fn sequencer3_comp() {

    let test_log_path = Path::new("./logs/sequencer3_comp");

    let pdl = b"

    primitive fifo1_init(msg m, in a, out b) {

        while(true) synchronous {

            if(m != null && fires(b)) {

                put(b, m);

                m = null;

            } else if (m == null && fires(a)) {

                m = get(a);

            }

        }

    }

    composite fifo1_full(in a, out b) {

        new fifo1_init(create(0), a, b);

    }

    composite fifo1(in a, out b) {

        new fifo1_init(null, a, b);

    }

        channel d -> e;

        channel f -> g;

        channel h -> i;

        channel j -> k;

        channel l -> m;

        channel n -> o;

        new fifo1_full(o, d);

        new replicator2(e, f, a);

        new fifo1(g, h);

        new replicator2(i, j, b);

        new fifo1(k, l);

        new replicator2(m, n, c);

    }

    ";

    let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();

    let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));

    let [p0, g0] = c.new_port_pair();

    let [p1, g1] = c.new_port_pair();

    let [p2, g2] = c.new_port_pair();

    c.connect(None).unwrap();

        // setup three sync batches. sync. return which succeeded

        c.get(g0).unwrap();

        c.next_batch().unwrap();

        c.get(g1).unwrap();

        c.next_batch().unwrap();

        c.get(g2).unwrap();

    };

    const TEST_ROUNDS: usize = 50;

    // check that the batch index for rounds 0..TEST_ROUNDS are [0, 1, 2, 0, 1, 2, ...]

    for expected_batch_idx in (0..=2).cycle().take(TEST_ROUNDS) {

    }

}