use crate::protocol::*;

use crate::runtime2::*;

use super::{CompCtx, CompPDL};

pub enum CompScheduling {

    Immediate,

    if definition.source.is_builtin() {

        // Builtin component

    } else {

        // User-defined component

        let prompt = Prompt::new(

        return Box::new(component);

    }

}

use crate::protocol::eval::*;

use crate::runtime2::*;

use super::*;

/// TODO: Temporary component to figure out what to do with custom components.

///     This component sends random numbers between two u32 limits

}

    fn adopt_message(&mut self, _comp_ctx: &mut CompCtx, _message: DataMessage) {

        unreachable!("should not adopt messages");

    }

        todo!()

    }

}

            created_handle: LocalPortHandle,

            created_id: PortId,

        }

        let reservation = sched_ctx.runtime.start_create_pdl_component();

        let mut created_ctx = CompCtx::new(&reservation);

        // Take all the ports ID that are in the `args` (and currently belong to

        // the creator component) and translate them into new IDs that are

        // associated with the component we're about to create

            let created_port = created_ctx.get_port(created_port_handle);

            let created_port_id = created_port.self_id;

                creator_handle: creator_port_handle,

                creator_id: creator_port_id,

                created_handle: created_port_handle,

                created_id: created_port_id,

            // Modify value in arguments (bit dirty, but double vec in ValueGroup causes lifetime issues)

            let arg_value = if let Some(heap_pos) = port_reference.heap_pos {

        // the new component.

        let mut created_component_has_remote_peers = false;

            let creator_port_info = creator_ctx.get_port(pair.creator_handle);

            let created_port_info = created_ctx.get_port_mut(pair.created_handle);

            if created_port_info.peer_comp_id == creator_ctx.id {

                // Port peer is owned by the creator as well

                    .iter()

                    .position(|v| v.creator_id == creator_port_info.peer_port_id);

                match created_peer_port_index {

                    Some(created_peer_port_index) => {

                        // Peer port moved to the new component as well. So

                        // adjust IDs appropriately.

                        created_port_info.peer_port_id = peer_pair.created_id;

                        created_port_info.peer_comp_id = reservation.id();

                        todo!("either add 'self peer', or remove that idea from Ctx altogether")

        // actual component. Note that we initialize it as "not sleeping" as

        // its initial scheduling might be performed based on `Ack`s in response

        // to message exchanges between remote peers.

        let (created_key, component) = sched_ctx.runtime.finish_create_pdl_component(

            reservation, component, created_ctx, false,

        );

        // Now modify the creator's ports: remove every transferred port and

        // potentially remove the peer component.

            // Remove peer if appropriate

            let creator_port_info = creator_ctx.get_port(pair.creator_handle);

            let creator_port_index = creator_ctx.get_port_index(pair.creator_handle);

            }

        }

        // By now all ports and messages have been transferred. If there are any

        // peers that need to be notified about this new component, then we

        // initiate the protocol that will notify everyone here.

        if created_component_has_remote_peers {

            let created_ctx = &component.ctx;

            let schedule_entry_id = self.control.add_schedule_entry(created_ctx.id);

                let port_info = created_ctx.get_port(pair.created_handle);

                if port_info.peer_comp_id != creator_ctx.id && port_info.peer_comp_id != created_ctx.id {

                    let message = self.control.add_reroute_entry(

    }

}

/// Recursively goes through the value group, attempting to find ports.

/// Duplicates will only be added once.

pub(crate) fn find_ports_in_value_group(value_group: &ValueGroup, ports: &mut Vec<PortId>) {

        )?;

        let reserved = self.inner.start_create_pdl_component();

        let ctx = CompCtx::new(&reserved);

        self.inner.enqueue_work(key);

        return Ok(())

        return CompReserved{ reservation };

    }

        &self, reserved: CompReserved,

    ) -> (CompKey, &mut RuntimeComp) {

        let inbox_queue = QueueDynMpsc::new(16);

        let inbox_producer = inbox_queue.producer();

                num_handles: AtomicU32::new(1), // the component itself acts like a handle

                inbox: inbox_producer,

            },

            ctx: context,

            inbox: inbox_queue,

            exiting: false,

    ).expect("create prompt");

    let reserved = rt.inner.start_create_pdl_component();

    let ctx = CompCtx::new(&reserved);

    rt.inner.enqueue_work(key);

}

        new random_taker(rx);

    }

    ").expect("compilation");

}