rlox/src/backend/environment.rs

use std::collections::HashMap;

use crate::{
    frontend::{source_registry::SourceSlice, tokens::LiteralValue},
    result::{runtime_error, LoxResult},
};

#[derive(Debug, Clone, PartialEq)]
pub struct EnvironmentStack {
    stack: Vec<HashMap<String, LiteralValue>>,
}

impl EnvironmentStack {
    pub fn new() -> Self {
        EnvironmentStack {
            stack: vec![HashMap::new()],
        }
    }

    pub fn push_new_scope(&mut self) {
        self.stack.push(HashMap::new());
    }

    pub fn pop_scope(&mut self) {
        self.stack.pop();
    }

    pub fn get(&self, name: &str) -> LoxResult<LiteralValue> {
        let size = self.stack.len();

        for i in (0..size).rev() {
            if let Some(value) = self.stack[i].get(name) {
                return Ok(value.clone());
            }
        }
        runtime_error(
            SourceSlice::default(), // todo change this to the actual source slice
            format!("Undefined variable '{}'", name),
        )
    }

    pub fn declare(&mut self, name: String, value: LiteralValue) -> LoxResult<LiteralValue> {
        self.stack.last_mut().unwrap().insert(name, value.clone());
        Ok(value)
    }

    pub fn set(&mut self, name: String, value: LiteralValue) -> LoxResult<LiteralValue> {
        let size = self.stack.len();

        for i in (0..size).rev() {
            if let Some(_) = self.stack[i].get(&name) {
                let mut founded = false;
                self.stack[i].entry(name.clone()).and_modify(|v| {
                    *v = value.clone();
                    founded = true;
                });

                if founded {
                    return Ok(value);
                }
            }
        }
        runtime_error(
            SourceSlice::default(), // todo change this to the actual source slice
            format!("Undefined variable '{}'", name),
        )
    }
}