glowdust 0.0.1

use crate::compiler::cursor::{FunctionCursor, FunctionCursorMethods};
use crate::compiler::value::parameters::Parameter::Constant;
use crate::compiler::value::parameters::{Parameter, Variable};
use crate::compiler::value::primitives::Primitive::{Boolean, Integer, MyString};
use crate::compiler::value::values::Value::{FunctionNameValue, PrimitiveValue};
use crate::compiler::value::values::Value::{Tuple, TypedValueInstance};
use crate::compiler::value::values::{FunctionDefinitionObject, TypedValue, Value};
use crate::runtime::bytecode::OpCode;
use crate::runtime::bytecode::OpCode::*;
use crate::store::Store;
use crate::{
    boolean_to_value, empty_tuple_value, integer_to_value, string_to_value, value_is_integer,
    value_is_string, value_to_boolean, value_to_integer, value_to_string, vector_to_value,
};
use std::cell::RefCell;

use std::collections::HashMap;
use std::ops::Add;
use std::rc::Rc;

use crate::runtime::compiled_script::{Bytecode, Executable};
use crate::runtime::disassembler::disassemble_no_lines;
use crate::runtime::sink::Sink;
use crate::runtime::RuntimeError;
use tracing::{debug, trace};

macro_rules! current_stack_mut {
    ($self:expr) => {{
        &mut $self.frame_stack.last_mut().unwrap().value_stack
    }};
}

macro_rules! current_stack {
    ($self:expr) => {{
        &$self.frame_stack.last().unwrap().value_stack
    }};
}

#[derive(Debug)]
pub struct Frame {
    ip: usize,
    bytecodes: Bytecode,
    name: String,
    value_stack: Vec<Value>,

    pub variables: Vec<Value>,
    pub constants: Vec<Value>,
}

#[derive(Debug)]
pub struct VirtualMachine {
    pub frame_stack: Vec<Frame>,
    pub global_variables: HashMap<String, Value>,
    pub cursors: HashMap<u8, FunctionCursor>,
}

impl Default for VirtualMachine {
    fn default() -> Self {
        Self::new()
    }
}

impl VirtualMachine {
    pub fn new() -> VirtualMachine {
        VirtualMachine {
            frame_stack: vec![],
            global_variables: HashMap::new(),
            cursors: HashMap::new(),
        }
    }

    fn pop(&mut self) -> Value {
        if let Some(result) = current_stack_mut!(self).pop() {
            result
        } else {
            panic!(
                "Stack underflow, ip is {}",
                self.frame_stack.last().unwrap().ip
            )
        }
    }

    fn peek(&mut self) -> &Value {
        if let Some(result) = current_stack!(self).last() {
            result
        } else {
            panic!(
                "Stack underflow, IP is {}",
                self.frame_stack.last().unwrap().ip
            );
        }
    }

    // maybe this should return the value if a value match is found. We'll see
    pub fn call(
        &mut self,
        function_name: &str,
        function_store: &mut dyn Store,
        arguments: &[Value],
    ) -> Result<(), RuntimeError> {
        match function_store
            .get_function_value(function_name, arguments)
            .unwrap()
        {
            None => {
                // no values for this function
                // debug!(
                //     "Did not find a value mapping for function {} and value {:?}",
                //     function_name, arguments
                // );
            }
            Some(value) => {
                // debug!(
                //     "Found direct value mapping for function: {} -> {:?}, using it",
                //     function_name, value
                // );
                current_stack_mut!(self).push(value.clone());
                return Ok(());
            }
        }

        match function_store.get_function_definition(function_name, arguments)? {
            Some(definition) => {
                self.setup_call_frame(&definition, arguments)?;
            }
            None => {
                // Final attempt, see if this is a native function and call it
                match function_store.get_native_function(function_name)? {
                    Some(function) => {
                        // debug!(
                        //     "Found native function for name: {}, using it", function_name
                        // );
                        let result = function(arguments);
                        current_stack_mut!(self).push(result);
                    }
                    None => {
                        // debug!(
                        //     "no definitions matched at all, pushing an empty tuple and hoping for the best"
                        // );
                        current_stack_mut!(self).push(empty_tuple_value!());
                    }
                }
            }
        }
        Ok(())
    }

    fn setup_call_frame(
        &mut self,
        definition: &FunctionDefinitionObject,
        arguments: &[Value],
    ) -> Result<(), RuntimeError> {
        if self.frame_stack.len() == 32 {
            return Err(RuntimeError::new_stack_error(
                format!("Stack overflow, function is {}", definition.name),
                self.frame_stack.last().unwrap().ip,
                OpCall,
            ));
        }

        let mut variables = vec![];

        for (index, argument) in arguments.iter().enumerate() {
            match definition.formal_arguments[index] {
                Constant(_) => continue,
                Parameter::Variable(_) => {
                    variables.push(argument.clone());
                }
            }
        }

        let mut constants = vec![];

        for constant in &definition.constants {
            constants.push(constant.clone());
        }

        let new_frame = Frame {
            ip: 0,
            bytecodes: definition.bytecode.clone(),
            name: definition.name.clone(),
            variables,
            constants,
            value_stack: Vec::new(),
        };

        self.frame_stack.push(new_frame);
        Ok(())
    }

