define_aliased_ast_id!(VariableId, Id<Variable>, index(Variable, variables), alloc(alloc_variable));

pub enum VariableKind {

    Parameter,

    Local,

pub struct Variable {

    pub this: VariableId,

    // Parsing

    pub kind: VariableKind,

    // Validator/linker

    pub unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated

    pub fn parameters(&self) -> &Vec<VariableId> {

        match self {

            Definition::Component(def) => &def.parameters,

            Definition::Function(def) => &def.parameters,

            _ => panic!("Called parameters() on {:?}", self)

        }

    }

    pub parameters: Vec<VariableId>,

    pub parameters: Vec<VariableId>,

                LocalStatement::Channel(stmt) => stmt.next = next,

                LocalStatement::Memory(stmt) => stmt.next = next,

            Statement::EndIf(stmt) => stmt.next = next,

            Statement::EndWhile(stmt) => stmt.next = next,

            Statement::EndSynchronous(stmt) => stmt.next = next,

            Statement::New(stmt) => stmt.next = next,

            Statement::Expression(stmt) => stmt.next = next,

    pub parent_scope: Scope,

    pub first_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated

    pub next_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated

    pub variable: VariableId,

    pub next: StatementId,

    pub from: VariableId, // output

    pub to: VariableId,   // input

    pub next: StatementId,

    pub next: StatementId,

    pub next: StatementId,

    pub next: StatementId,

    pub next: StatementId,

    pub next: StatementId,

#[derive(Debug, Clone, Copy)]

    // Parsing

    // Validator/Linker

    // Typing

    // Parsing

    // Validator/Linker

    // Typing

    // Parsing

    // Validator/Linking

    // Typing

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

    // Parsing

    // Validator/Linker

    // Typing

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

pub enum UnaryOperator {

    // Parsing

    pub operation: UnaryOperator,

    // Validator/Linker

    // Typing

    // Parsing

    // Validator/Linker

    // Typing

    // Parsing

    // Validator/Linker

    // Typing

    // Parsing

    // Validator/Linker

    // Typing

    // Parsing

    // Validator/Linker

    // Typing

    // Parsing

    // Validator/Linker

    // Typing

    // Parsing

    // Validator/Linker

    // Typing

                self.kv(indent2).with_s_key("FirstUniqueScopeID").with_disp_val(&stmt.first_unique_id_in_scope);

                self.kv(indent2).with_s_key("NextUniqueScopeID").with_disp_val(&stmt.next_unique_id_in_scope);

                self.kv(indent2).with_s_key("RelativePos").with_disp_val(&stmt.relative_pos_in_parent);

                self.kv(indent2).with_s_key("Statements");

                    self.write_stmt(heap, *stmt_id, indent3);

                        self.write_variable(heap, stmt.from, indent3);

                        self.write_variable(heap, stmt.to, indent3);

                        self.write_variable(heap, stmt.variable, indent3);

