// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use crate::bind_program::{Condition, ConditionOp, Statement};
use crate::compiler::{self, Symbol, SymbolTable, SymbolicInstruction, SymbolicInstructionInfo};
use crate::device_specification::{DeviceSpecification, Property};
use crate::errors::UserError;
use crate::instruction::{InstructionDebug, RawAstLocation};
use crate::parser_common::{self, CompoundIdentifier, Span, Value};
use std::collections::{HashMap, HashSet};
use std::fmt;
use std::str::FromStr;
use thiserror::Error;

#[derive(Debug, Error, Clone, PartialEq)]
pub enum DebuggerError {
    BindParserError(parser_common::BindParserError),
    CompilerError(compiler::CompilerError),
    DuplicateKey(CompoundIdentifier),
    MissingLabel,
    NoOutcome,
    IncorrectAstLocation,
    InvalidAstLocation,
    UnknownKey(CompoundIdentifier),
    InvalidValueSymbol(Symbol),
}

impl fmt::Display for DebuggerError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", UserError::from(self.clone()))
    }
}

type DevicePropertyMap = HashMap<Symbol, DeviceValue>;

#[derive(Debug, PartialEq)]
struct DeviceValue {
    symbol: Option<Symbol>,
    identifier: Option<CompoundIdentifier>,
}

