archscript/

interpreter.rs

//! Tree-walking interpreter for ArchScript.

use std::collections::HashMap;
use std::fmt;

use crate::ast::*;

// ── Runtime Values ───────────────────────────────────────────────────────────

#[derive(Debug, Clone)]
pub enum Value {
    Integer(i64),
    Float(f64),
    String(String),
    Boolean(bool),
    List(Vec<Value>),
    Dict(Vec<(Value, Value)>),
    Tuple(Vec<Value>),
    Function(FuncValue),
    BuiltinFn(String),
    None,
}

#[derive(Debug, Clone)]
pub struct FuncValue {
    pub name: Option<String>,
    pub params: Vec<Param>,
    pub body: Expr,
    pub closure: Environment,
}

impl fmt::Display for Value {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Value::Integer(n) => write!(f, "{}", n),
            Value::Float(n) => write!(f, "{}", n),
            Value::String(s) => write!(f, "{}", s),
            Value::Boolean(b) => write!(f, "{}", if *b { "True" } else { "False" }),
            Value::List(items) => {
                write!(f, "[")?;
                for (i, item) in items.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "{}", item)?;
                }
                write!(f, "]")
            }
            Value::Dict(entries) => {
                write!(f, "{{")?;
                for (i, (k, v)) in entries.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "{}: {}", k, v)?;
                }
                write!(f, "}}")
            }
            Value::Tuple(items) => {
                write!(f, "(")?;
                for (i, item) in items.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "{}", item)?;
                }
                write!(f, ")")
            }
            Value::Function(_) => write!(f, "<function>"),
            Value::BuiltinFn(name) => write!(f, "<builtin:{}>", name),
            Value::None => write!(f, "None"),
        }
    }
}

impl PartialEq for Value {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Value::Integer(a), Value::Integer(b)) => a == b,
            (Value::Float(a), Value::Float(b)) => a == b,
            (Value::Integer(a), Value::Float(b)) => (*a as f64) == *b,
            (Value::Float(a), Value::Integer(b)) => *a == (*b as f64),
            (Value::String(a), Value::String(b)) => a == b,
            (Value::Boolean(a), Value::Boolean(b)) => a == b,
            (Value::None, Value::None) => true,
            (Value::List(a), Value::List(b)) => a == b,
            _ => false,
        }
    }
}

// ── Environment (scoped symbol table) ────────────────────────────────────────

#[derive(Debug, Clone)]
pub struct Environment {
    pub scopes: Vec<HashMap<String, Value>>,
}

impl Default for Environment {
    fn default() -> Self {
        Self::new()
    }
}

impl Environment {
    pub fn new() -> Self {
        let mut global = HashMap::new();
        // Register built-in functions
        for name in [
            "print", "println", "len", "range", "str", "int", "float", "type", "map", "filter",
            "sum", "append",
        ] {
            global.insert(name.to_string(), Value::BuiltinFn(name.to_string()));
        }
        let mut env = Self {
            scopes: vec![global],
        };
        // Register stdlib modules (pacman, systemd, aur, fs)
        crate::stdlib::register_modules(&mut env);
        env
    }

    pub fn push_scope(&mut self) {
        self.scopes.push(HashMap::new());
    }

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

    pub fn get(&self, name: &str) -> Option<&Value> {
        for scope in self.scopes.iter().rev() {
            if let Some(val) = scope.get(name) {
                return Some(val);
            }
        }
        None
    }

    pub fn set(&mut self, name: String, value: Value) {
        // Update existing binding if found
        for scope in self.scopes.iter_mut().rev() {
            if let std::collections::hash_map::Entry::Occupied(mut e) = scope.entry(name.clone()) {
                e.insert(value);
                return;
            }
        }
        // Otherwise create in current scope
        if let Some(scope) = self.scopes.last_mut() {
            scope.insert(name, value);
        }
    }

    pub fn define(&mut self, name: String, value: Value) {
        if let Some(scope) = self.scopes.last_mut() {
            scope.insert(name, value);
        }
    }
}

// ── Runtime Error ────────────────────────────────────────────────────────────

#[derive(Debug, Clone)]
pub struct RuntimeError(pub String);

impl fmt::Display for RuntimeError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Runtime error: {}", self.0)
    }
}

impl std::error::Error for RuntimeError {}

