#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub struct ExpressionStatement {

    pub this: ExpressionStatementId,

    // Phase 1: parser

    pub position: InputPosition,

    pub expression: ExpressionId,

    // Phase 2: linker

    pub next: Option<StatementId>,

}

impl SyntaxElement for ExpressionStatement {

    fn position(&self) -> InputPosition {

        self.position

    }

}

#[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]

pub enum ExpressionParent {

    None, // only set during initial parsing

    Memory(MemoryStatementId),

    If(IfStatementId),

    While(WhileStatementId),

    Return(ReturnStatementId),

    Assert(AssertStatementId),

    Put(PutStatementId, u32), // index of arg

    ExpressionStmt(ExpressionStatementId),

    Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)

}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub enum Expression {

    Assignment(AssignmentExpression),

    Conditional(ConditionalExpression),

    Binary(BinaryExpression),

    Unary(UnaryExpression),

    Indexing(IndexingExpression),

    Slicing(SlicingExpression),

    Select(SelectExpression),

    Array(ArrayExpression),

    Constant(ConstantExpression),

    Call(CallExpression),

    Variable(VariableExpression),

}

impl Expression {

    pub fn as_assignment(&self) -> &AssignmentExpression {

        match self {

            Expression::Assignment(result) => result,

            embedded.extend(&symbolic.poly_args);

        }

    };

    if !embedded.is_empty() {

        target.write_str("<");

        for (idx, embedded_id) in embedded.into_iter().enumerate() {

            if idx != 0 { target.write_str(", "); }

            write_type(target, heap, &heap[embedded_id]);

        }

        target.write_str(">");

    }

}

fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {

    use ExpressionParent as EP;

    *target = match parent {

        EP::None => String::from("None"),

        EP::Memory(id) => format!("MemoryStmt({})", id.0.0.index),

        EP::If(id) => format!("IfStmt({})", id.0.index),

        EP::While(id) => format!("WhileStmt({})", id.0.index),

        EP::Return(id) => format!("ReturnStmt({})", id.0.index),

        EP::Assert(id) => format!("AssertStmt({})", id.0.index),

        EP::Put(id, idx) => format!("PutStmt({}, {})", id.0.index, idx),

        EP::ExpressionStmt(id) => format!("ExprStmt({})", id.0.index),

        EP::Expression(id, idx) => format!("Expr({}, {})", id.index, idx)

    };

}

//      (which may be embedded) and store them in some kind of map.

//  - go through entire AST and visit all expressions depth-first. We will

//      attempt to resolve the return type of each expression. If we can't then

//      we store them in another lookup map and link the dependency on an

//      inferred variable to that expression.

//  - keep iterating until we have completely resolved all variables.

/// This particular visitor will recurse depth-first into the AST and ensures

/// that all expressions have the appropriate types. At the moment this implies:

///

///     - Type checking arguments to unary and binary operators.

///     - Type checking assignment, indexing, slicing and select expressions.

///     - Checking arguments to functions and component instantiations.

///

/// This will be achieved by slowly descending into the AST. At any given

/// expression we may depend on

pub(crate) struct TypeResolvingVisitor {

    // Tracking traversal state

    expr_type: ExprType,

    // Buffers for iteration over substatements and subexpressions

    stmt_buffer: Vec<StatementId>,

    expr_buffer: Vec<ExpressionId>,

    env: HashMap<ParserTypeId, ConcreteTypeVariant>

}

impl TypeResolvingVisitor {

    pub(crate) fn new() -> Self {

        TypeResolvingVisitor{

            expr_type: ExprType::Regular,

            stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),

            expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),

            env: HashMap::new(),

        }

    }

    fn reset(&mut self) {

        self.expr_type = ExprType::Regular;

    }

}

impl Visitor2 for TypeResolvingVisitor {

    // Definitions

    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {

        let body_stmt_id = ctx.heap[id].body;

        self.visit_stmt(ctx, body_stmt_id)

    }

    fn visit_assert_stmt(&mut self, ctx: &mut Ctx, id: AssertStatementId) -> VisitorResult {

        let stmt = &ctx.heap[id];

        if self.performing_breadth_pass {

            if self.def_type == DefinitionType::Function {

                // TODO: We probably want to allow this. Mark the function as

                //  using asserts, and then only allow calls to these functions

                //  within components. Such a marker will cascade through any

                //  functions that then call an asserting function

                return Err(

                    ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement in a function")

                );

            }

            // We are in a component of some sort, but we also need to be within a

            // synchronous statement

            if self.in_sync.is_none() {

                return Err(

                    ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement outside of a synchronous block")

                );

            }

        } else {

            debug_assert_eq!(self.expr_parent, ExpressionParent::None);

            let expr_id = stmt.expression;

            self.visit_expr(ctx, expr_id)?;

        }

        Ok(())

    }

    fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {

        if !self.performing_breadth_pass {

            // Must perform goto label resolving after the breadth pass, this

            // way we are able to find all the labels in current and outer

            // scopes.

            let target_id = self.find_label(ctx, &ctx.heap[id].label)?;

            ctx.heap[id].target = Some(target_id);

            let target = &ctx.heap[target_id];

            if self.in_sync != target.in_sync {

                // We can only goto the current scope or outer scopes. Because

                // nested sync statements are not allowed so if the value does

                // not match, then we must be inside a sync scope

                debug_assert!(self.in_sync.is_some());

                let goto_stmt = &ctx.heap[id];

                let sync_stmt = &ctx.heap[self.in_sync.unwrap()];

                return Err(

                    ParseError2::new_error(&ctx.module.source, goto_stmt.position, "Goto may not escape the surrounding synchronous block")

                        .with_postfixed_info(&ctx.module.source, target.position, "This is the target of the goto statement")

                            return Err(ParseError2::new_error(

                                &ctx.module.source, symbolic.identifier.position,

                                "Could not find a defined component with this name"

                            ))

                        }

                    }

                } else {

                    return Err(

                        ParseError2::new_error(&ctx.module.source, call_expr.position, "Must instantiate a component")

                    );

                }

            };

            // Modify new statement's symbolic call to point to the appropriate

            // definition.

            let call_expr = &mut ctx.heap[call_expr_id];