    pub fn reset(&mut self) {
        self.frame_stack = vec![];
        self.cursors.clear();
    }

    pub fn run(
        &mut self,
        script: &Executable,
        store: &mut impl Store,
        sink: &mut impl Sink,
    ) -> Result<Value, RuntimeError> {
        for (name, definitions) in script.function_definitions.iter() {
            for definition in definitions {
                match store.set_function_definition(
                    name,
                    definition.formal_arguments.as_slice(),
                    definition.clone(),
                ) {
                    Ok(_) => {} // cool, keep going
                    Err(e) => {
                        return Err(RuntimeError::new_io_error(format!(
                            "Error during function definition: {}",
                            e
                        )))
                    }
                }
            }
        }

        for type_def in &script.type_definitions {
            match store.set_type_definition(&type_def.name, type_def.clone()) {
                Ok(_) => {}
                Err(e) => {
                    return Err(RuntimeError::new_io_error(format!(
                        "Error while storing type: {}",
                        e
                    )))
                }
            }
        }
        self.setup_call_frame(&script.as_fdo(), &[])?;
        self.run_inner(&script.script_variables, store, sink)
    }

    fn dump_stack(stack: &[Value]) {
        trace!("Stack:");
        for (pos, value) in stack.iter().rev().enumerate() {
            trace!("{}:[{}]", pos, value);
        }
    }