/// Signal for early return from functions.
#[derive(Debug, Clone)]
pub enum Signal {
    Value(Value),
    Return(Value),
}

// ── Interpreter ──────────────────────────────────────────────────────────────

pub struct Interpreter {
    pub env: Environment,
    pub output: Vec<String>,
}

impl Default for Interpreter {
    fn default() -> Self {
        Self::new()
    }
}

impl Interpreter {
    pub fn new() -> Self {
        Self {
            env: Environment::new(),
            output: Vec::new(),
        }
    }

    pub fn run(&mut self, program: &Node) -> Result<Value, RuntimeError> {
        match program {
            Node::Module(items) => {
                let mut last = Value::None;
                for item in items {
                    match self.exec_node(item)? {
                        Signal::Return(v) => return Ok(v),
                        Signal::Value(v) => last = v,
                    }
                }
                Ok(last)
            }
            _ => match self.exec_node(program)? {
                Signal::Return(v) | Signal::Value(v) => Ok(v),
            },
        }
    }

    fn exec_node(&mut self, node: &Node) -> Result<Signal, RuntimeError> {
        match node {
            Node::Module(items) => {
                let mut last = Value::None;
                for item in items {
                    match self.exec_node(item)? {
                        Signal::Return(v) => return Ok(Signal::Return(v)),
                        Signal::Value(v) => last = v,
                    }
                }
                Ok(Signal::Value(last))
            }
            Node::Import(_) => {
                // Imports are a no-op for now
                Ok(Signal::Value(Value::None))
            }
            Node::VariableDeclaration(name, _, expr) => {
                let val = self.eval(expr)?;
                self.env.define(name.clone(), val);
                Ok(Signal::Value(Value::None))
            }
            Node::FunctionDeclaration(decl) => {
                let func = Value::Function(FuncValue {
                    name: Some(decl.name.clone()),
                    params: decl.params.clone(),
                    body: *decl.body.clone(),
                    closure: self.env.clone(),
                });
                self.env.define(decl.name.clone(), func);
                Ok(Signal::Value(Value::None))
            }
            Node::Expression(expr) => {
                let val = self.eval(expr)?;
                Ok(Signal::Value(val))
            }
            Node::Return(expr) => {
                let val = match expr {
                    Some(e) => self.eval(e)?,
                    None => Value::None,
                };
                Ok(Signal::Return(val))
            }
            Node::TypeDefinition(_, _)
            | Node::DataDefinition(_, _)
            | Node::TraitDefinition(_, _)
            | Node::InstanceDefinition(_, _, _) => {
                // Type system constructs — no-op in interpreter for now
                Ok(Signal::Value(Value::None))
            }
        }
    }