            match &mut call_expr.method {

                Method::Symbolic(method) => method.definition = Some(definition_id),

                _ => unreachable!()

            }

        } else {

            // Performing depth pass. The function definition should have been

            // resolved in the breadth pass, now we recurse to evaluate the

            // arguments

            let call_expr_id = ctx.heap[id].expression;

            let old_num_exprs = self.expression_buffer.len();

            self.expression_buffer.extend(&call_expr.arguments);

            let new_num_exprs = self.expression_buffer.len();

            for arg_expr_idx in old_num_exprs..new_num_exprs {

                let arg_expr_id = self.expression_buffer[arg_expr_idx];

                self.visit_expr(ctx, arg_expr_id)?;

            }

            self.expression_buffer.truncate(old_num_exprs);

        }

        Ok(())

    }

    fn visit_put_stmt(&mut self, ctx: &mut Ctx, id: PutStatementId) -> VisitorResult {

        // TODO: Make `put` an expression. Perhaps silly, but much easier to

        //  perform typechecking

        if self.performing_breadth_pass {

            let put_stmt = &ctx.heap[id];

            if self.in_sync.is_none() {

                return Err(ParseError2::new_error(

                    &ctx.module.source, put_stmt.position, "Put must be called in a synchronous block"

                ));

            }

        } else {

            let put_stmt = &ctx.heap[id];

            let port = put_stmt.port;

            let message = put_stmt.message;

            debug_assert_eq!(self.expr_parent, ExpressionParent::None);

            self.expr_parent = ExpressionParent::Put(id, 0);

            self.visit_expr(ctx, port)?;

            self.expr_parent = ExpressionParent::Put(id, 1);

        let upcast_id = id.upcast();

        let assignment_expr = &mut ctx.heap[id];

        let left_expr_id = assignment_expr.left;

        let right_expr_id = assignment_expr.right;

        let old_expr_parent = self.expr_parent;

        assignment_expr.parent = old_expr_parent;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 0);

        self.visit_expr(ctx, left_expr_id)?;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 1);

        self.visit_expr(ctx, right_expr_id)?;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let upcast_id = id.upcast();

        let conditional_expr = &mut ctx.heap[id];

        let test_expr_id = conditional_expr.test;

        let true_expr_id = conditional_expr.true_expression;

        let false_expr_id = conditional_expr.false_expression;

        let old_expr_parent = self.expr_parent;

        conditional_expr.parent = old_expr_parent;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 0);

        self.visit_expr(ctx, test_expr_id)?;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 1);

        self.visit_expr(ctx, true_expr_id)?;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 2);

        self.visit_expr(ctx, false_expr_id)?;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let left_expr_id = binary_expr.left;

        let right_expr_id = binary_expr.right;

        self.visit_expr(ctx, left_expr_id)?;

        self.visit_expr(ctx, right_expr_id)?;

        Ok(())

    }

    fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        self.visit_expr(ctx, expr_id)?;

        Ok(())

    }

    fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let subject_expr_id = indexing_expr.subject;

        let index_expr_id = indexing_expr.index;

        self.visit_expr(ctx, subject_expr_id)?;

        self.visit_expr(ctx, index_expr_id)?;

        Ok(())

    }

    fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let subject_expr_id = slicing_expr.subject;

        let from_expr_id = slicing_expr.from_index;

        let to_expr_id = slicing_expr.to_index;

        self.visit_expr(ctx, subject_expr_id)?;

        self.visit_expr(ctx, from_expr_id)?;

        self.visit_expr(ctx, to_expr_id)?;

        Ok(())

    }

    fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        self.visit_expr(ctx, expr_id)?;

        Ok(())

    }

    fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let old_num_exprs = self.expression_buffer.len();

        self.expression_buffer.extend(&array_expr.elements);

        let new_num_exprs = self.expression_buffer.len();

        for field_expr_idx in old_num_exprs..new_num_exprs {

            let field_expr_id = self.expression_buffer[field_expr_idx];

            self.visit_expr(ctx, field_expr_id)?;

        }

        self.expression_buffer.truncate(old_num_exprs);

        Ok(())

    }

        debug_assert!(!self.performing_breadth_pass);

        Ok(())

    }

    fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let call_expr = &mut ctx.heap[id];

        // Resolve the method to the appropriate definition and check the

        // legality of the particular method call.

        match &mut call_expr.method {

            Method::Create => {},

            Method::Fires => {

                if self.def_type != DefinitionType::Primitive {

                    return Err(ParseError2::new_error(

                        &ctx.module.source, call_expr.position,

                        "A call to 'fires' may only occur in primitive component definitions"

                    ));

                }

            },

            Method::Get => {

                if self.def_type != DefinitionType::Primitive {

                    return Err(ParseError2::new_error(

                        &ctx.module.source, call_expr.position,

                let found_symbol = self.find_symbol_of_type(

                    ctx.module.root_id, &ctx.symbols, &ctx.types,

                    &symbolic.identifier, TypeClass::Function

                );

                let definition_id = match found_symbol {

                    FindOfTypeResult::Found(definition_id) => definition_id,

                    FindOfTypeResult::TypeMismatch(got_type_class) => {

                        return Err(ParseError2::new_error(

                            &ctx.module.source, symbolic.identifier.position,

                            &format!("Only functions can be called, this identifier points to a {}", got_type_class)

                        ))

                    },

                    FindOfTypeResult::NotFound => {

                        return Err(ParseError2::new_error(

                            &ctx.module.source, symbolic.identifier.position,

                            &format!("Could not find a function with this name")

                        ))

                    }

                };

                symbolic.definition = Some(definition_id);

            }

        }

        let call_expr = &mut ctx.heap[id];

        let old_num_exprs = self.expression_buffer.len();

        self.expression_buffer.extend(&call_expr.arguments);

        let new_num_exprs = self.expression_buffer.len();

        for arg_expr_idx in old_num_exprs..new_num_exprs {

            let arg_expr_id = self.expression_buffer[arg_expr_idx];

            self.visit_expr(ctx, arg_expr_id)?;

        }

        self.expression_buffer.truncate(old_num_exprs);

        Ok(())

    }

    fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let var_expr = &ctx.heap[id];

        let variable_id = self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier)?;

        let var_expr = &mut ctx.heap[id];

        var_expr.declaration = Some(variable_id);

        Ok(())

    }

}

enum FindOfTypeResult {

    // Identifier was exactly matched, type matched as well

    Found(DefinitionId),

    // Identifier was matched, but the type differs from the expected one

    TypeMismatch(&'static str),

    // Identifier could not be found

    NotFound,

}

impl ValidityAndLinkerVisitor {

    //--------------------------------------------------------------------------

    // Special traversal

    //--------------------------------------------------------------------------

    /// Will visit a statement with a hint about its wrapping statement. This is

    /// used to distinguish block statements with a wrapping synchronous

    /// statement from normal block statements.

    fn visit_stmt_with_hint(&mut self, ctx: &mut Ctx, id: StatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {

        if let Statement::Block(block_stmt) = &ctx.heap[id] {