    fn write_variable(&mut self, heap: &Heap, variable_id: VariableId, indent: usize) {

        let var = &heap[variable_id];

        self.kv(indent).with_id(PREFIX_VARIABLE_ID, variable_id.0.index)

            .with_s_key("Variable");

        self.kv(indent2).with_s_key("Name").with_identifier_val(&var.identifier);

        self.kv(indent2).with_s_key("Kind").with_debug_val(&var.kind);

            .with_custom_val(|w| write_parser_type(w, heap, &var.parser_type));

        self.kv(indent2).with_s_key("RelativePos").with_disp_val(&var.relative_pos_in_block);

        self.kv(indent2).with_s_key("UniqueScopeID").with_disp_val(&var.unique_id_in_scope);

/// eval

///

/// Evaluator of the generated AST. Note that we use some misappropriated terms

/// to describe where values live and what they do. This is a temporary

/// implementation of an evaluator until some kind of appropriate bytecode or

/// machine code is generated.

///

/// Code is always executed within a "frame". For Reowolf the first frame is

/// usually an executed component. All subsequent frames are function calls.

/// Simple values live on the "stack". Each variable/parameter has a place on

/// the stack where its values are stored. If the value is not a primitive, then

/// its value will be stored in the "heap". Expressions are treated differently

/// and use a separate "stack" for their evaluation.

///

/// Since this is a value-based language, most values are copied. One has to be

/// careful with values that reside in the "heap" and make sure that copies are

/// properly removed from the heap..

///

/// Just to reiterate: this is a temporary implementation. A proper

/// implementation would fully fill out the type table with alignment/size/

/// offset information and lay out bytecode.

mod value;

use std::collections::VecDeque;

use super::value::*;

use crate::PortId;

use crate::protocol::ast::*;

use crate::protocol::*;

struct HeapAllocation {

    values: Vec<Value>,

}

struct Store {

    // The stack where variables/parameters are stored. Note that this is a

    // non-shrinking stack. So it may be filled with garbage.

    stack: Vec<Value>,

    // Represents the place in the stack where we find the `PrevStackBoundary`

    // value containing the previous stack boundary. This is so we can pop from

    // the stack after function calls.

    cur_stack_boundary: usize,

    // A rather ridiculous simulated heap, but this allows us to "allocate"

    // things that occupy more then one stack slot.

    heap_regions: Vec<HeapAllocation>,

    free_regions: VecDeque<HeapPos>,

}

impl Store {

    fn new() -> Self {

        let mut store = Self{

            stack: Vec::with_capacity(64),

            cur_stack_boundary: 0,

            heap_regions: Vec::new(),

            free_regions: VecDeque::new(),

        };

        store.stack.push(Value::PrevStackBoundary(-1));

        store

    }

    /// Resizes(!) the stack to fit the required number of values. Any

    /// unallocated slots are initialized to `Unassigned`. The specified stack

    /// index is exclusive.

    fn reserve_stack(&mut self, unique_stack_idx: usize) {

        let new_size = self.cur_stack_boundary + unique_stack_idx + 1;

        if new_size > self.stack.len() {

            self.stack.resize(new_size, Value::Unassigned);

        }

    }

    /// Clears values on the stack and removes their heap allocations when

    /// applicable. The specified index itself will also be cleared (so if you

    /// specify 0 all values in the frame will be destroyed)

    fn clear_stack(&mut self, unique_stack_idx: usize) {

        let new_size = self.cur_stack_boundary + unique_stack_idx + 1;

        for idx in new_size..self.stack.len() {

            self.drop_value(&self.stack[idx]);

            self.stack[idx] = Value::Unassigned;

        }

    }

    /// Reads a value from a specific address. The value is always copied, hence

    /// if the value ends up not being written, one should call `drop_value` on

    /// it.

    fn read_copy(&mut self, address: ValueId) -> Value {

        match value {

            ValueId::Stack(pos) => {

                let cur_pos = self.cur_stack_boundary + 1 + pos as usize;

                return self.clone_value(&self.stack[cur_pos]);

            },

            ValueId::Heap(heap_pos, region_idx) => {

                return self.clone_value(&self.heap_regions[heap_pos as usize].values[region_idx as usize])

            }

        }

    }

    /// Returns an immutable reference to the value pointed to by an address

    fn read_ref(&mut self, address: ValueId) -> &Value {

        match value {

            ValueId::Stack(pos) => {

                let cur_pos = self.cur_stack_boundary + 1 + pos as usize;

                return &self.stack[cur_pos];

            },

            ValueId::Heap(heap_pos, region_idx) => {

                return &self.heap_regions[heap_pos as usize].values[region_idx as usize];

            }

        }

    }

    /// Returns a mutable reference to the value pointed to by an address

    fn read_mut_ref(&mut self, address: ValueId) -> &mut Value {

        match value {

            ValueId::Stack(pos) => {

                let cur_pos = self.cur_stack_boundary + 1 + pos as usize;

                return &mut self.stack[cur_pos];

            },

            ValueId::Heap(heap_pos, region_idx) => {

                return &mut self.heap_regions[heap_pos as usize].values[region_idx as usize];

            }

        }

    }

    /// Writes a value

    fn write(&mut self, address: ValueId, value: Value) {

        match address {

            ValueId::Stack(pos) => {

                let cur_pos = self.cur_stack_boundary + 1 + pos as usize;

                self.drop_value(&self.stack[cur_pos]);

                self.stack[cur_pos] = value;

            },

            ValueId::Heap(heap_pos, region_idx) => {

                let heap_pos = heap_pos as usize;

                let region_idx = region_idx as usize;

                self.drop_value(&self.heap_regions[heap_pos].values[region_idx]);

                self.heap_regions[heap_pos].values[region_idx] = value

            }

        }

    }

    fn clone_value(&mut self, value: &Value) -> Value {

        // Quickly check if the value is not on the heap

        let source_heap_pos = value.get_heap_pos();

        if source_heap_pos.is_none() {

            // We can do a trivial copy

            return value.clone();

        }

        // Value does live on heap, copy it

        let source_heap_pos = source_heap_pos.unwrap() as usize;

        let target_heap_pos = self.alloc_heap();

        let target_heap_pos_usize = target_heap_pos as usize;

        let num_values = self.heap_regions[source_heap_pos].values.len();

        for value_idx in 0..num_values {

            let cloned = self.clone_value(&self.heap_regions[source_heap_pos].values[value_idx]);

            self.heap_regions[target_heap_pos_usize].values.push(cloned);

        }

        match value {

            Value::Message(_) => Value::Message(target_heap_pos),

            Value::Array(_) => Value::Array(target_heap_pos),

            Value::Union(tag, _) => Value::Union(*tag, target_heap_pos),

            Value::Struct(_) => Value::Struct(target_heap_pos),

            _ => unreachable!("performed clone_value on heap, but {:?} is not a heap value", value),

        }

    }

    fn drop_value(&mut self, value: &Value) {

        if let Some(heap_pos) = value.get_heap_pos() {

            self.drop_heap_pos(heap_pos);

        }

    }

    fn drop_heap_pos(&mut self, heap_pos: HeapPos) {

        let num_values = self.heap_regions[heap_pos as usize].values.len();

        for value_idx in 0..num_values {

            if let Some(other_heap_pos) = self.heap_regions[heap_pos as usize].values[value_idx].get_heap_pos() {

                self.drop_heap_pos(other_heap_pos);

            }

        }

        self.heap_regions[heap_pos as usize].values.clear();

        self.free_regions.push_back(heap_pos);

    }

    fn alloc_heap(&mut self) -> HeapPos {

        if self.free_regions.is_empty() {

            let idx = self.heap_regions.len() as HeapPos;

            self.heap_regions.push(HeapAllocation{ values: Vec::new() });

            return idx;

        } else {

            let idx = self.free_regions.pop_back().unwrap();

            return idx;

        }

    }

}

enum ExprInstruction {

    EvalExpr(ExpressionId),

    PushValToFront,

}

struct Frame {

    definition: DefinitionId,

    position: StatementId,

    expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back

    expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back

}

impl Frame {

    /// Creates a new execution frame. Does not modify the stack in any way.

    pub fn new(heap: &Heap, definition_id: DefinitionId) -> Self {

        let definition = &heap[definition_id];

        let first_statement = match definition {

            Definition::Component(definition) => definition.body,

            Definition::Function(definition) => definition.body,

            _ => unreachable!("initializing frame with {:?} instead of a function/component", definition),

        };

        Frame{

            definition: definition_id,

            position: first_statement.upcast(),

            expr_stack: VecDeque::with_capacity(128),

            expr_values: VecDeque::with_capacity(128),

        }

    }

    /// Prepares a single expression for execution. This involves walking the

    /// expression tree and putting them in the `expr_stack` such that

    /// continuously popping from its back will evaluate the expression. The

    /// results of each expression will be stored by pushing onto `expr_values`.

    pub fn prepare_single_expression(&mut self, heap: &Heap, expr_id: ExpressionId) {

        debug_assert!(self.expr_stack.is_empty());

        self.expr_values.clear(); // May not be empty if last expression result(s) were discarded

        self.serialize_expression(heap, expr_id);

    }

    /// Prepares multiple expressions for execution (i.e. evaluating all

    /// function arguments or all elements of an array/union literal). Per

    /// expression this works the same as `prepare_single_expression`. However

    /// after each expression is evaluated we insert a `PushValToFront`

    /// instruction

    pub fn prepare_multiple_expressions(&mut self, heap: &Heap, expr_ids: &[ExpressionId]) {

        debug_assert!(self.expr_stack.is_empty());

        self.expr_values.clear();

        for expr_id in expr_ids {

            self.expr_stack.push_back(ExprInstruction::PushValToFront);

            self.serialize_expression(heap, *expr_id);

        }

    }

    /// Performs depth-first serialization of expression tree. Let's not care

    /// about performance for a temporary runtime implementation

    fn serialize_expression(&mut self, heap: &Heap, id: ExpressionId) {

        self.expr_stack.push_back(ExprInstruction::EvalExpr(id));

        match &heap[id] {

            Expression::Assignment(expr) => {

                self.serialize_expression(heap, expr.left);

                self.serialize_expression(heap, expr.right);

            },

            Expression::Binding(expr) => {

                todo!("implement binding expression");

            },

            Expression::Conditional(expr) => {

                self.serialize_expression(heap, expr.test);

            },

            Expression::Binary(expr) => {

                self.serialize_expression(heap, expr.left);

                self.serialize_expression(heap, expr.right);

            },

            Expression::Unary(expr) => {

                self.serialize_expression(heap, expr.expression);

            },

            Expression::Indexing(expr) => {

                self.serialize_expression(heap, expr.index);

                self.serialize_expression(heap, expr.subject);

            },

            Expression::Slicing(expr) => {

                self.serialize_expression(heap, expr.from_index);

                self.serialize_expression(heap, expr.to_index);

                self.serialize_expression(heap, expr.subject);

            },

            Expression::Select(expr) => {

                self.serialize_expression(heap, expr.subject);

            },

            Expression::Literal(expr) => {

                // Here we only care about literals that have subexpressions

                match &expr.value {

                    Literal::Null | Literal::True | Literal::False |

                    Literal::Character(_) | Literal::String(_) |

                    Literal::Integer(_) | Literal::Enum(_) => {

                        // No subexpressions

                    },

                    Literal::Struct(literal) => {

                        for field in &literal.fields {

                            self.expr_stack.push_back(ExprInstruction::PushValToFront);

                            self.serialize_expression(heap, field.value);

                        }

                    },

                    Literal::Union(literal) => {

                        for value_expr_id in &literal.values {

                            self.expr_stack.push_back(ExprInstruction::PushValToFront);

                            self.serialize_expression(heap, *value_expr_id);

                        }

                    },

                    Literal::Array(value_expr_ids) => {

                        for value_expr_id in value_expr_ids {

                            self.expr_stack.push_back(ExprInstruction::PushValToFront);

                            self.serialize_expression(heap, *value_expr_id);

                        }

                    }

                }

            },

            Expression::Call(expr) => {

                for arg_expr_id in &expr.arguments {

                    self.expr_stack.push_back(ExprInstruction::PushValToFront);

                    self.serialize_expression(heap, *arg_expr_id);

                }

            },

            Expression::Variable(expr) => {

                // No subexpressions