fn declaration(&mut self) -> Result<Stmt> {
    if self.match_tokens(&[TokenType::Var]) {
        self.var_declaration()
    } else {
        // Remove the block handling from here
        self.statement()
    }
}

fn statement(&mut self) -> Result<Stmt> {
    if self.match_tokens(&[TokenType::Print]) {
        self.print_statement()
    } else if self.match_tokens(&[TokenType::LeftBrace]) {
        // Block handling belongs here
        Ok(Stmt::block(self.block()?))
    } else {
        self.expression_statement()
    }
}

pub fn get(&self, name: &str) -> Result<Value> {
        // TODO: Get variable value, return error if undefined
        // Hint: Use anyhow! macro for error
        
        if let Some(value) = self.values.get(name) { // don't confuse HashMap's get and Environment's get
            Ok(value.clone())
        }
        else if let Some(enclosing) = &self.enclosing { // If cannot find in the current env, find it in the parent env
            enclosing.get(name)
        }
        else {
            Err(anyhow!("Undefined variable '{}'.", name))
        }
    }

Logical { 
        left: Box<Expr>,
        operator: Token,
        right: Box<Expr>,
    },

fn visit_logical_expr(&mut self, _expr: &Expr, left: &Expr, operator: &Token, right: &Expr) -> Result<Value> {
    // TODO: Implement short-circuiting logic
    // For "or": if left is truthy, return left, otherwise return right
    // For "and": if left is falsy, return left, otherwise return right
    
    let left_value = left.accept(self)?;
    
    match operator.token_type {
        TokenType::Or => {
            if left_value.is_truthy() {
                // TODO: Return left_value (short-circuit)
                Ok(left_value)
            } else {
                // TODO: Evaluate and return right
                right.accept(self)
            }
        }
        TokenType::And => {
            if !left_value.is_truthy() {
                // TODO: Return left_value (short-circuit)  
                Ok(left_value)
            } else {
                // TODO: Evaluate and return right
                right.accept(self)
            }
        }
        _ => Err(anyhow!("Unknown logical operator: {:?}", operator.token_type)),
    }
}

fn visit_return_stmt(&mut self, ...) -> Result<()> {
    let val = if let Some(v) = value {
        v.accept(self)?
    } else {
        Value::Nil
    };
    
    // "Throw" the return value as an error
    Err(ReturnValue { value: val }.into())
}

// In visit_while_stmt
while condition.accept(self)?.is_truthy() {
    body.accept(self)?;  // ← If this is a return, the ? operator 
                         //   immediately exits this function!
}

pub fn call_lox_function(&mut self, function: &LoxFunction, arguments: Vec<Value>) -> Result<Value> {
    // ... setup code ...
    
    let result: anyhow::Result<Value> = (|| {
        for statement in &function.declaration().body {
            statement.accept(self)?;  // ← Return "error" propagates out of this loop
        }
        Ok(Value::Nil)  // If no return, function returns nil
    })();

    // ... cleanup code ...

    match result {
        Err(err) => {
            // Check if it's actually a return value
            if let Some(return_val) = err.downcast_ref::<ReturnValue>() {
                Ok(return_val.value.clone())  // Convert "error" back to normal value
            } else {
                Err(err)  // Real error, propagate it
            }
        }
        Ok(_) => Ok(Value::Nil),
    }
}

#[derive(Debug)]
pub struct EnvironmentArena {
    environments: Vec<Environment>, // The "parking lot" for environments
}

#[derive(Debug, Clone)]
pub struct Environment {
    enclosing: Option<EnvId>, // Just an ID, not a direct pointer!
    values: HashMap<String, Value>,
}

pub type EnvId = usize; // Environment ID - just a number!

// Get a variable's value, walking up the chain if needed
pub fn get(&self, env_id: EnvId, name: &str) -> Result<Value> {
    let mut current = env_id;
    loop {
        // Check current environment
        if let Some(value) = self.environments[current].values.get(name) {
            return Ok(value.clone());
        }
        
        // Move to parent environment
        if let Some(parent) = self.environments[current].enclosing {
            current = parent;
        } else {
            return Err(anyhow!("Undefined variable '{}'.", name));
        }
    }
}

// Arena contents:
environments[0] = Environment {  // Global scope
    enclosing: None,
    values: {
        "global" -> "I'm global",
        "outer" -> Function(...)
    }
}

environments[1] = Environment {  // outer() function scope
    enclosing: Some(0),  // Points to global
    values: {
        "outerVar" -> "I'm in outer",
        "inner" -> Function(...)
    }
}