    pub fn eval(&mut self, expr: &Expr) -> Result<Value, RuntimeError> {
        match expr {
            Expr::Integer(n) => Ok(Value::Integer(*n)),
            Expr::Float(n) => Ok(Value::Float(*n)),
            Expr::StringLit(s) => Ok(Value::String(s.clone())),
            Expr::Boolean(b) => Ok(Value::Boolean(*b)),
            Expr::Identifier(name) => self
                .env
                .get(name)
                .cloned()
                .ok_or_else(|| RuntimeError(format!("undefined variable: {}", name))),

            Expr::List(items) => {
                let vals: Vec<Value> = items
                    .iter()
                    .map(|e| self.eval(e))
                    .collect::<Result<_, _>>()?;
                Ok(Value::List(vals))
            }
            Expr::Dict(entries) => {
                let vals: Vec<(Value, Value)> = entries
                    .iter()
                    .map(|(k, v)| Ok((self.eval(k)?, self.eval(v)?)))
                    .collect::<Result<_, RuntimeError>>()?;
                Ok(Value::Dict(vals))
            }
            Expr::Tuple(items) => {
                let vals: Vec<Value> = items
                    .iter()
                    .map(|e| self.eval(e))
                    .collect::<Result<_, _>>()?;
                Ok(Value::Tuple(vals))
            }

            Expr::BinaryOp(op, left, right) => {
                let lv = self.eval(left)?;
                let rv = self.eval(right)?;
                self.eval_binop(op, &lv, &rv)
            }

            Expr::UnaryOp(op, expr) => {
                let val = self.eval(expr)?;
                match op {
                    UnaryOp::Neg => match val {
                        Value::Integer(n) => Ok(Value::Integer(-n)),
                        Value::Float(n) => Ok(Value::Float(-n)),
                        _ => Err(RuntimeError("cannot negate non-numeric value".into())),
                    },
                    UnaryOp::Pos => Ok(val),
                    UnaryOp::Not => match val {
                        Value::Boolean(b) => Ok(Value::Boolean(!b)),
                        _ => Err(RuntimeError(
                            "cannot apply 'not' to non-boolean value".into(),
                        )),
                    },
                }
            }

            Expr::Pipe(left, right) => {
                let lv = self.eval(left)?;
                // right should be a function — call it with lv as argument
                let func = self.eval(right)?;
                self.call_value(&func, &[lv])
            }

            Expr::FunctionCall(callee, args) => {
                let func = self.eval(callee)?;
                let arg_vals: Vec<Value> = args
                    .iter()
                    .map(|a| self.eval(a))
                    .collect::<Result<_, _>>()?;
                self.call_value(&func, &arg_vals)
            }

            Expr::Index(expr, idx) => {
                let container = self.eval(expr)?;
                let index = self.eval(idx)?;
                match (&container, &index) {
                    (Value::List(items), Value::Integer(i)) => {
                        let i = if *i < 0 { items.len() as i64 + i } else { *i } as usize;
                        items
                            .get(i)
                            .cloned()
                            .ok_or_else(|| RuntimeError(format!("index {} out of bounds", i)))
                    }
                    (Value::String(s), Value::Integer(i)) => {
                        let i = if *i < 0 { s.len() as i64 + i } else { *i } as usize;
                        s.chars()
                            .nth(i)
                            .map(|c| Value::String(c.to_string()))
                            .ok_or_else(|| RuntimeError(format!("index {} out of bounds", i)))
                    }
                    (Value::Dict(entries), key) => {
                        for (k, v) in entries {
                            if k == key {
                                return Ok(v.clone());
                            }
                        }
                        Err(RuntimeError(format!("key not found: {}", key)))
                    }
                    _ => Err(RuntimeError("cannot index this value".into())),
                }
            }

            Expr::MemberAccess(expr, member) => {
                let val = self.eval(expr)?;
                match &val {
                    Value::Dict(entries) => {
                        for (k, v) in entries {
                            if let Value::String(s) = k {
                                if s == member {
                                    return Ok(v.clone());
                                }
                            }
                        }
                        Err(RuntimeError(format!("no member '{}' found", member)))
                    }
                    _ => Err(RuntimeError(format!(
                        "member access on unsupported type: {}",
                        val
                    ))),
                }
            }

            Expr::If(cond, then_body, elif_branches, else_body) => {
                let cond_val = self.eval(cond)?;
                if is_truthy(&cond_val) {
                    self.eval(then_body)
                } else {
                    for (elif_cond, elif_body) in elif_branches {
                        let elif_val = self.eval(elif_cond)?;
                        if is_truthy(&elif_val) {
                            return self.eval(elif_body);
                        }
                    }
                    if let Some(else_body) = else_body {
                        self.eval(else_body)
                    } else {
                        Ok(Value::None)
                    }
                }
            }

            Expr::For(var, iterable, body) => {
                let iter_val = self.eval(iterable)?;
                let items = match iter_val {
                    Value::List(items) => items,
                    _ => return Err(RuntimeError("for loop requires iterable (list)".into())),
                };
                self.env.push_scope();
                let mut last = Value::None;
                for item in items {
                    self.env.define(var.clone(), item);
                    last = self.eval(body)?;
                }
                self.env.pop_scope();
                Ok(last)
            }

            Expr::While(cond, body) => {
                let mut last = Value::None;
                loop {
                    let cond_val = self.eval(cond)?;
                    if !is_truthy(&cond_val) {
                        break;
                    }
                    last = self.eval(body)?;
                }
                Ok(last)
            }

            Expr::Match(subject, arms) => {
                let val = self.eval(subject)?;
                for arm in arms {
                    if let Some(bindings) = match_pattern(&arm.pattern, &val) {
                        self.env.push_scope();
                        for (name, bound_val) in &bindings {
                            self.env.define(name.clone(), bound_val.clone());
                        }
                        // Check guard
                        if let Some(guard) = &arm.guard {
                            let guard_val = self.eval(guard)?;
                            if !is_truthy(&guard_val) {
                                self.env.pop_scope();
                                continue;
                            }
                        }
                        let result = self.eval(&arm.body)?;
                        self.env.pop_scope();
                        return Ok(result);
                    }
                }
                Err(RuntimeError(
                    "no matching pattern in match expression".into(),
                ))
            }

            Expr::Lambda(params, body) => Ok(Value::Function(FuncValue {
                name: None,
                params: params.clone(),
                body: *body.clone(),
                closure: self.env.clone(),
            })),

            Expr::ListComprehension(expr, var, iterable, filter) => {
                let iter_val = self.eval(iterable)?;
                let items = match iter_val {
                    Value::List(items) => items,
                    _ => return Err(RuntimeError("list comprehension requires iterable".into())),
                };
                let mut result = Vec::new();
                self.env.push_scope();
                for item in items {
                    self.env.define(var.clone(), item);
                    if let Some(filter_expr) = filter {
                        let fv = self.eval(filter_expr)?;
                        if !is_truthy(&fv) {
                            continue;
                        }
                    }
                    result.push(self.eval(expr)?);
                }
                self.env.pop_scope();
                Ok(Value::List(result))
            }

            Expr::Block(stmts) => {
                self.env.push_scope();
                let mut last = Value::None;
                for stmt in stmts {
                    match self.exec_node(stmt)? {
                        Signal::Return(v) => {
                            self.env.pop_scope();
                            return Ok(v); // Propagate return as a value in this context
                        }
                        Signal::Value(v) => last = v,
                    }
                }
                self.env.pop_scope();
                Ok(last)
            }

            Expr::Assign(target, value) => {
                let val = self.eval(value)?;
                match target.as_ref() {
                    Expr::Identifier(name) => {
                        self.env.set(name.clone(), val);
                        Ok(Value::None)
                    }
                    _ => Err(RuntimeError("invalid assignment target".into())),
                }
            }

            Expr::CompoundAssign(op, target, value) => {
                let current = self.eval(target)?;
                let rhs = self.eval(value)?;
                let result = self.eval_binop(op, &current, &rhs)?;
                match target.as_ref() {
                    Expr::Identifier(name) => {
                        self.env.set(name.clone(), result);
                        Ok(Value::None)
                    }
                    _ => Err(RuntimeError("invalid compound assignment target".into())),
                }
            }
        }
    }

