use std::ops::{Add, Div, Mul, Sub};

use color_eyre::eyre::Result;

use crate::chunk::{Chunk, DisassembledInstruction, OpCode};
use crate::compiler::compile;
use crate::value::Value;
use tracing::debug;

pub struct VM {
    chunk: Chunk,
    ip: usize,
    stack: [Value; 256],
    stack_top: usize,
}

impl VM {
    pub fn interpret(source: &str) -> Result<()> {
        compile(source);
        Ok(())
    }

    pub fn new(chunk: Chunk) -> Self {
        Self {
            chunk,
            ip: 0,
            stack: [0.0; 256],
            stack_top: 0,
        }
    }

    pub fn run(&mut self) -> Result<()> {
        loop {
            debug!("{:?}", &self.stack[0..self.stack_top]);
            debug!("{}", DisassembledInstruction::new(self.ip, &self.chunk,));

            match &self.chunk.code[self.ip] {
                OpCode::Constant(constant) => {
                    let value = self.chunk.constants[*constant];
                    self.push(value);
                }
                OpCode::Add => self.binary_op(Value::add),
                OpCode::Subtract => self.binary_op(Value::sub),
                OpCode::Multiply => self.binary_op(Value::mul),
                OpCode::Divide => self.binary_op(Value::div),
                OpCode::Negate => {
                    let value = self.pop();
                    self.push(-value);
                }
                OpCode::Return => {
                    println!("{}", self.pop());
                    return Ok(());
                }
            }

            self.ip += 1;
        }
    }

    fn push(&mut self, value: Value) {
        self.stack[self.stack_top] = value;
        self.stack_top += 1;
    }

    fn pop(&mut self) -> Value {
        self.stack_top -= 1;
        self.stack[self.stack_top]
    }

    fn binary_op<T: Fn(Value, Value) -> Value>(&mut self, op: T) {
        let b = self.pop();
        let a = self.pop();
        self.push(op(a, b));
    }
}