environments[2] = Environment {  // inner() function scope
    enclosing: Some(1),  // Points to outer scope
    values: {
        "innerVar" -> "I'm in inner"
    }
}

// Looking up "global" from environment 2
let mut current = 2; // Start in inner() scope

// Check environments[2] - not found
// Move to parent: current = environments[2].enclosing = Some(1)
current = 1;

// Check environments[1] - not found  
// Move to parent: current = environments[1].enclosing = Some(0)
current = 0;

// Check environments[0] - FOUND! Return "I'm global"

pub fn call_lox_function(&mut self, function: &LoxFunction, arguments: Vec<Value>) -> Result<Value> {
        ...

        let current_env = self.environment; // Remember current environment
        // Create new environment with function's closure as parent
        let call_env = self.arena.create_env_with_enclosing(function.closure());
        // Add function to its own environment for recursion
        self.arena.define(call_env, function.name().to_string(), Value::Function(function.clone()));
        // Bind parameters to arguments
        for (param, arg) in function.declaration().params.iter().zip(arguments.iter()) {
            self.arena.define(call_env, param.lexeme.clone(), arg.clone());
        }
        
        self.environment = call_env; // Switch to function's environment

        let result: anyhow::Result<Value> = (|| {
            for statement in &function.declaration().body {
                statement.accept(self)?;
            }
            Ok(Value::Nil)
        })();

        self.environment = current_env; // Restore previous environment

        match result {
            Err(err) => {
                if let Some(return_val) = err.downcast_ref::<ReturnValue>() {
                    Ok(return_val.value.clone())
                } else {
                    Err(err)
                }
            }
            Ok(_) => Ok(Value::Nil),
        }
    }

let current_env = self.environment; // Remember current environment
// Create new environment with function's closure as parent
let call_env = self.arena.create_env_with_enclosing(function.closure());
// Add function to its own environment for recursion --IMPORTANT--
self.arena.define(call_env, function.name().to_string(), Value::Function(function.clone()));

let result: anyhow::Result<Value> = (|| {
            for statement in &function.declaration().body {
                statement.accept(self)?;
            }
            Ok(Value::Nil)
        })();

// ...
self.environment = current_env; // Restore previous environment

match result {
    Err(err) => {
        if let Some(return_val) = err.downcast_ref::<ReturnValue>() {
            Ok(return_val.value.clone())
        } else {
            Err(err)
        }
    }
    Ok(_) => Ok(Value::Nil),
}

...
let block_env = self.arena.create_env_with_enclosing(global_env);
// block_env contents: {} (empty)
// block_env.enclosing: global_env
...

fn visit_function_stmt(&mut self, _stmt: &Stmt, name: &Token, params: &[Token], body: &[Stmt]) -> Result<()> {
        // TODO: Create function object and store in environment
        // 1. Create FunctionDeclaration
        // 2. Capture current environment as closure
        // 3. Create LoxFunction
        // 4. Store in environment with function name
        let declaration = FunctionDeclaration {
            name: name.clone(),
            params: params.to_vec(),
            body: body.to_vec(),
        };
        
        // Create function with current environment as closure (just store the ID!)
        let function = LoxFunction::new(declaration, self.environment);
        
        // Define function in current environment
        self.arena.define(self.environment, name.lexeme.clone(), Value::Function(function));
        Ok(())
    }

impl StmtVisitor<Result<()>> for Interpreter {
    fn visit_var_stmt(&mut self, _stmt: &Stmt, name: &Token, initializer: &Option<Box<Expr>>) -> Result<()> {
        let value = if let Some(init) = initializer {
            init.accept(self)? // Evaluates "block" -> Value::String("block")
        } else {
            Value::Nil
        };

        // HERE IS WHERE IT HAPPENS! 👇
        self.arena.define(self.environment, name.lexeme.clone(), value);
        //                ^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^   ^^^^^
        //                current env ID   "a"                 Value::String("block")
        // This MODIFIES block_env: {} becomes {a: "block"}
        Ok(())
    }
}
// This MODIFIES block_env: {} becomes {a: "block"}

impl EnvironmentArena {
    pub fn define(&mut self, env_id: EnvId, name: String, value: Value) {
        // THIS IS THE ACTUAL MUTATION! 👇
        self.environments[env_id].values.insert(name, value);
        //                        ^^^^^^ This HashMap gets modified!
    }
}

pub struct Environment {
    enclosing: Option<EnvId>,
    values: HashMap<String, Value>, // This HashMap gets modified!
}