    fn eval_binop(&self, op: &BinOp, left: &Value, right: &Value) -> Result<Value, RuntimeError> {
        match op {
            BinOp::Add => match (left, right) {
                (Value::Integer(a), Value::Integer(b)) => Ok(Value::Integer(a + b)),
                (Value::Float(a), Value::Float(b)) => Ok(Value::Float(a + b)),
                (Value::Integer(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)),
                (Value::Float(a), Value::Integer(b)) => Ok(Value::Float(a + *b as f64)),
                (Value::String(a), Value::String(b)) => Ok(Value::String(format!("{}{}", a, b))),
                (Value::List(a), Value::List(b)) => {
                    let mut result = a.clone();
                    result.extend(b.clone());
                    Ok(Value::List(result))
                }
                _ => Err(RuntimeError(format!("cannot add {} and {}", left, right))),
            },
            BinOp::Sub => numeric_op(left, right, |a, b| a - b, |a, b| a - b),
            BinOp::Mul => match (left, right) {
                (Value::String(s), Value::Integer(n)) | (Value::Integer(n), Value::String(s)) => {
                    Ok(Value::String(s.repeat(*n as usize)))
                }
                _ => numeric_op(left, right, |a, b| a * b, |a, b| a * b),
            },
            BinOp::Div => match (left, right) {
                (Value::Integer(_), Value::Integer(0)) | (Value::Float(_), Value::Integer(0)) => {
                    Err(RuntimeError("division by zero".into()))
                }
                _ => numeric_op_float(left, right, |a, b| a / b),
            },
            BinOp::IntDiv => match (left, right) {
                (Value::Integer(a), Value::Integer(b)) => {
                    if *b == 0 {
                        Err(RuntimeError("division by zero".into()))
                    } else {
                        Ok(Value::Integer(a / b))
                    }
                }
                _ => Err(RuntimeError("integer division requires integers".into())),
            },
            BinOp::Mod => match (left, right) {
                (Value::Integer(a), Value::Integer(b)) => {
                    if *b == 0 {
                        Err(RuntimeError("modulo by zero".into()))
                    } else {
                        Ok(Value::Integer(a % b))
                    }
                }
                _ => Err(RuntimeError("modulo requires integers".into())),
            },
            BinOp::Pow => match (left, right) {
                (Value::Integer(a), Value::Integer(b)) => Ok(Value::Integer(a.pow(*b as u32))),
                (Value::Float(a), Value::Float(b)) => Ok(Value::Float(a.powf(*b))),
                (Value::Integer(a), Value::Float(b)) => Ok(Value::Float((*a as f64).powf(*b))),
                (Value::Float(a), Value::Integer(b)) => Ok(Value::Float(a.powf(*b as f64))),
                _ => Err(RuntimeError("power requires numeric operands".into())),
            },
            BinOp::Eq => Ok(Value::Boolean(left == right)),
            BinOp::Neq => Ok(Value::Boolean(left != right)),
            BinOp::Lt => compare_op(left, right, |ord| ord == std::cmp::Ordering::Less),
            BinOp::Lte => compare_op(left, right, |ord| {
                ord == std::cmp::Ordering::Less || ord == std::cmp::Ordering::Equal
            }),
            BinOp::Gt => compare_op(left, right, |ord| ord == std::cmp::Ordering::Greater),
            BinOp::Gte => compare_op(left, right, |ord| {
                ord == std::cmp::Ordering::Greater || ord == std::cmp::Ordering::Equal
            }),
            BinOp::And => Ok(Value::Boolean(is_truthy(left) && is_truthy(right))),
            BinOp::Or => Ok(Value::Boolean(is_truthy(left) || is_truthy(right))),
        }
    }

