#[derive(Debug, Clone)]

pub struct ForkStatement {

    pub this: ForkStatementId,

    // Phase 1: parser

    pub span: InputSpan, // of the "fork" keyword

    pub left_body: BlockStatementId,

    pub right_body: Option<BlockStatementId>,

    pub end_fork: EndForkStatementId,

}

#[derive(Debug, Clone)]

pub struct EndForkStatement {

    pub start_fork: ForkStatementId,

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct ReturnStatement {

    pub this: ReturnStatementId,

    // Phase 1: parser

    pub span: InputSpan, // of the "return" keyword

    pub expressions: Vec<ExpressionId>,

}

}

type EvalResult = Result<EvalContinuation, EvalError>;

pub enum EvalContinuation {

    Stepping,

    Inconsistent,

    Terminal,

    SyncBlockStart,

    SyncBlockEnd,

    NewComponent(DefinitionId, i32, ValueGroup),

    NewChannel,

    BlockFires(PortId),

    BlockGet(PortId),

    Put(PortId, Value),

}

// Note: cloning is fine, methinks. cloning all values and the heap regions then

// we end up with valid "pointers" to heap regions.

#[derive(Debug, Clone)]

pub struct Prompt {

    pub(crate) frames: Vec<Frame>,

    pub(crate) store: Store,

}

                Ok(EvalContinuation::Stepping)

            },

            Statement::Synchronous(stmt) => {

                cur_frame.position = stmt.body.upcast();

                Ok(EvalContinuation::SyncBlockStart)

            },

            Statement::EndSynchronous(stmt) => {

                cur_frame.position = stmt.next;

                Ok(EvalContinuation::SyncBlockEnd)

            },

            Statement::Return(_stmt) => {

                debug_assert!(heap[cur_frame.definition].is_function());

                debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");

                // The preceding frame has executed a call, so is expecting the

                // return expression on its expression value stack. Note that

                // we may be returning a reference to something on our stack,

                // so we need to read that value and clone it.

                let return_value = cur_frame.expr_values.pop_back().unwrap();

                let return_value = match return_value {

                    Value::Ref(value_id) => self.store.read_copy(value_id),

                    _ => return_value,

                todo!("implement full type checking on user-supplied arguments");

                return false;

            },

        }

    }

}

// TODO: @temp Should just become a concrete thing that is passed in

pub trait RunContext {

    fn did_put(&mut self, port: PortId) -> bool;

    fn get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message

    fn fires(&mut self, port: PortId) -> Option<Value>; // None if not yet branched

    fn get_channel(&mut self) -> Option<(Value, Value)>; // None if not yet prepared

}

#[derive(Debug)]

pub enum RunResult {

    // Can only occur outside sync blocks

    ComponentTerminated, // component has exited its procedure

    ComponentAtSyncStart,

    NewComponent(DefinitionId, i32, ValueGroup), // should also be possible inside sync

    NewChannel, // should also be possible inside sync

    // Can only occur inside sync blocks

    BranchInconsistent, // branch has inconsistent behaviour

    BranchMissingPortState(PortId), // branch doesn't know about port firing

    BranchMissingPortValue(PortId), // branch hasn't received message on input port yet

    BranchAtSyncEnd,

    BranchPut(PortId, ValueGroup),

}

impl ComponentState {