    fn run_inner(
        &mut self,
        global_variables: &[Variable],
        store: &mut dyn Store,
        sink: &mut impl Sink,
    ) -> Result<Value, RuntimeError> {
        let mut result = empty_tuple_value!();
        if self.frame_stack.is_empty() {
            // this horrible, I know
            trace!("No code to run, returning");
            return Ok(result);
        }

        macro_rules! read_byte {
            () => {{
                let result = self
                    .frame_stack
                    .last()
                    .unwrap()
                    .bytecodes
                    .get(self.frame_stack.last().unwrap().ip);
                self.frame_stack.last_mut().unwrap().ip += 1;
                result as usize
            }};
        }

        macro_rules! opcode {
            () => {{
                OpCode::from_byte(
                    frame_stack_top!()
                        .bytecodes
                        .get(self.frame_stack.last().unwrap().ip),
                )
            }};
        }

        macro_rules! frame_stack_top_mut {
            () => {{
                self.frame_stack.last_mut().unwrap()
            }};
        }

        macro_rules! frame_stack_top {
            () => {{
                self.frame_stack.last().unwrap()
            }};
        }

        loop {
            let bytecode = opcode!();
            // debug!(
            //     "Value stack is {} long, executing {}",
            //     current_stack!(self).len(),
            //     bytecode
            // );
            frame_stack_top_mut!().ip += 1;
            match bytecode {
                OpPop => {
                    self.pop();
                }
                OpConst => {
                    let index = read_byte!();
                    let value = frame_stack_top!().constants[index].clone();
                    // trace!("OpConst pushing {:?}", value);
                    current_stack_mut!(self).push(value);
                }
                OpTrue => {
                    current_stack_mut!(self).push(boolean_to_value!(true));
                }
                OpFalse => {
                    current_stack_mut!(self).push(boolean_to_value!(false));
                }
                OpMktuple => {
                    let mut arity = read_byte!();
                    let value;
                    if arity > 0 {
                        // The 0 is just a random value to populate the vector so it has `arity` size
                        // and all indexes are valid, which is necessary because  we populate it
                        // backwards. Some unsafe code here would make things faster, I think.
                        let mut tuple_contents = vec![integer_to_value!(0); arity];
                        loop {
                            arity -= 1;
                            let value1 = self.pop();
                            tuple_contents[arity] = value1;
                            if arity == 0 {
                                break;
                            }
                        }
                        value = vector_to_value!(tuple_contents);
                    } else {
                        value = empty_tuple_value!();
                    }
                    current_stack_mut!(self).push(value);
                }
                OpAdd => {
                    let right = self.pop();
                    if value_is_integer!(right) {
                        // trace!("Right value to add is {:?}", right);
                        let right = value_to_integer!(right);
                        let left = self.pop();
                        // trace!("Left value to add is {:?}", left);
                        let left = value_to_integer!(left);
                        current_stack_mut!(self).push(integer_to_value!(left + right));
                    } else if value_is_string!(right) {
                        let right = value_to_string!(right);
                        let left = value_to_string!(self.pop());
                        current_stack_mut!(self).push(string_to_value!(left.add(&right)))
                    } else {
                        return Err(RuntimeError::new_value_error(
                            format!("Value {} does not support addition", right),
                            frame_stack_top!().ip,
                            OpAdd,
                        ));
                    }
                }
                OpSubtract => {
                    let right = value_to_integer!(self.pop());
                    let left = value_to_integer!(self.pop());
                    current_stack_mut!(self).push(integer_to_value!(left - right));
                }
                OpMultiply => {
                    let right = value_to_integer!(self.pop());
                    let left = value_to_integer!(self.pop());
                    current_stack_mut!(self).push(integer_to_value!(left * right));
                }
                OpDivide => {
                    let right = value_to_integer!(self.pop());
                    let left = value_to_integer!(self.pop());
                    current_stack_mut!(self).push(integer_to_value!(left / right));
                }
                OpNegate => {
                    let value = value_to_integer!(self.pop());
                    current_stack_mut!(self).push(integer_to_value!(-value));
                }
                OpAnd => {
                    let right = value_to_boolean!(self.pop());
                    let left = value_to_boolean!(self.pop());
                    current_stack_mut!(self).push(boolean_to_value!(left && right));
                }
                OpOr => {
                    let right = value_to_boolean!(self.pop());
                    let left = value_to_boolean!(self.pop());
                    current_stack_mut!(self).push(boolean_to_value!(left || right));
                }
                OpNot => {
                    let value = value_to_boolean!(self.pop());
                    current_stack_mut!(self).push(boolean_to_value!(!value));
                }
                OpEquals => {
                    let right = self.pop();
                    let left = self.pop();
                    current_stack_mut!(self).push(boolean_to_value!(left.eq(&right)));
                }
                OpGt => {
                    let right = value_to_integer!(self.pop());
                    let left = value_to_integer!(self.pop());
                    current_stack_mut!(self).push(boolean_to_value!(left > right));
                }
                OpLt => {
                    let right = value_to_integer!(self.pop());
                    let left = value_to_integer!(self.pop());
                    current_stack_mut!(self).push(boolean_to_value!(left < right));
                }
                OpReturn => {
                    if let Some(mut frame) = self.frame_stack.pop() {
                        if self.frame_stack.is_empty() {
                            if let Some(return_value) = frame.value_stack.pop() {
                                result = return_value;
                            }
                            break;
                        }
                        if let Some(return_value) = frame.value_stack.pop() {
                            assert_eq!(
                                0,
                                frame.value_stack.len(),
                                "After return from function {}, stack had length {}",
                                frame.name,
                                frame.value_stack.len()
                            );
                            current_stack_mut!(self).push(return_value);
                        }
                        /*
                        Else should there be a default return value? Probably not, this is a concern with
                        language semantics, not a runtime issue.
                        It does assume however that the caller expects a return value.
                        */
                    } else {
                        panic!("OpReturn could not find current executing frame")
                    }
                }
                OpSetGlobal => {
                    let name_index = read_byte!();
                    if let Some(var) = global_variables.get(name_index) {
                        let value = self.peek().clone();
                        self.global_variables.insert(var.name.to_string(), value);
                    } else {
                        return Err(RuntimeError::new_compiler_error(
                            format!("Global Variable {} not found", name_index),
                            frame_stack_top!().ip,
                            OpSetGlobal,
                        ));
                    }
                }
                OpGetGlobal => {
                    let name_index = read_byte!();
                    let name = &global_variables.get(name_index).unwrap().name;
                    if let Some(value) = self.global_variables.get(name) {
                        current_stack_mut!(self).push(value.clone());
                    } else {
                        return Err(RuntimeError::new_compiler_error(
                            format!("Variable {} not found", name),
                            frame_stack_top!().ip,
                            OpGetGlobal,
                        ));
                    }
                }
                OpSetLocal => {
                    let index = read_byte!();
                    if index > frame_stack_top!().variables.len() + 1 {
                        // This check is probably wrong, but I want to know when it's invalidated.
                        // It checks that variables are first referenced in strict order and we never skip one
                        // This may change in the future if variables can be declared before being assigned
                        // Then they will get an index before they are actually set, so calls to OpSetVar
                        // will be mixed up
                        return Err(RuntimeError::new_compiler_error(
                            format!(
                                "index was {}, variables length was {}",
                                index,
                                frame_stack_top!().variables.len()
                            ),
                            frame_stack_top!().ip,
                            OpSetLocal,
                        ));
                    }
                    while index >= frame_stack_top!().variables.len() {
                        // If the index for the variable is missing, create it.
                        frame_stack_top_mut!().variables.push(integer_to_value!(0));
                    }
                    frame_stack_top_mut!().variables[index] = self.peek().clone();
                    // debug!(
                    //     "Set local variable at index {} to {}",
                    //     index,
                    //     frame_stack_top!().variables[index]
                    // );
                }
                OpGetLocal => {
                    let index = read_byte!();
                    let val = frame_stack_top!().variables[index].clone();
                    current_stack_mut!(self).push(val);
                    // trace!("GetLocal pushed value {} for index {}", self.peek(), index);
                }
                OpSetFunt => {
                    let index = read_byte!();
                    let codomain_value = self.pop();
                    match self.pop() {
                        Tuple(tuple) => {
                            // trace!(
                            //     "SetFunT popped values: codom-> {:?}, tuple-> {:?}",
                            //     codomain_value,
                            //     tuple
                            // );
                            let FunctionNameValue(function_name) =
                                &frame_stack_top_mut!().constants[index]
                            else {
                                return Err(RuntimeError::new_value_error(
                                    "Expected FunctionNameValue".to_string(),
                                    frame_stack_top!().ip,
                                    OpSetFunt,
                                ));
                            };
                            store.set_function_value(
                                function_name,
                                tuple.as_slice(),
                                codomain_value.clone(),
                            )?;
                            // Yeah, this is not good, codomain and domain values should be flipped
                            current_stack_mut!(self).push(codomain_value);
                        }
                        o => {
                            return Err(RuntimeError::new_value_error(
                                format!("Expected tuple at top of stack, got {:?} instead", o),
                                frame_stack_top!().ip,
                                OpSetFunt,
                            ));
                        }
                    }
                }
                OpCall => {
                    let mut arg_count = read_byte!();
                    let FunctionNameValue(function_name) = self.pop() else {
                        return Err(RuntimeError::new_value_error(
                            "Expected FunctionNameValue".to_string(),
                            frame_stack_top!().ip,
                            OpCall,
                        ));
                    };
                    // TODO This is the same code as OpMkTuple, this should be fixed
                    let mut domain_value = vec![integer_to_value!(0); arg_count];
                    if arg_count > 0 {
                        loop {
                            arg_count -= 1;
                            let value1 = self.pop();
                            domain_value[arg_count] = value1;
                            if arg_count == 0 {
                                break;
                            }
                        }
                    }
                    self.call(function_name.as_str(), store, &domain_value)?;
                }
                OpJump => {
                    let jump_distance = read_byte!();
                    frame_stack_top_mut!().ip += jump_distance;
                }
                OpJumpIfFalse => {
                    let jump_distance = read_byte!();
                    let ip = frame_stack_top!().ip;
                    let value = self.peek();
                    if !as_boolean(value, ip, OpJumpIfFalse)? {
                        // trace!("OpJumpIfFalse jumping by {} at ip {}", jump_distance, ip);
                        frame_stack_top_mut!().ip += jump_distance;
                        // } else {
                        //     trace!("OpJumpIfFalse not jumping at ip {}", ip);
                    }
                }
                OpLoop => {
                    let jump_distance = read_byte!();
                    frame_stack_top_mut!().ip -= jump_distance;
                }
                OpPull => {
                    let cursor_id = read_byte!();

                    let cur = self.cursors.get_mut(&(cursor_id as u8)).unwrap();

                    match cur.next() {
                        None => {
                            current_stack_mut!(self).push(empty_tuple_value!());
                        }
                        Some(mut row) => {
                            row.reverse();
                            for value in row {
                                // trace!("Pushing value {} from cursor {}", value, cursor_id);
                                current_stack_mut!(self).push(value);
                            }
                        }
                    }
                }
                OpProduce => {
                    let count = read_byte!();
                    let mut result = Vec::with_capacity(count);
                    for _ in 0..count {
                        result.push(self.pop());
                    }
                    result.reverse();
                    sink.accept(&result);
                }
                OpOpenCursor => {
                    let cursor_id = read_byte!();
                    let FunctionNameValue(cursor_name) = self.pop() else {
                        return Err(RuntimeError::new_value_error(
                            "Expected FunctionNameValue".to_string(),
                            frame_stack_top!().ip,
                            OpOpenCursor,
                        ));
                    };
                    self.cursors
                        .insert(cursor_id as u8, store.function_cursor(&cursor_name));
                }
                OpCloseCursor => {
                    // TODO this needs to be implemented, we leak cursors otherwise
                    let cursor_id = read_byte!();
                    debug!("Here I would close cursor {}", cursor_id);
                }
                OpTupleGet => {
                    let _ = read_byte!();
                    let stack_top = self.pop();
                    match stack_top {
                        Tuple(mut values) => {
                            if values.is_empty() {
                                return Err(RuntimeError::new_value_error(
                                    "Expected non empty tuple, got empty one instead".to_string(),
                                    frame_stack_top!().ip,
                                    OpTupleGet,
                                ));
                            }
                            let first = values.remove(0);
                            if values.len() == 1 {
                                current_stack_mut!(self).push(values.remove(0));
                            } else {
                                current_stack_mut!(self).push(Tuple(values));
                            }
                            current_stack_mut!(self).push(first);
                        }
                        _ => {
                            current_stack_mut!(self).push(stack_top); // push it back in unchanged
                        }
                    }
                }
                OpNewInstance => {
                    let constant = read_byte!();
                    let name = value_to_string!(&frame_stack_top!().constants[constant]);
                    match store.type_definition_by_name(name)? {
                        Some(definition) => {
                            let mut default_field_values = HashMap::new();

                            for (field_name, field_type) in definition.fields {
                                match field_type.as_str() {
                                    "int" => {
                                        default_field_values.insert(field_name, Integer(0));
                                    }
                                    "string" => {
                                        default_field_values
                                            .insert(field_name, MyString("".to_string()));
                                    }
                                    "bool" => {
                                        default_field_values.insert(field_name, Boolean(false));
                                    }
                                    _ => {
                                        panic!("Type {} is not a supported field type", field_type)
                                    }
                                }
                            }

                            let value = TypedValueInstance(Rc::new(RefCell::new(TypedValue {
                                name: definition.name,
                                fields: default_field_values,
                            })));
                            current_stack_mut!(self).push(value);
                        }
                        None => {
                            return Err(RuntimeError::new_schema_error(
                                format!("There is no type named '{}' defined. You need to define it first with a 'type' statement.", name)
                            ));
                        }
                    }
                }
                OpSetField => {
                    let stack_top = current_stack_mut!(self).pop();
                    let field_name = read_byte!();
                    let field_name =
                        value_to_string!(&frame_stack_top!().constants[field_name]).to_string();
                    if let Some(PrimitiveValue(primitive)) = stack_top {
                        if let Some(TypedValueInstance(ref mut value)) =
                            current_stack_mut!(self).last_mut()
                        {
                            value
                                .borrow_mut()
                                .fields
                                .insert(field_name, primitive.clone());
                        }
                    } else {
                        panic!()
                    }
                }
                OpGetField => {
                    let field_name_const = read_byte!();
                    let field_name =
                        value_to_string!(&frame_stack_top!().constants[field_name_const]).clone();

                    let object = current_stack_mut!(self).pop();
                    let value = if let Some(TypedValueInstance(value)) = object {
                        match value.borrow().fields.get(&field_name) {
                            Some(value) => value.clone(),
                            None => {
                                panic!(
                                    "no field with name {} in type {}",
                                    field_name,
                                    value.borrow().name
                                )
                            }
                        }
                    } else {
                        panic!()
                    };

                    current_stack_mut!(self).push(PrimitiveValue(value));
                }
                e => {
                    panic!(
                        "{:?} opcode not implemented, ip={}",
                        e,
                        frame_stack_top!().ip
                    );
                }
            }
            // VirtualMachine::dump_stack(&current_stack!(self));
        }
        // trace!("Execution completed:");
        Ok(result)
    }
}