    fn call_value(&mut self, func: &Value, args: &[Value]) -> Result<Value, RuntimeError> {
        match func {
            Value::Function(fv) => {
                let mut call_env = fv.closure.clone();
                call_env.push_scope();
                // Bind the function itself for recursion
                if let Some(ref name) = fv.name {
                    call_env.define(name.clone(), func.clone());
                }
                for (i, param) in fv.params.iter().enumerate() {
                    let val = args.get(i).cloned().unwrap_or(Value::None);
                    call_env.define(param.name.clone(), val);
                }
                let prev_env = std::mem::replace(&mut self.env, call_env);
                let result = self.eval(&fv.body);
                self.env = prev_env;
                result
            }
            Value::BuiltinFn(name) => self.call_builtin(name, args),
            _ => Err(RuntimeError(format!("cannot call non-function: {}", func))),
        }
    }

    fn call_builtin(&mut self, name: &str, args: &[Value]) -> Result<Value, RuntimeError> {
        match name {
            "print" => {
                let text: Vec<String> = args.iter().map(|a| format!("{}", a)).collect();
                let output = text.join(" ");
                self.output.push(output);
                Ok(Value::None)
            }
            "println" => {
                let text: Vec<String> = args.iter().map(|a| format!("{}", a)).collect();
                let output = text.join(" ");
                self.output.push(output);
                Ok(Value::None)
            }
            "len" => match args.first() {
                Some(Value::List(items)) => Ok(Value::Integer(items.len() as i64)),
                Some(Value::String(s)) => Ok(Value::Integer(s.len() as i64)),
                Some(Value::Dict(entries)) => Ok(Value::Integer(entries.len() as i64)),
                _ => Err(RuntimeError(
                    "len() requires a list, string, or dict".into(),
                )),
            },
            "range" => {
                let (start, end, step) = match args.len() {
                    1 => match &args[0] {
                        Value::Integer(n) => (0, *n, 1),
                        _ => return Err(RuntimeError("range() requires integer arguments".into())),
                    },
                    2 => match (&args[0], &args[1]) {
                        (Value::Integer(a), Value::Integer(b)) => (*a, *b, 1),
                        _ => return Err(RuntimeError("range() requires integer arguments".into())),
                    },
                    3 => match (&args[0], &args[1], &args[2]) {
                        (Value::Integer(a), Value::Integer(b), Value::Integer(c)) => (*a, *b, *c),
                        _ => return Err(RuntimeError("range() requires integer arguments".into())),
                    },
                    _ => return Err(RuntimeError("range() takes 1-3 arguments".into())),
                };
                if step == 0 {
                    return Err(RuntimeError("range() step cannot be zero".into()));
                }
                let mut items = Vec::new();
                let mut i = start;
                if step > 0 {
                    while i < end {
                        items.push(Value::Integer(i));
                        i += step;
                    }
                } else {
                    while i > end {
                        items.push(Value::Integer(i));
                        i += step;
                    }
                }
                Ok(Value::List(items))
            }
            "str" => match args.first() {
                Some(val) => Ok(Value::String(format!("{}", val))),
                None => Ok(Value::String(String::new())),
            },
            "int" => match args.first() {
                Some(Value::Integer(n)) => Ok(Value::Integer(*n)),
                Some(Value::Float(n)) => Ok(Value::Integer(*n as i64)),
                Some(Value::String(s)) => s
                    .parse::<i64>()
                    .map(Value::Integer)
                    .map_err(|_| RuntimeError(format!("cannot convert '{}' to int", s))),
                Some(Value::Boolean(b)) => Ok(Value::Integer(if *b { 1 } else { 0 })),
                _ => Err(RuntimeError(
                    "int() requires a numeric or string argument".into(),
                )),
            },
            "float" => match args.first() {
                Some(Value::Integer(n)) => Ok(Value::Float(*n as f64)),
                Some(Value::Float(n)) => Ok(Value::Float(*n)),
                Some(Value::String(s)) => s
                    .parse::<f64>()
                    .map(Value::Float)
                    .map_err(|_| RuntimeError(format!("cannot convert '{}' to float", s))),
                _ => Err(RuntimeError(
                    "float() requires a numeric or string argument".into(),
                )),
            },
            "type" => {
                let type_name = match args.first() {
                    Some(Value::Integer(_)) => "Int",
                    Some(Value::Float(_)) => "Float",
                    Some(Value::String(_)) => "String",
                    Some(Value::Boolean(_)) => "Bool",
                    Some(Value::List(_)) => "List",
                    Some(Value::Dict(_)) => "Dict",
                    Some(Value::Tuple(_)) => "Tuple",
                    Some(Value::Function(_)) => "Function",
                    Some(Value::BuiltinFn(_)) => "BuiltinFn",
                    Some(Value::None) | None => "None",
                };
                Ok(Value::String(type_name.to_string()))
            }
            "map" => {
                if args.len() != 2 {
                    return Err(RuntimeError(
                        "map() takes 2 arguments (function, list)".into(),
                    ));
                }
                let func = &args[0];
                let items = match &args[1] {
                    Value::List(items) => items.clone(),
                    _ => return Err(RuntimeError("map() second argument must be a list".into())),
                };
                let mut result = Vec::new();
                for item in &items {
                    result.push(self.call_value(func, std::slice::from_ref(item))?);
                }
                Ok(Value::List(result))
            }
            "filter" => {
                if args.len() != 2 {
                    return Err(RuntimeError(
                        "filter() takes 2 arguments (function, list)".into(),
                    ));
                }
                let func = &args[0];
                let items = match &args[1] {
                    Value::List(items) => items.clone(),
                    _ => {
                        return Err(RuntimeError(
                            "filter() second argument must be a list".into(),
                        ))
                    }
                };
                let mut result = Vec::new();
                for item in &items {
                    let v = self.call_value(func, std::slice::from_ref(item))?;
                    if is_truthy(&v) {
                        result.push(item.clone());
                    }
                }
                Ok(Value::List(result))
            }
            "sum" => match args.first() {
                Some(Value::List(items)) => {
                    let mut total = Value::Integer(0);
                    for item in items {
                        total = self.eval_binop(&BinOp::Add, &total, item)?;
                    }
                    Ok(total)
                }
                _ => Err(RuntimeError("sum() requires a list argument".into())),
            },
            "append" => {
                if args.len() != 2 {
                    return Err(RuntimeError(
                        "append() takes 2 arguments (list, item)".into(),
                    ));
                }
                match &args[0] {
                    Value::List(items) => {
                        let mut new_items = items.clone();
                        new_items.push(args[1].clone());
                        Ok(Value::List(new_items))
                    }
                    _ => Err(RuntimeError(
                        "append() first argument must be a list".into(),
                    )),
                }
            }
            _ => {
                // Delegate to stdlib modules
                if let Some(result) = crate::stdlib::call(name, args) {
                    return result;
                }
                Err(RuntimeError(format!("unknown builtin: {}", name)))
            }
        }
    }
}