#[derive(Debug, PartialEq)]
pub enum AstLocation<'a> {
    ConditionStatement(Statement<'a>),
    AcceptStatementValue { identifier: CompoundIdentifier, value: Value, span: Span<'a> },
    AcceptStatementFailure { identifier: CompoundIdentifier, symbol: Symbol, span: Span<'a> },
    IfCondition(Condition<'a>),
    AbortStatement(Statement<'a>),
}

impl<'a> AstLocation<'a> {
    pub fn to_instruction_debug(self) -> InstructionDebug {
        match self {
            AstLocation::ConditionStatement(statement) => InstructionDebug {
                line: statement.get_span().line,
                ast_location: RawAstLocation::ConditionStatement,
                extra: 0,
            },
            AstLocation::AcceptStatementValue { span, .. } => InstructionDebug {
                line: span.line,
                ast_location: RawAstLocation::AcceptStatementValue,
                extra: 0,
            },
            AstLocation::AcceptStatementFailure { span, symbol, .. } => InstructionDebug {
                line: span.line,
                ast_location: RawAstLocation::AcceptStatementFailure,
                extra: symbol.to_bytecode(),
            },
            AstLocation::IfCondition(condition) => InstructionDebug {
                line: condition.span.line,
                ast_location: RawAstLocation::IfCondition,
                extra: 0,
            },
            AstLocation::AbortStatement(statement) => InstructionDebug {
                line: statement.get_span().line,
                ast_location: RawAstLocation::AbortStatement,
                extra: 0,
            },
        }
    }
}

#[derive(Debug, PartialEq)]
enum DebuggerOutput<'a> {
    ConditionStatement {
        statement: &'a Statement<'a>,
        success: bool,
    },
    AbortStatement {
        statement: &'a Statement<'a>,
    },
    AcceptStatementSuccess {
        identifier: &'a CompoundIdentifier,
        value: &'a Value,
        value_symbol: &'a Symbol,
        span: &'a Span<'a>,
    },
    AcceptStatementFailure {
        identifier: &'a CompoundIdentifier,
        span: &'a Span<'a>,
    },
    IfCondition {
        condition: &'a Condition<'a>,
        success: bool,
    },
}

pub fn debug_from_str<'a>(
    instructions: &[SymbolicInstructionInfo<'a>],
    symbol_table: &SymbolTable,
    device_file: &str,
) -> Result<bool, DebuggerError> {
    let device_specification =
        DeviceSpecification::from_str(device_file).map_err(DebuggerError::BindParserError)?;

    debug_from_device_specification(instructions, symbol_table, device_specification)
}

pub fn debug_from_device_specification<'a>(
    instructions: &[SymbolicInstructionInfo<'a>],
    symbol_table: &SymbolTable,
    device_specification: DeviceSpecification,
) -> Result<bool, DebuggerError> {
    let mut debugger = Debugger::new(&device_specification.properties, instructions, symbol_table)?;
    let binds = debugger.evaluate_bind_program()?;
    debugger.log_output()?;
    Ok(binds)
}

struct Debugger<'a> {
    device_properties: DevicePropertyMap,
    instructions: &'a [SymbolicInstructionInfo<'a>],
    symbol_table: &'a SymbolTable,
    output: Vec<DebuggerOutput<'a>>,
}

impl<'a> Debugger<'a> {
    fn new(
        properties: &[Property],
        instructions: &'a [SymbolicInstructionInfo<'a>],
        symbol_table: &'a SymbolTable,
    ) -> Result<Self, DebuggerError> {
        let device_properties = Debugger::construct_property_map(properties, symbol_table)?;
        let output = Vec::new();
        Ok(Debugger { device_properties, instructions, symbol_table, output })
    }

    /// Constructs a map of the device's properties. The keys are of type Symbol, and only keys
    /// which appear in the bind program's symbol table are included. Any other keys in the device
    /// specification can be safely ignored, since the bind program won't check their values. The
    /// values are a struct containing both a symbol and an identifier, to allow the debugger to
    /// output both the identifier and the literal value it corresponds to when printing values.
    /// Both these fields are optional. If the symbol is None, then the device value is an
    /// identifier not defined in the symbol table. If the identifier is None, then the device
    /// value is a literal.
    fn construct_property_map(
        properties: &[Property],
        symbol_table: &SymbolTable,
    ) -> Result<DevicePropertyMap, DebuggerError> {
        let mut property_map = HashMap::new();
        let mut keys_seen = HashSet::new();

        for Property { key, value } in properties {
            // Check for duplicate keys in the device specification. This is done using a separate
            // set since the property_map only contains keys which are present in the symbol table.
            if keys_seen.contains(key) {
                return Err(DebuggerError::DuplicateKey(key.clone()));
            }
            keys_seen.insert(key.clone());

            if let Some(key_symbol) = symbol_table.get(key) {
                let device_value = match value {
                    Value::NumericLiteral(n) => {
                        DeviceValue { symbol: Some(Symbol::NumberValue(*n)), identifier: None }
                    }
                    Value::StringLiteral(s) => DeviceValue {
                        symbol: Some(Symbol::StringValue(s.to_string())),
                        identifier: None,
                    },
                    Value::BoolLiteral(b) => {
                        DeviceValue { symbol: Some(Symbol::BoolValue(*b)), identifier: None }
                    }
                    Value::Identifier(identifier) => match symbol_table.get(identifier) {
                        Some(symbol) => DeviceValue {
                            symbol: Some(symbol.clone()),
                            identifier: Some(identifier.clone()),
                        },
                        None => DeviceValue { symbol: None, identifier: Some(identifier.clone()) },
                    },
                };

                property_map.insert(key_symbol.clone(), device_value);
            }
        }

        Ok(property_map)
    }

    fn evaluate_bind_program(&mut self) -> Result<bool, DebuggerError> {
        let mut instructions = self.instructions.iter();

        while let Some(mut instruction) = instructions.next() {
            let mut jump_label = None;

            match &instruction.instruction {
                SymbolicInstruction::AbortIfEqual { lhs, rhs } => {
                    let aborts = self.device_property_matches(lhs, rhs);
                    self.output_abort_if(&instruction.location, aborts)?;
                    if aborts {
                        return Ok(false);
                    }
                }
                SymbolicInstruction::AbortIfNotEqual { lhs, rhs } => {
                    let aborts = !self.device_property_matches(lhs, rhs);
                    self.output_abort_if(&instruction.location, aborts)?;
                    if aborts {
                        return Ok(false);
                    }
                }
                SymbolicInstruction::Label(_label) => (),
                SymbolicInstruction::UnconditionalJump { label } => {
                    jump_label = Some(label);
                }
                SymbolicInstruction::JumpIfEqual { lhs, rhs, label } => {
                    let jump_succeeds = self.device_property_matches(lhs, rhs);
                    self.output_jump_if_equal(&instruction.location, rhs, jump_succeeds)?;
                    if jump_succeeds {
                        jump_label = Some(label);
                    }
                }
                SymbolicInstruction::JumpIfNotEqual { lhs, rhs, label } => {
                    let jump_succeeds = !self.device_property_matches(lhs, rhs);
                    self.output_jump_if_not_equal(&instruction.location, jump_succeeds)?;
                    if jump_succeeds {
                        jump_label = Some(label);
                    }
                }
                SymbolicInstruction::UnconditionalAbort => {
                    self.output_unconditional_abort(&instruction.location)?;
                    return Ok(false);
                }
                SymbolicInstruction::UnconditionalBind => return Ok(true),
            }

            if let Some(label) = jump_label {
                while instruction.instruction != SymbolicInstruction::Label(*label) {
                    instruction = instructions.next().ok_or(DebuggerError::MissingLabel)?;
                }
            }
        }

        Err(DebuggerError::NoOutcome)
    }

    fn device_property_matches(&self, lhs: &Symbol, rhs: &Symbol) -> bool {
        if let Some(DeviceValue { symbol: Some(value_symbol), identifier: _ }) =
            self.device_properties.get(lhs)
        {
            value_symbol == rhs
        } else {
            false
        }
    }

    fn output_abort_if(
        &mut self,
        location: &'a Option<AstLocation>,
        aborts: bool,
    ) -> Result<(), DebuggerError> {
        if let Some(AstLocation::ConditionStatement(statement)) = location {
            self.output.push(DebuggerOutput::ConditionStatement { statement, success: !aborts });
            Ok(())
        } else {
            Err(DebuggerError::IncorrectAstLocation)
        }
    }

    fn output_jump_if_equal(
        &mut self,
        location: &'a Option<AstLocation>,
        rhs: &'a Symbol,
        jump_succeeds: bool,
    ) -> Result<(), DebuggerError> {
        match location {
            Some(AstLocation::AcceptStatementValue { identifier, value, span }) => {
                if jump_succeeds {
                    self.output.push(DebuggerOutput::AcceptStatementSuccess {
                        identifier,
                        value,
                        value_symbol: rhs,
                        span,
                    });
                }
                Ok(())
            }
            Some(AstLocation::IfCondition(condition)) => {
                self.output
                    .push(DebuggerOutput::IfCondition { condition, success: !jump_succeeds });
                Ok(())
            }
            _ => Err(DebuggerError::IncorrectAstLocation),
        }
    }

    fn output_jump_if_not_equal(
        &mut self,
        location: &'a Option<AstLocation>,
        jump_succeeds: bool,
    ) -> Result<(), DebuggerError> {
        if let Some(AstLocation::IfCondition(condition)) = location {
            self.output.push(DebuggerOutput::IfCondition { condition, success: !jump_succeeds });
            Ok(())
        } else {
            Err(DebuggerError::IncorrectAstLocation)
        }
    }

    fn output_unconditional_abort(
        &mut self,
        location: &'a Option<AstLocation>,
    ) -> Result<(), DebuggerError> {
        match location {
            Some(AstLocation::AbortStatement(statement)) => {
                self.output.push(DebuggerOutput::AbortStatement { statement });
                Ok(())
            }
            Some(AstLocation::AcceptStatementFailure { identifier, span, symbol: _ }) => {
                self.output.push(DebuggerOutput::AcceptStatementFailure { identifier, span });
                Ok(())
            }
            _ => Err(DebuggerError::IncorrectAstLocation),
        }
    }

    fn log_output(&self) -> Result<(), DebuggerError> {
        for output in &self.output {
            match output {
                DebuggerOutput::ConditionStatement { statement, success } => {
                    self.log_condition_statement(statement, *success)?;
                }
                DebuggerOutput::AbortStatement { statement } => self.log_abort_statement(statement),
                DebuggerOutput::AcceptStatementSuccess {
                    identifier,
                    value,
                    value_symbol,
                    span,
                } => self.log_accept_statement_success(identifier, value, value_symbol, span)?,
                DebuggerOutput::AcceptStatementFailure { identifier, span } => {
                    self.log_accept_statement_failure(identifier, span)?;
                }
                DebuggerOutput::IfCondition { condition, success } => {
                    self.log_if_condition(condition, *success)?;
                }
            }
        }
        Ok(())
    }

    fn log_condition_statement(
        &self,
        statement: &Statement,
        success: bool,
    ) -> Result<(), DebuggerError> {
        if let Statement::ConditionStatement { span, condition: Condition { lhs, op, .. } } =
            statement
        {
            let outcome_string = if success { "succeeded" } else { "failed" };
            println!(
                "Line {}: Condition statement {}: {}",
                span.line, outcome_string, span.fragment
            );

            if condition_needs_actual_value(success, op) {
                println!("\t{}", self.actual_value_string(lhs)?)
            }

            Ok(())
        } else {
            Err(DebuggerError::InvalidAstLocation)
        }
    }

    fn log_abort_statement(&self, statement: &Statement) {
        if let Statement::Abort { span } = statement {
            println!("Line {}: Abort statement reached.", span.line);
        }
    }

    fn log_accept_statement_success(
        &self,
        identifier: &CompoundIdentifier,
        value: &Value,
        value_symbol: &Symbol,
        span: &Span,
    ) -> Result<(), DebuggerError> {
        // Get the value identifier from the accept statement (or None for a literal value).
        let value_identifier_prog =
            if let Value::Identifier(identifier) = value { Some(identifier) } else { None };

        // Get the value identifier from the device specification (or None for a literal value).
        let key_symbol = self
            .symbol_table
            .get(identifier)
            .ok_or(DebuggerError::UnknownKey(identifier.clone()))?;
        let DeviceValue { symbol: _, identifier: value_identifier_device } = self
            .device_properties
            .get(key_symbol)
            .expect("Accept statement succeeded so device must have this key.");

        let value_literal = value_symbol_string(value_symbol)?;

        let value_string = match (value_identifier_prog, value_identifier_device) {
            (Some(identifier_prog), Some(identifier_value)) => {
                if identifier_prog == identifier_value {
                    format!("`{}` [{}]", identifier_prog, value_literal)
                } else {
                    format!("`{}` (`{}`) [{}]", identifier_prog, identifier_value, value_literal)
                }
            }
            (Some(identifier_prog), None) => format!("`{}` [{}]", identifier_prog, value_literal),
            (None, Some(identifier_value)) => format!("`{}` [{}]", identifier_value, value_literal),
            (None, None) => format!("{}", value_literal),
        };

        println!(
            "Line {}: Accept statement succeeded.\n\tValue of `{}` was {}.",
            span.line, identifier, value_string
        );

        Ok(())
    }

    fn log_accept_statement_failure(
        &self,
        identifier: &CompoundIdentifier,
        span: &Span,
    ) -> Result<(), DebuggerError> {
        println!(
            "Line {}: Accept statement failed.\n\t{}",
            span.line,
            self.actual_value_string(identifier)?
        );

        Ok(())
    }

    fn log_if_condition(&self, condition: &Condition, success: bool) -> Result<(), DebuggerError> {
        let Condition { span, lhs, op, rhs: _ } = condition;

        let outcome_string = if success { "succeeded" } else { "failed" };
        println!(
            "Line {}: If statement condition {}: {}",
            span.line, outcome_string, span.fragment
        );

        if condition_needs_actual_value(success, op) {
            println!("\t{}", self.actual_value_string(lhs)?)
        }

        Ok(())
    }

    fn actual_value_string(
        &self,
        key_identifier: &CompoundIdentifier,
    ) -> Result<String, DebuggerError> {
        let key_symbol = self
            .symbol_table
            .get(key_identifier)
            .ok_or(DebuggerError::UnknownKey(key_identifier.clone()))?;
        let DeviceValue { symbol: value_symbol, identifier: value_identifier } = self
            .device_properties
            .get(key_symbol)
            .unwrap_or(&DeviceValue { symbol: None, identifier: None });

        Ok(match (value_symbol, value_identifier) {
            (Some(symbol), Some(identifier)) => format!(
                "Actual value of `{}` was `{}` [{}].",
                key_identifier,
                identifier,
                value_symbol_string(symbol)?
            ),
            (Some(symbol), None) => format!(
                "Actual value of `{}` was literal {}.",
                key_identifier,
                value_symbol_string(symbol)?
            ),
            (None, Some(identifier)) => {
                format!("Actual value of `{}` was `{}`.", key_identifier, identifier)
            }
            (None, None) => format!("Device had no value for `{}`.", key_identifier),
        })
    }
}