fn as_boolean(value: &Value, ip: usize, op_code: OpCode) -> Result<bool, RuntimeError> {
    let result = match value {
        PrimitiveValue(Boolean(bool)) => !*bool,
        PrimitiveValue(_) => false,
        FunctionNameValue(_) => {
            return Err(RuntimeError::new_value_error(
                "Cannot assign boolean to function name value".to_string(),
                ip,
                op_code,
            ))
        }
        Tuple(tuple) => tuple.is_empty(),
        TypedValueInstance(_) => false,
    };
    Ok(!result)
}

#[cfg(test)]
mod tests {
    use crate::compiler::value::parameters::{Parameter, Variable};
    use crate::compiler::value::primitives::Primitive::{Boolean, Integer, MyString};
    use crate::compiler::value::values::Value::{FunctionNameValue, PrimitiveValue};
    use crate::compiler::value::values::{FunctionDefinitionObject, TypeDefinition};
    use crate::runtime::bytecode::OpCode::{
        OpAdd, OpCall, OpCloseCursor, OpConst, OpEquals, OpGetField, OpGetGlobal, OpGetLocal, OpGt,
        OpJump, OpJumpIfFalse, OpLoop, OpNewInstance, OpNone, OpNot, OpOpenCursor, OpPop,
        OpProduce, OpPull, OpReturn, OpSetField, OpSetGlobal, OpSetLocal,
    };
    use crate::runtime::compiled_script::Executable;
    use crate::runtime::sink::AccumulatingSink;
    use crate::runtime::vm::VirtualMachine;
    use crate::runtime::RuntimeError;
    use crate::store::memory::MemoryStore;
    use crate::store::Store;
    use crate::{integer_to_value, string_to_value};