// ── Helper Functions ─────────────────────────────────────────────────────────

fn is_truthy(val: &Value) -> bool {
    match val {
        Value::Boolean(b) => *b,
        Value::Integer(n) => *n != 0,
        Value::Float(n) => *n != 0.0,
        Value::String(s) => !s.is_empty(),
        Value::List(items) => !items.is_empty(),
        Value::None => false,
        _ => true,
    }
}

fn numeric_op(
    left: &Value,
    right: &Value,
    int_op: fn(i64, i64) -> i64,
    float_op: fn(f64, f64) -> f64,
) -> Result<Value, RuntimeError> {
    match (left, right) {
        (Value::Integer(a), Value::Integer(b)) => Ok(Value::Integer(int_op(*a, *b))),
        (Value::Float(a), Value::Float(b)) => Ok(Value::Float(float_op(*a, *b))),
        (Value::Integer(a), Value::Float(b)) => Ok(Value::Float(float_op(*a as f64, *b))),
        (Value::Float(a), Value::Integer(b)) => Ok(Value::Float(float_op(*a, *b as f64))),
        _ => Err(RuntimeError(format!(
            "arithmetic requires numeric operands, got {} and {}",
            left, right
        ))),
    }
}

fn numeric_op_float(
    left: &Value,
    right: &Value,
    op: fn(f64, f64) -> f64,
) -> Result<Value, RuntimeError> {
    match (left, right) {
        (Value::Integer(a), Value::Integer(b)) => Ok(Value::Float(op(*a as f64, *b as f64))),
        (Value::Float(a), Value::Float(b)) => Ok(Value::Float(op(*a, *b))),
        (Value::Integer(a), Value::Float(b)) => Ok(Value::Float(op(*a as f64, *b))),
        (Value::Float(a), Value::Integer(b)) => Ok(Value::Float(op(*a, *b as f64))),
        _ => Err(RuntimeError(format!(
            "arithmetic requires numeric operands, got {} and {}",
            left, right
        ))),
    }
}