fn condition_needs_actual_value(success: bool, op: &ConditionOp) -> bool {
    match op {
        ConditionOp::Equals => !success,
        ConditionOp::NotEquals => success,
    }
}

fn value_symbol_string(symbol: &Symbol) -> Result<String, DebuggerError> {
    match symbol {
        Symbol::DeprecatedKey(..) => Err(DebuggerError::InvalidValueSymbol(symbol.clone())),
        Symbol::Key(..) => Err(DebuggerError::InvalidValueSymbol(symbol.clone())),
        Symbol::NumberValue(n) => Ok(format!("0x{:x}", n)),
        Symbol::StringValue(s) => Ok(format!("\"{}\"", s)),
        Symbol::BoolValue(b) => Ok(b.to_string()),
        Symbol::EnumValue => unimplemented!("Enum values are unsupported."),
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::bind_library;
    use crate::bind_program::{Condition, ConditionOp, Statement};
    use crate::make_identifier;
    use crate::parser_common::{CompoundIdentifier, Span};

    #[test]
    fn duplicate_key() {
        let symbol_table = HashMap::new();
        let properties = vec![
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(42) },
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(5) },
        ];
        assert_eq!(
            Debugger::construct_property_map(&properties, &symbol_table),
            Err(DebuggerError::DuplicateKey(make_identifier!("abc")))
        );
    }

    #[test]
    fn condition_equals() {
        let statement = Statement::ConditionStatement {
            span: Span::new(),
            condition: Condition {
                span: Span::new(),
                lhs: make_identifier!("abc"),
                op: ConditionOp::Equals,
                rhs: Value::NumericLiteral(42),
            },
        };
        let statements = vec![statement.clone()];
        let mut symbol_table = HashMap::new();
        symbol_table.insert(
            make_identifier!("abc"),
            Symbol::Key("abc".to_string(), bind_library::ValueType::Number),
        );
        let instructions = compiler::compile_statements(statements, &symbol_table).unwrap();

        // Binds when the device has the correct property.
        let properties =
            vec![Property { key: make_identifier!("abc"), value: Value::NumericLiteral(42) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::ConditionStatement { statement: &statement, success: true }]
        );

        // Binds when other properties are present as well.
        let properties = vec![
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(42) },
            Property { key: make_identifier!("xyz"), value: Value::BoolLiteral(true) },
        ];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::ConditionStatement { statement: &statement, success: true }]
        );

        // Doesn't bind when the device has the wrong value for the property.
        let properties =
            vec![Property { key: make_identifier!("abc"), value: Value::NumericLiteral(5) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::ConditionStatement { statement: &statement, success: false }]
        );

        // Doesn't bind when the property is not present in the device.
        let properties = Vec::new();
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::ConditionStatement { statement: &statement, success: false }]
        );
    }

    #[test]
    fn condition_not_equals() {
        let statement = Statement::ConditionStatement {
            span: Span::new(),
            condition: Condition {
                span: Span::new(),
                lhs: make_identifier!("abc"),
                op: ConditionOp::NotEquals,
                rhs: Value::NumericLiteral(42),
            },
        };
        let statements = vec![statement.clone()];
        let mut symbol_table = HashMap::new();
        symbol_table.insert(
            make_identifier!("abc"),
            Symbol::Key("abc".to_string(), bind_library::ValueType::Number),
        );
        let instructions = compiler::compile_statements(statements, &symbol_table).unwrap();

        // Binds when the device has a different value for the property.
        let properties =
            vec![Property { key: make_identifier!("abc"), value: Value::NumericLiteral(5) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::ConditionStatement { statement: &statement, success: true }]
        );

        // Binds when the property is not present in the device.
        let properties = Vec::new();
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::ConditionStatement { statement: &statement, success: true }]
        );

        // Doesn't bind when the device has the property in the condition statement.
        let properties =
            vec![Property { key: make_identifier!("abc"), value: Value::NumericLiteral(42) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::ConditionStatement { statement: &statement, success: false }]
        );
    }

    #[test]
    fn accept() {
        let statements = vec![Statement::Accept {
            span: Span::new(),
            identifier: make_identifier!("abc"),
            values: vec![Value::NumericLiteral(42), Value::NumericLiteral(314)],
        }];
        let mut symbol_table = HashMap::new();
        symbol_table.insert(
            make_identifier!("abc"),
            Symbol::Key("abc".to_string(), bind_library::ValueType::Number),
        );

        let instructions = compiler::compile_statements(statements, &symbol_table).unwrap();

        // Binds when the device has one of the accepted values for the property.
        let properties =
            vec![Property { key: make_identifier!("abc"), value: Value::NumericLiteral(42) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::AcceptStatementSuccess {
                identifier: &make_identifier!("abc"),
                value: &Value::NumericLiteral(42),
                value_symbol: &Symbol::NumberValue(42),
                span: &Span::new(),
            }]
        );

        // Doesn't bind when the device has a different value for the property.
        let properties =
            vec![Property { key: make_identifier!("abc"), value: Value::NumericLiteral(5) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::AcceptStatementFailure {
                identifier: &make_identifier!("abc"),
                span: &Span::new(),
            }]
        );

        // Doesn't bind when the device is missing the property.
        let properties = Vec::new();
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![DebuggerOutput::AcceptStatementFailure {
                identifier: &make_identifier!("abc"),
                span: &Span::new(),
            }]
        );
    }

    #[test]
    fn if_else() {
        /*
        if abc == 1 {
            xyz == 1;
        } else if abc == 2{
            xyz == 2;
        } else {
            xyz == 3;
        }
        */

        let condition1 = Condition {
            span: Span::new(),
            lhs: make_identifier!("abc"),
            op: ConditionOp::Equals,
            rhs: Value::NumericLiteral(1),
        };
        let condition2 = Condition {
            span: Span::new(),
            lhs: make_identifier!("abc"),
            op: ConditionOp::Equals,
            rhs: Value::NumericLiteral(2),
        };
        let statement1 = Statement::ConditionStatement {
            span: Span::new(),
            condition: Condition {
                span: Span::new(),
                lhs: make_identifier!("xyz"),
                op: ConditionOp::Equals,
                rhs: Value::NumericLiteral(1),
            },
        };
        let statement2 = Statement::ConditionStatement {
            span: Span::new(),
            condition: Condition {
                span: Span::new(),
                lhs: make_identifier!("xyz"),
                op: ConditionOp::Equals,
                rhs: Value::NumericLiteral(2),
            },
        };
        let statement3 = Statement::ConditionStatement {
            span: Span::new(),
            condition: Condition {
                span: Span::new(),
                lhs: make_identifier!("xyz"),
                op: ConditionOp::Equals,
                rhs: Value::NumericLiteral(3),
            },
        };

        let statements = vec![Statement::If {
            span: Span::new(),
            blocks: vec![
                (condition1.clone(), vec![statement1.clone()]),
                (condition2.clone(), vec![statement2.clone()]),
            ],
            else_block: vec![statement3.clone()],
        }];
        let mut symbol_table = HashMap::new();
        symbol_table.insert(
            make_identifier!("abc"),
            Symbol::Key("abc".to_string(), bind_library::ValueType::Number),
        );
        symbol_table.insert(
            make_identifier!("xyz"),
            Symbol::Key("xyz".to_string(), bind_library::ValueType::Number),
        );

        let instructions = compiler::compile_statements(statements, &symbol_table).unwrap();

        // Binds when the if clause is satisfied.
        let properties = vec![
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(1) },
            Property { key: make_identifier!("xyz"), value: Value::NumericLiteral(1) },
        ];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition1, success: true },
                DebuggerOutput::ConditionStatement { statement: &statement1, success: true }
            ]
        );

        // Binds when the if else clause is satisfied.
        let properties = vec![
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(2) },
            Property { key: make_identifier!("xyz"), value: Value::NumericLiteral(2) },
        ];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition1, success: false },
                DebuggerOutput::IfCondition { condition: &condition2, success: true },
                DebuggerOutput::ConditionStatement { statement: &statement2, success: true }
            ]
        );

        // Binds when the else clause is satisfied.
        let properties =
            vec![Property { key: make_identifier!("xyz"), value: Value::NumericLiteral(3) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition1, success: false },
                DebuggerOutput::IfCondition { condition: &condition2, success: false },
                DebuggerOutput::ConditionStatement { statement: &statement3, success: true }
            ]
        );

        // Doesn't bind when the device has incorrect values for the properties.
        let properties = vec![
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(42) },
            Property { key: make_identifier!("xyz"), value: Value::NumericLiteral(42) },
        ];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition1, success: false },
                DebuggerOutput::IfCondition { condition: &condition2, success: false },
                DebuggerOutput::ConditionStatement { statement: &statement3, success: false }
            ]
        );

        // Doesn't bind when the properties are missing in the device.
        let properties = Vec::new();
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition1, success: false },
                DebuggerOutput::IfCondition { condition: &condition2, success: false },
                DebuggerOutput::ConditionStatement { statement: &statement3, success: false }
            ]
        );
    }

    #[test]
    fn abort() {
        let condition_statement = Statement::ConditionStatement {
            span: Span::new(),
            condition: Condition {
                span: Span::new(),
                lhs: make_identifier!("abc"),
                op: ConditionOp::Equals,
                rhs: Value::NumericLiteral(42),
            },
        };
        let abort_statement = Statement::Abort { span: Span::new() };
        let statements = vec![condition_statement.clone(), abort_statement.clone()];
        let mut symbol_table = HashMap::new();
        symbol_table.insert(
            make_identifier!("abc"),
            Symbol::Key("abc".to_string(), bind_library::ValueType::Number),
        );

        let instructions = compiler::compile_statements(statements, &symbol_table).unwrap();

        // Doesn't bind when abort statement is present.
        let properties =
            vec![Property { key: make_identifier!("abc"), value: Value::NumericLiteral(42) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::ConditionStatement {
                    statement: &condition_statement,
                    success: true
                },
                DebuggerOutput::AbortStatement { statement: &abort_statement }
            ]
        );
    }

    #[test]
    fn supports_all_value_types() {
        let statements = vec![
            Statement::ConditionStatement {
                span: Span::new(),
                condition: Condition {
                    span: Span::new(),
                    lhs: make_identifier!("a"),
                    op: ConditionOp::Equals,
                    rhs: Value::NumericLiteral(42),
                },
            },
            Statement::ConditionStatement {
                span: Span::new(),
                condition: Condition {
                    span: Span::new(),
                    lhs: make_identifier!("b"),
                    op: ConditionOp::Equals,
                    rhs: Value::BoolLiteral(false),
                },
            },
            Statement::ConditionStatement {
                span: Span::new(),
                condition: Condition {
                    span: Span::new(),
                    lhs: make_identifier!("c"),
                    op: ConditionOp::Equals,
                    rhs: Value::StringLiteral("string".to_string()),
                },
            },
            Statement::ConditionStatement {
                span: Span::new(),
                condition: Condition {
                    span: Span::new(),
                    lhs: make_identifier!("d"),
                    op: ConditionOp::Equals,
                    rhs: Value::Identifier(make_identifier!("VALUE")),
                },
            },
        ];
        let mut symbol_table = HashMap::new();
        symbol_table.insert(
            make_identifier!("a"),
            Symbol::Key("a".to_string(), bind_library::ValueType::Number),
        );
        symbol_table.insert(
            make_identifier!("b"),
            Symbol::Key("b".to_string(), bind_library::ValueType::Number),
        );
        symbol_table.insert(
            make_identifier!("c"),
            Symbol::Key("c".to_string(), bind_library::ValueType::Number),
        );
        symbol_table.insert(
            make_identifier!("d"),
            Symbol::Key("d".to_string(), bind_library::ValueType::Number),
        );
        symbol_table.insert(
            make_identifier!("VALUE"),
            Symbol::Key("VALUE".to_string(), bind_library::ValueType::Number),
        );

        let instructions = compiler::compile_statements(statements, &symbol_table).unwrap();

        // Binds when other properties are present as well.
        let properties = vec![
            Property { key: make_identifier!("a"), value: Value::NumericLiteral(42) },
            Property { key: make_identifier!("b"), value: Value::BoolLiteral(false) },
            Property {
                key: make_identifier!("c"),
                value: Value::StringLiteral("string".to_string()),
            },
            Property {
                key: make_identifier!("d"),
                value: Value::Identifier(make_identifier!("VALUE")),
            },
        ];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
    }

    #[test]
    fn full_program() {
        /*
        if abc == 42 {
            abort;
        } else {
            accept xyz {1, 2};
            pqr != true;
        }
        */

        let condition = Condition {
            span: Span::new(),
            lhs: make_identifier!("abc"),
            op: ConditionOp::Equals,
            rhs: Value::NumericLiteral(42),
        };
        let abort_statement = Statement::Abort { span: Span::new() };
        let condition_statement = Statement::ConditionStatement {
            span: Span::new(),
            condition: Condition {
                span: Span::new(),
                lhs: make_identifier!("pqr"),
                op: ConditionOp::NotEquals,
                rhs: Value::BoolLiteral(true),
            },
        };

        let statements = vec![Statement::If {
            span: Span::new(),
            blocks: vec![(condition.clone(), vec![abort_statement.clone()])],
            else_block: vec![
                Statement::Accept {
                    span: Span::new(),
                    identifier: make_identifier!("xyz"),
                    values: vec![Value::NumericLiteral(1), Value::NumericLiteral(2)],
                },
                condition_statement.clone(),
            ],
        }];
        let mut symbol_table = HashMap::new();
        symbol_table.insert(
            make_identifier!("abc"),
            Symbol::Key("abc".to_string(), bind_library::ValueType::Number),
        );
        symbol_table.insert(
            make_identifier!("xyz"),
            Symbol::Key("xyz".to_string(), bind_library::ValueType::Number),
        );
        symbol_table.insert(
            make_identifier!("pqr"),
            Symbol::Key("pqr".to_string(), bind_library::ValueType::Number),
        );
        let instructions = compiler::compile_statements(statements, &symbol_table).unwrap();

        // Aborts because if condition is true.
        let properties =
            vec![Property { key: make_identifier!("abc"), value: Value::NumericLiteral(42) }];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition, success: true },
                DebuggerOutput::AbortStatement { statement: &abort_statement }
            ]
        );

        // Binds because all statements inside else block are satisfied.
        let properties = vec![
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(43) },
            Property { key: make_identifier!("xyz"), value: Value::NumericLiteral(1) },
        ];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition, success: false },
                DebuggerOutput::AcceptStatementSuccess {
                    identifier: &make_identifier!("xyz"),
                    value: &Value::NumericLiteral(1),
                    value_symbol: &Symbol::NumberValue(1),
                    span: &Span::new(),
                },
                DebuggerOutput::ConditionStatement {
                    statement: &condition_statement,
                    success: true
                }
            ]
        );

        // Doesn't bind because accept statement is not satisfied.
        let properties = vec![
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(43) },
            Property { key: make_identifier!("xyz"), value: Value::NumericLiteral(3) },
        ];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition, success: false },
                DebuggerOutput::AcceptStatementFailure {
                    identifier: &make_identifier!("xyz"),
                    span: &Span::new(),
                },
            ]
        );

        // Doesn't bind because condition statement is not satisfied.
        let properties = vec![
            Property { key: make_identifier!("abc"), value: Value::NumericLiteral(43) },
            Property { key: make_identifier!("xyz"), value: Value::NumericLiteral(1) },
            Property { key: make_identifier!("pqr"), value: Value::BoolLiteral(true) },
        ];
        let mut debugger = Debugger::new(&properties, &instructions, &symbol_table).unwrap();
        assert!(!debugger.evaluate_bind_program().unwrap());
        assert_eq!(
            debugger.output,
            vec![
                DebuggerOutput::IfCondition { condition: &condition, success: false },
                DebuggerOutput::AcceptStatementSuccess {
                    identifier: &make_identifier!("xyz"),
                    value: &Value::NumericLiteral(1),
                    value_symbol: &Symbol::NumberValue(1),
                    span: &Span::new(),
                },
                DebuggerOutput::ConditionStatement {
                    statement: &condition_statement,
                    success: false
                }
            ]
        );
    }
}