    #[test]
    fn test_addition() -> Result<(), RuntimeError> {
        let mut script = Executable::default();
        // define two constants
        script.script_constants = vec![
            PrimitiveValue(Integer(37)), // constant 0
            PrimitiveValue(Integer(5)),  // constant 1
        ];

        // and add them
        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                OpConst as u8, 0, // push constant 0
                OpConst as u8, 1, // push constant 1
                OpAdd as u8,    // add them
                OpReturn as u8, // exit vm
            ];
        }

        let mut vm = VirtualMachine::new();
        let result = vm.run(
            &script,
            &mut MemoryStore::new(),
            &mut AccumulatingSink::default(),
        )?;
        assert_eq!(result, PrimitiveValue(Integer(42)));
        Ok(())
    }

    #[test]
    fn test_greater_than() -> Result<(), RuntimeError> {
        let mut script = Executable::default();

        // define two constants
        script.script_constants = vec![
            PrimitiveValue(Integer(-12)), // constant 0
            PrimitiveValue(Integer(55)),  // constant 1
        ];

        // and compare them
        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                OpConst as u8, 0, // push constant 0
                OpConst as u8, 1, // push constant 1
                OpGt as u8,     // compare them
                OpReturn as u8, // exit vm
            ];
        }

        let mut vm = VirtualMachine::new();
        let result = vm.run(
            &script,
            &mut MemoryStore::new(),
            &mut AccumulatingSink::default(),
        )?;
        assert_eq!(result, PrimitiveValue(Boolean(false)));
        Ok(())
    }

    #[test]
    fn create_object() -> Result<(), RuntimeError> {
        let mut script = Executable::default();
        script.script_variables.push(Variable::new("a".to_string()));
        script.script_constants = vec![
            PrimitiveValue(MyString("Activity".to_string())),
            PrimitiveValue(MyString("field1".to_string())),
            PrimitiveValue(MyString("field2".to_string())),
            PrimitiveValue(Integer(-12)), // constant 0
            PrimitiveValue(Integer(55)),  // constant 1
        ];

        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                OpNewInstance as u8, 0, // Activity::new()
                OpConst as u8, 3,       // -12
                OpSetField as u8, 1,    // .field1 = -12
                OpConst as u8, 4,       // 55
                OpSetField as u8, 2,    // .field2 = 55
                OpGetField as u8, 1,    //
                OpSetGlobal as u8, 0,   // a = .field1
                OpReturn as u8, // exit vm
            ];
        }

        let mut vm = VirtualMachine::new();
        let mut store = MemoryStore::new();
        store.set_type_definition(
            "Activity",
            TypeDefinition {
                name: "Activity".to_string(),
                fields: vec![
                    ("field1".to_string(), "int".to_string()),
                    ("field2".to_string(), "int".to_string()),
                ],
            },
        )?;
        vm.run(&script, &mut store, &mut AccumulatingSink::default())?;

        assert_eq!(
            &integer_to_value!(-12),
            vm.global_variables.get("a").unwrap()
        );

        Ok(())
    }

    #[test]
    fn test_jump() -> Result<(), RuntimeError> {
        let mut script = Executable::default();
        script.script_variables.push(Variable::new("a".to_string()));
        script.script_variables.push(Variable::new("b".to_string()));
        script.script_constants.push(integer_to_value!(11));
        script.script_constants.push(integer_to_value!(22));
        script
            .script_constants
            .push(string_to_value!("a".to_string()));
        script
            .script_constants
            .push(string_to_value!("b".to_string()));

        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                // Op               // arg
                // set up a = 11
                OpConst as u8, 0,
                OpSetGlobal as u8, 0,
                // jump over next 2 instructions
                OpJump as u8, 4,
                // set a = 22
                OpConst as u8, 1,
                OpSetGlobal as u8, 0,
                // set b = 22 - this is to make sure that we jump to the correct place
                OpConst as u8, 1,
                OpSetGlobal as u8, 1,
                OpReturn as u8,
            ];
        }

        let mut vm = VirtualMachine::new();
        vm.run(
            &script,
            &mut MemoryStore::new(),
            &mut AccumulatingSink::default(),
        )?;

        assert_eq!(
            &integer_to_value!(11),
            vm.global_variables.get("a").unwrap()
        );
        assert_eq!(
            &integer_to_value!(22),
            vm.global_variables.get("b").unwrap()
        );

        Ok(())
    }

    #[test]
    fn test_jump_to_jump() -> Result<(), RuntimeError> {
        let mut script = Executable::default();
        script.script_variables.push(Variable::new("a".to_string()));
        script.script_variables.push(Variable::new("b".to_string()));

        script.script_constants.push(integer_to_value!(11));
        script.script_constants.push(integer_to_value!(22));
        script
            .script_constants
            .push(string_to_value!("a".to_string()));
        script
            .script_constants
            .push(string_to_value!("b".to_string()));

        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                // Op               // arg
                // set up a = 11
                OpConst as u8, 0,
                OpSetGlobal as u8, 0,
                // jump over next 2 instructions
                OpJump as u8, 4,
                // set a = 22
                OpConst as u8, 1,
                OpSetGlobal as u8, 0,
                // Jump to here, then jump another 5
                OpJump as u8, 5,
                OpNone as u8,
                OpNone as u8,
                OpNone as u8,
                OpNone as u8,
                OpNone as u8,
                // set b = 22
                OpConst as u8, 1,
                OpSetGlobal as u8, 1,
                OpReturn as u8,
            ];
        }

        let mut vm = VirtualMachine::new();
        vm.run(
            &script,
            &mut MemoryStore::new(),
            &mut AccumulatingSink::default(),
        )?;

        assert_eq!(
            &integer_to_value!(11),
            vm.global_variables.get("a").unwrap()
        );
        assert_eq!(
            &integer_to_value!(22),
            vm.global_variables.get("b").unwrap()
        );

        Ok(())
    }

    #[test]
    fn test_jump_if_false() -> Result<(), RuntimeError> {
        let mut script = Executable::default();
        script.script_variables.push(Variable::new("a".to_string()));
        script.script_variables.push(Variable::new("b".to_string()));

        script.script_constants.push(integer_to_value!(11));
        script.script_constants.push(integer_to_value!(22));
        script
            .script_constants
            .push(string_to_value!("a".to_string()));
        script
            .script_constants
            .push(string_to_value!("b".to_string()));

        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                // Op               // arg
                // set up a = 11
                OpConst as u8, 0,
                OpSetGlobal as u8, 0,
                // set up b = 22
                OpConst as u8, 1,
                OpSetGlobal as u8, 1,
                OpGetGlobal as u8, 0,
                OpGetGlobal as u8, 1,
                OpEquals as u8, // this is false
                OpJumpIfFalse as u8, 4,
                OpNone as u8,
                OpNone as u8,
                OpNone as u8,
                OpNone as u8,
                OpPop as u8,
                // set up b = 11
                OpConst as u8, 0,
                OpSetGlobal as u8, 1,
                OpGetGlobal as u8, 0,
                OpGetGlobal as u8, 1,
                OpEquals as u8,
                OpJumpIfFalse as u8, 255, // beyond range, will cause panic if it executes
                OpPop as u8,
                // set a = 22 so we can assert something
                OpConst as u8, 1,
                OpSetGlobal as u8, 0,
                OpReturn as u8,
            ];
        }

        let mut vm = VirtualMachine::new();
        vm.run(
            &script,
            &mut MemoryStore::new(),
            &mut AccumulatingSink::default(),
        )?;

        assert_eq!(
            &integer_to_value!(22),
            vm.global_variables.get("a").unwrap()
        );
        assert_eq!(
            &integer_to_value!(11),
            vm.global_variables.get("b").unwrap()
        );
        Ok(())
    }

    #[test]
    fn test_loop() -> Result<(), RuntimeError> {
        let mut script = Executable::default();
        script.script_variables.push(Variable::new("a".to_string()));

        script.script_constants.push(integer_to_value!(0));
        script.script_constants.push(integer_to_value!(1));
        script.script_constants.push(integer_to_value!(13));

        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                // Op               // arg
                // set up a = 0
                OpConst as u8, 0,
                OpSetGlobal as u8, 0,
                // check:
                // push a and limit
                OpGetGlobal as u8, 0,
                OpConst as u8, 2,
                // Compare
                OpEquals as u8,
                OpNot as u8,
                // Jump over loop body
                OpJumpIfFalse as u8, 10,
                OpPop as u8,
                OpConst as u8, 1,
                OpGetGlobal as u8, 0,
                OpAdd as u8,
                OpSetGlobal as u8, 0,
                OpLoop as u8, 18, // check:
                OpReturn as u8,
            ];
        }

        let mut vm = VirtualMachine::new();
        vm.run(
            &script,
            &mut MemoryStore::new(),
            &mut AccumulatingSink::default(),
        )?;

        assert_eq!(
            &integer_to_value!(13),
            vm.global_variables.get("a").unwrap()
        );
        Ok(())
    }

    #[test]
    fn open_pull_close_cursor() -> Result<(), RuntimeError> {
        let mut store = MemoryStore::new();
        store
            .set_function_value("f", &vec![integer_to_value!(1)], integer_to_value!(2))
            .unwrap();

        let mut script = Executable::default();

        script
            .script_constants
            .push(FunctionNameValue("f".to_string()));
        script.script_variables.push(Variable::new("a".to_string()));
        script.script_variables.push(Variable::new("b".to_string()));

        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                OpConst as u8, 0,
                OpOpenCursor as u8, 0,
                OpPull as u8, 0,
                OpSetGlobal as u8, 0,
                OpPop as u8,
                OpSetGlobal as u8, 1,
                OpPop as u8,
                OpCloseCursor as u8, 0,
                OpReturn as u8,
            ];
        }

        let mut vm = VirtualMachine::new();
        vm.run(&script, &mut store, &mut AccumulatingSink::default())?;

        assert_eq!(&integer_to_value!(1), vm.global_variables.get("a").unwrap());
        assert_eq!(&integer_to_value!(2), vm.global_variables.get("b").unwrap());

        Ok(())
    }

    #[test]
    fn test_cursor_pull_then_predicate_and_return() -> Result<(), RuntimeError> {
        // match f(x) -> (y), eq(x, y+1), return (x, y)

        let mut store = MemoryStore::new();
        store
            .set_function_value("f", &vec![integer_to_value!(1)], integer_to_value!(2))
            .unwrap();
        store
            .set_function_value("f", &vec![integer_to_value!(3)], integer_to_value!(4))
            .unwrap();
        let mut eq_fdo = FunctionDefinitionObject::new("eq".to_string());

        eq_fdo
            .formal_arguments
            .push(Parameter::Variable("x".to_string()));
        eq_fdo
            .formal_arguments
            .push(Parameter::Variable("y".to_string()));
        eq_fdo.variables.push(Variable::new("x".to_string()));
        eq_fdo.variables.push(Variable::new("y".to_string()));

        #[rustfmt::skip]
        {
            eq_fdo.bytecode.bytes = vec![
                OpGetLocal as u8, 0,
                OpGetLocal as u8, 1,
                OpEquals as u8,
                OpReturn as u8,
            ];
        }

        store
            .set_function_definition(
                "eq",
                &vec![
                    Parameter::Variable("x".to_string()),
                    Parameter::Variable("y".to_string()),
                ],
                eq_fdo,
            )
            .unwrap();

        let mut script = Executable::default();

        script
            .script_constants
            .push(FunctionNameValue("f".to_string()));
        script.script_constants.push(integer_to_value!(1));
        script
            .script_constants
            .push(FunctionNameValue("eq".to_string()));

        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                // prologue 1
                OpConst as u8, 0,
                OpOpenCursor as u8, 0,
                OpPull as u8, 0,
                OpJumpIfFalse as u8, 21, // exit:
                // body
                OpSetLocal as u8, 0,
                OpSetLocal as u8, 1,
                // prepare stack for calling eq, push x, y and const 1
                OpGetLocal as u8, 0,
                OpGetLocal as u8, 1,
                OpConst as u8, 1,
                OpAdd as u8,
                // Function name
                OpConst as u8, 2,
                OpCall as u8, 2,
                OpJumpIfFalse as u8, 2,
                OpProduce as u8, 0,
                OpLoop as u8, 25,
                OpCloseCursor as u8, 0,
                // exit:
                OpReturn as u8,
            ];
        }

        let mut vm = VirtualMachine::new();
        vm.run(&script, &mut store, &mut AccumulatingSink::default())?;

        Ok(())
    }

    #[test]
    fn test_self_join() -> Result<(), RuntimeError> {
        // match f(x), f(y), { print(x) print(y)}

        let mut store = MemoryStore::new();
        store
            .set_function_value("f", &vec![integer_to_value!(1)], integer_to_value!(2))
            .unwrap();
        store
            .set_function_value("f", &vec![integer_to_value!(3)], integer_to_value!(4))
            .unwrap();

        let mut script = Executable::default();
        script
            .script_constants
            .push(FunctionNameValue("f".to_string()));

        /*
        Produce { name: "f", name_const: 0, params: [[20, 0]] }

        Produce { name: "f", name_const: 0, params: [[20, 1]] }
        Block { code: Bytecode { bytes: [21, 0, 24, 21, 1, 24] }
        */

        #[rustfmt::skip]
        {
            script.script_bytecode.bytes = vec![
                // prologue 1
                OpConst as u8, 0,
                OpOpenCursor as u8, 0,
                OpPull as u8, 0,
                OpJumpIfFalse as u8, 24,
                // body 1
                OpSetLocal as u8, 0,
                OpPop as u8,
                // prologue 2
                OpConst as u8, 0,
                OpOpenCursor as u8, 1,
                OpPull as u8, 1,
                OpJumpIfFalse as u8, 10,
                // body 2
                OpSetLocal as u8, 1,
                OpPop as u8,
                OpGetLocal as u8, 0,
                OpGetLocal as u8, 1,
                // epilogue 2
                OpLoop as u8, 13,
                OpCloseCursor as u8, 1,
                // epilogue 1
                OpLoop as u8, 28,
                OpCloseCursor as u8, 0,
                // return
                OpReturn as u8,
            ];
        }

        let mut vm = VirtualMachine::new();
        vm.run(&script, &mut store, &mut AccumulatingSink::default())?;

        Ok(())
    }
}