fn compare_op(
    left: &Value,
    right: &Value,
    pred: fn(std::cmp::Ordering) -> bool,
) -> Result<Value, RuntimeError> {
    let ord = match (left, right) {
        (Value::Integer(a), Value::Integer(b)) => a.cmp(b),
        (Value::Float(a), Value::Float(b)) => a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal),
        (Value::Integer(a), Value::Float(b)) => (*a as f64)
            .partial_cmp(b)
            .unwrap_or(std::cmp::Ordering::Equal),
        (Value::Float(a), Value::Integer(b)) => a
            .partial_cmp(&(*b as f64))
            .unwrap_or(std::cmp::Ordering::Equal),
        (Value::String(a), Value::String(b)) => a.cmp(b),
        _ => {
            return Err(RuntimeError(format!(
                "cannot compare {} and {}",
                left, right
            )))
        }
    };
    Ok(Value::Boolean(pred(ord)))
}

fn match_pattern(pattern: &Pattern, value: &Value) -> Option<Vec<(String, Value)>> {
    match pattern {
        Pattern::Wildcard => Some(vec![]),
        Pattern::Literal(lit_expr) => {
            let lit_val = match lit_expr {
                Expr::Integer(n) => Value::Integer(*n),
                Expr::Float(n) => Value::Float(*n),
                Expr::StringLit(s) => Value::String(s.clone()),
                Expr::Boolean(b) => Value::Boolean(*b),
                _ => return None,
            };
            if &lit_val == value {
                Some(vec![])
            } else {
                None
            }
        }
        Pattern::Identifier(name) => Some(vec![(name.clone(), value.clone())]),
        Pattern::Tuple(patterns) => match value {
            Value::Tuple(items) if items.len() == patterns.len() => {
                let mut bindings = Vec::new();
                for (pat, val) in patterns.iter().zip(items.iter()) {
                    match match_pattern(pat, val) {
                        Some(b) => bindings.extend(b),
                        None => return None,
                    }
                }
                Some(bindings)
            }
            _ => None,
        },
        Pattern::List(patterns, rest) => match value {
            Value::List(items) => {
                if rest.is_some() {
                    if items.len() < patterns.len() {
                        return None;
                    }
                } else if items.len() != patterns.len() {
                    return None;
                }
                let mut bindings = Vec::new();
                for (pat, val) in patterns.iter().zip(items.iter()) {
                    match match_pattern(pat, val) {
                        Some(b) => bindings.extend(b),
                        None => return None,
                    }
                }
                if let Some(rest_name) = rest {
                    let rest_items = items[patterns.len()..].to_vec();
                    bindings.push((rest_name.clone(), Value::List(rest_items)));
                }
                Some(bindings)
            }
            _ => None,
        },
        Pattern::Constructor(_name, _patterns) => {
            // Constructors are not fully implemented yet
            None
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser;

    fn eval_str(source: &str) -> Result<Value, String> {
        let ast = parser::parse(source).map_err(|e| e.to_string())?;
        let mut interp = Interpreter::new();
        interp.run(&ast).map_err(|e| e.to_string())
    }

    fn eval_with_output(source: &str) -> (Result<Value, String>, Vec<String>) {
        let ast = match parser::parse(source) {
            Ok(a) => a,
            Err(e) => return (Err(e.to_string()), vec![]),
        };
        let mut interp = Interpreter::new();
        let result = interp.run(&ast).map_err(|e| e.to_string());
        (result, interp.output)
    }

    #[test]
    fn test_integer_literal() {
        assert_eq!(eval_str("42").unwrap(), Value::Integer(42));
    }

    #[test]
    fn test_float_literal() {
        match eval_str("3.14").unwrap() {
            Value::Float(f) => assert!((f - 3.14).abs() < f64::EPSILON),
            other => panic!("expected float, got {:?}", other),
        }
    }

    #[test]
    fn test_var_float_bug() {
        // The original bug: `var y = 13.1` should work
        let source = "var y = 13.1\ny";
        match eval_str(source).unwrap() {
            Value::Float(f) => assert!((f - 13.1).abs() < f64::EPSILON),
            other => panic!("expected float 13.1, got {:?}", other),
        }
    }

    #[test]
    fn test_string_literal() {
        assert_eq!(
            eval_str("\"hello\"").unwrap(),
            Value::String("hello".to_string())
        );
    }

    #[test]
    fn test_boolean() {
        assert_eq!(eval_str("True").unwrap(), Value::Boolean(true));
        assert_eq!(eval_str("False").unwrap(), Value::Boolean(false));
    }

    #[test]
    fn test_arithmetic() {
        assert_eq!(eval_str("2 + 3").unwrap(), Value::Integer(5));
        assert_eq!(eval_str("10 - 4").unwrap(), Value::Integer(6));
        assert_eq!(eval_str("3 * 7").unwrap(), Value::Integer(21));
        assert_eq!(eval_str("10 % 3").unwrap(), Value::Integer(1));
    }

    #[test]
    fn test_operator_precedence() {
        assert_eq!(eval_str("2 + 3 * 4").unwrap(), Value::Integer(14));
        assert_eq!(eval_str("2 * 3 + 4").unwrap(), Value::Integer(10));
    }

    #[test]
    fn test_variable() {
        let source = "var x = 42\nx";
        assert_eq!(eval_str(source).unwrap(), Value::Integer(42));
    }

    #[test]
    fn test_comparison() {
        assert_eq!(eval_str("3 < 5").unwrap(), Value::Boolean(true));
        assert_eq!(eval_str("5 < 3").unwrap(), Value::Boolean(false));
        assert_eq!(eval_str("3 == 3").unwrap(), Value::Boolean(true));
        assert_eq!(eval_str("3 != 4").unwrap(), Value::Boolean(true));
    }

    #[test]
    fn test_print() {
        let (result, output) = eval_with_output("println(\"Hello, ArchScript!\")");
        assert!(result.is_ok());
        assert_eq!(output, vec!["Hello, ArchScript!"]);
    }

    #[test]
    fn test_len() {
        let source = "len(\"hello\")";
        assert_eq!(eval_str(source).unwrap(), Value::Integer(5));
    }

    #[test]
    fn test_range() {
        let source = "range(5)";
        assert_eq!(
            eval_str(source).unwrap(),
            Value::List(vec![
                Value::Integer(0),
                Value::Integer(1),
                Value::Integer(2),
                Value::Integer(3),
                Value::Integer(4),
            ])
        );
    }
}