    pub(crate) fn run(&mut self, ctx: &mut impl RunContext, pd: &ProtocolDescription) -> RunResult {

        use EvalContinuation as EC;

        use RunResult as RR;

        loop {

            let step_result = self.prompt.step(&pd.types, &pd.heap, &pd.modules, ctx);

            match step_result {

                Err(reason) => {

                },

                Ok(continuation) => match continuation {

                    // TODO: Probably want to remove this translation

                    EC::Stepping => continue,

                    EC::Inconsistent => return RR::BranchInconsistent,

                    EC::Terminal => return RR::ComponentTerminated,

                    EC::SyncBlockStart => return RR::ComponentAtSyncStart,

                    EC::SyncBlockEnd => return RR::BranchAtSyncEnd,

                    EC::NewComponent(definition_id, monomorph_idx, args) =>

                        return RR::NewComponent(definition_id, monomorph_idx, args),

                    EC::NewChannel =>

                        return RR::NewChannel,

                    EC::BlockFires(port_id) => return RR::BranchMissingPortState(port_id),

                    EC::BlockGet(port_id) => return RR::BranchMissingPortValue(port_id),

                    EC::Put(port_id, value) => {

                        let value_group = ValueGroup::from_store(&self.prompt.store, &[value]);

                        return RR::BranchPut(port_id, value_group);

                    },

                }

            }

        }

    }

}

                        let init_state = ComponentState { prompt: Prompt::new(&pd.types, &pd.heap, definition_id, monomorph_idx, args) };

                        context.new_component(moved_ports, init_state);

                        // Continue stepping

                        continue;

                    },

                    EvalContinuation::NewChannel => {

                        // Because of the way we emulate the old context for now, we can safely

                        // assume that this will never happen. The old context thingamajig always

                        // creates a channel, it never bubbles a "need to create a channel" message

                        // to the runtime

                        unreachable!();

                    },

                    // Outside synchronous blocks, no fires/get/put happens

                    EvalContinuation::BlockFires(_) => unreachable!(),

                    EvalContinuation::BlockGet(_) => unreachable!(),

                    EvalContinuation::Put(_, _) => unreachable!(),

                },

            }

        }

    }

    pub(crate) fn sync_run<'a: 'b, 'b>(

        &'a mut self,

        context: &'b mut SyncProtoContext<'b>,

                },

                Ok(cont) => match cont {

                    EvalContinuation::Stepping => continue,

                    EvalContinuation::Inconsistent => return SyncBlocker::Inconsistent,

                    // First need to exit synchronous block before definition may end

                    EvalContinuation::Terminal => unreachable!(),

                    // No nested synchronous blocks

                    EvalContinuation::SyncBlockStart => unreachable!(),

                    EvalContinuation::SyncBlockEnd => return SyncBlocker::SyncBlockEnd,

                    // Not possible to create component in sync block

                    EvalContinuation::NewComponent(_, _, _) => unreachable!(),

                    EvalContinuation::NewChannel => unreachable!(),

                    EvalContinuation::BlockFires(port) => {

                        return SyncBlocker::CouldntCheckFiring(port);

                    },

                    EvalContinuation::BlockGet(port) => {

                        return SyncBlocker::CouldntReadMsg(port);

                    },

                    EvalContinuation::Put(port, message) => {

                        let payload;

                        match message {

                            Value::Null => {

                                return SyncBlocker::Inconsistent;

                            },

    fn get_channel(&mut self) -> Option<(Value, Value)> {

        match self {

            EvalContext::None => unreachable!(),

            EvalContext::Nonsync(context) => {

                let [from, to] = context.new_port_pair();

                let from = Value::Output(from);

                let to = Value::Input(to);

                return Some((from, to));

            },

            EvalContext::Sync(_) => unreachable!(),

        }

    }

}

// TODO: @remove once old runtime has disappeared

impl EvalContext<'_> {

    // fn random(&mut self) -> LongValue {

    //     match self {

    //         // EvalContext::None => unreachable!(),

    //         EvalContext::Nonsync(_context) => todo!(),

    //         EvalContext::Sync(_) => unreachable!(),

    //     }

    // }

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

        self.in_sync = SynchronousStatementId::new_invalid();

        Ok(())

    }

    fn visit_fork_stmt(&mut self, ctx: &mut Ctx, id: ForkStatementId) -> VisitorResult {

        let fork_stmt = &ctx.heap[id];

        let end_fork_id = fork_stmt.end_fork;

        let left_body_id = fork_stmt.left_body;

        let right_body_id = fork_stmt.right_body;

        // Visit the respective bodies. Like the if statement, a fork statement

        // does not have a single static subsequent statement. It forks and then

        // each fork has a different next statement.

        assign_then_erase_next_stmt!(self, ctx, id.upcast());

        self.visit_block_stmt(ctx, left_body_id)?;

        assign_then_erase_next_stmt!(self, ctx, end_fork_id.upcast());

        if let Some(right_body_id) = right_body_id {

            self.visit_block_stmt(ctx, right_body_id)?;

            assign_then_erase_next_stmt!(self, ctx, end_fork_id.upcast());

        }