r/interpreter/

value.rs

pub mod buffer;
pub mod character;
pub mod complex;
pub mod double;
pub mod error;
pub mod integer;
pub mod logical;
pub mod traits;
pub mod vector;

pub use buffer::NullableBuffer;
pub use character::Character;
pub use complex::ComplexVec;
pub use double::Double;
pub use error::{
    get_class, make_condition, make_condition_with_call, ConditionKind, RError, RErrorKind, RFlow,
    RSignal,
};
pub use integer::Integer;
pub use logical::Logical;
pub use traits::{
    coerce_arg, coerce_arg_three_way, find_arg, find_named_arg, Builtin, BuiltinInfo, CoerceArg,
    Dots, FromArgs, RArg,
};
pub use vector::{format_r_complex, format_r_double, Vector};

use std::fmt;
use std::ops::{Deref, DerefMut};

use indexmap::IndexMap;
use itertools::Itertools;
use unicode_width::UnicodeWidthStr;

use crate::interpreter::environment::Environment;
use crate::interpreter::BuiltinContext;
use crate::parser::ast::{Arg, Expr, Param};

pub type BuiltinFn = fn(&[RValue], &[(String, RValue)]) -> Result<RValue, RError>;
pub type InterpreterBuiltinFn =
    for<'a> fn(&[RValue], &[(String, RValue)], &BuiltinContext<'a>) -> Result<RValue, RError>;
pub type PreEvalBuiltinFn =
    for<'a> fn(&[Arg], &Environment, &BuiltinContext<'a>) -> Result<RValue, RError>;

#[derive(Debug, Clone, Copy)]
pub enum BuiltinImplementation {
    Eager(BuiltinFn),
    Interpreter(InterpreterBuiltinFn),
    PreEval(PreEvalBuiltinFn),
}

#[derive(Debug, Clone, Copy)]
pub struct BuiltinDescriptor {
    pub name: &'static str,
    pub aliases: &'static [&'static str],
    pub implementation: BuiltinImplementation,
    pub min_args: usize,
    pub max_args: Option<usize>,
    /// Raw doc string extracted from rustdoc comments (may contain @param/@title tags).
    pub doc: &'static str,
    /// Namespace this builtin belongs to (e.g. "base", "stats", "utils", "collections").
    pub namespace: &'static str,
    /// Formal parameter names (extracted from @param doc comments).
    /// Used at dispatch time to reorder positional/named args into canonical order
    /// so builtins can use `args[i]` regardless of how the user passed the args.
    /// Empty for variadic (dots) builtins — no reordering is performed.
    pub formals: &'static [&'static str],
}

/// Attribute map — every R object can carry named attributes.
///
/// Uses `IndexMap` to preserve insertion order, matching R's behavior where
/// `attributes(x)` returns attributes in the order they were set.
pub type Attributes = IndexMap<String, RValue>;

/// Unevaluated expression (language object) — returned by quote(), parse().
///
/// Wraps a boxed AST node. Derefs to `Expr` for pattern matching.
#[derive(Debug, Clone)]
pub struct Language {
    pub inner: Box<Expr>,
    pub attrs: Option<Box<Attributes>>,
}

impl Language {
    pub fn new(expr: Expr) -> Self {
        Language {
            inner: Box::new(expr),
            attrs: None,
        }
    }

    pub fn get_attr(&self, name: &str) -> Option<&RValue> {
        self.attrs.as_ref().and_then(|a| a.get(name))
    }

    pub fn set_attr(&mut self, name: String, value: RValue) {
        self.attrs
            .get_or_insert_with(|| Box::new(IndexMap::new()))
            .insert(name, value);
    }

    pub fn class(&self) -> Option<Vec<String>> {
        match self.get_attr("class") {
            Some(RValue::Vector(rv)) => match &rv.inner {
                Vector::Character(v) => Some(v.iter().filter_map(|s| s.clone()).collect()),
                _ => None,
            },
            _ => None,
        }
    }

    /// Return the R-style "length" of this language object.
    ///
    /// In R, language objects are list-like:
    /// - `quote(f(a, b))` has length 3 (function + 2 args)
    /// - `quote(a + b)` has length 3 (`+`, a, b)
    /// - `quote(-x)` has length 2 (`-`, x)
    /// - `quote({a; b})` has length 3 (`{`, a, b)
    /// - Atomic expressions (symbols, literals) have length 1
    pub fn language_length(&self) -> usize {
        match self.inner.as_ref() {
            Expr::Call { args, .. } => {
                // Only count args that have a value (filter out empty placeholder args
                // like the one generated by `f()` which has one Arg{name:None,value:None})
                1 + args.iter().filter(|a| a.value.is_some()).count()
            }
            Expr::BinaryOp { .. } => 3,
            Expr::UnaryOp { .. } => 2,
            Expr::Block(exprs) => 1 + exprs.len(),
            Expr::If { else_body, .. } => {
                if else_body.is_some() {
                    4
                } else {
                    3
                }
            }
            Expr::For { .. } => 4,
            Expr::While { .. } => 3,
            Expr::Repeat { .. } => 2,
            Expr::Assign { .. } => 3,
            Expr::Function { .. } => 3,
            Expr::Index { indices, .. } => 2 + indices.len(),
            Expr::IndexDouble { indices, .. } => 2 + indices.len(),
            Expr::Dollar { .. } => 3,
            Expr::Slot { .. } => 3,
            Expr::Formula { lhs, rhs } => {
                1 + usize::from(lhs.is_some()) + usize::from(rhs.is_some())
            }
            Expr::Return(Some(_)) => 2,
            Expr::Return(None) => 1,
            // Atomic expressions: symbols, literals, etc.
            _ => 1,
        }
    }

    /// Return the i-th element (1-based) of this language object as an `RValue`.
    ///
    /// In R, language objects can be indexed with `[[`:
    /// - Index 1 is the "function" (operator, keyword, etc.)
    /// - Index 2+ are the arguments/operands
    ///
    /// Returns `None` if the index is out of bounds.
    pub fn language_element(&self, index: usize) -> Option<RValue> {
        if index == 0 || index > self.language_length() {
            return None;
        }
        match self.inner.as_ref() {
            Expr::Call { func, args, .. } => {
                if index == 1 {
                    Some(expr_to_rvalue(func))
                } else {
                    // Skip empty placeholder args (like the one in `f()`)
                    args.iter()
                        .filter_map(|arg| arg.value.as_ref())
                        .nth(index - 2)
                        .map(expr_to_rvalue)
                }
            }
            Expr::BinaryOp { op, lhs, rhs } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    binary_op_symbol(op),
                )))),
                2 => Some(expr_to_rvalue(lhs)),
                3 => Some(expr_to_rvalue(rhs)),
                _ => None,
            },
            Expr::UnaryOp { op, operand } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    unary_op_symbol(op),
                )))),
                2 => Some(expr_to_rvalue(operand)),
                _ => None,
            },
            Expr::Block(exprs) => {
                if index == 1 {
                    Some(RValue::Language(Language::new(Expr::Symbol(
                        "{".to_string(),
                    ))))
                } else {
                    exprs.get(index - 2).map(expr_to_rvalue)
                }
            }
            Expr::If {
                condition,
                then_body,
                else_body,
            } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    "if".to_string(),
                )))),
                2 => Some(expr_to_rvalue(condition)),
                3 => Some(expr_to_rvalue(then_body)),
                4 => else_body.as_ref().map(|e| expr_to_rvalue(e)),
                _ => None,
            },
            Expr::For { var, iter, body } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    "for".to_string(),
                )))),
                2 => Some(RValue::Language(Language::new(Expr::Symbol(var.clone())))),
                3 => Some(expr_to_rvalue(iter)),
                4 => Some(expr_to_rvalue(body)),
                _ => None,
            },
            Expr::While { condition, body } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    "while".to_string(),
                )))),
                2 => Some(expr_to_rvalue(condition)),
                3 => Some(expr_to_rvalue(body)),
                _ => None,
            },
            Expr::Repeat { body } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    "repeat".to_string(),
                )))),
                2 => Some(expr_to_rvalue(body)),
                _ => None,
            },
            Expr::Assign { op, target, value } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    assign_op_symbol(op),
                )))),
                2 => Some(expr_to_rvalue(target)),
                3 => Some(expr_to_rvalue(value)),
                _ => None,
            },
            Expr::Function { params, body } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    "function".to_string(),
                )))),
                2 => {
                    // Formals as a pairlist (represented as a named list)
                    let entries: Vec<(Option<String>, RValue)> = params
                        .iter()
                        .map(|p| {
                            let val = if p.is_dots {
                                RValue::Language(Language::new(Expr::Dots))
                            } else if let Some(ref d) = p.default {
                                expr_to_rvalue(d)
                            } else {
                                // Missing default -> empty symbol (R uses this)
                                RValue::Language(Language::new(Expr::Symbol(String::new())))
                            };
                            (Some(p.name.clone()), val)
                        })
                        .collect();
                    Some(RValue::List(RList::new(entries)))
                }
                3 => Some(expr_to_rvalue(body)),
                _ => None,
            },
            Expr::Index { object, indices } => {
                if index == 1 {
                    Some(RValue::Language(Language::new(Expr::Symbol(
                        "[".to_string(),
                    ))))
                } else if index == 2 {
                    Some(expr_to_rvalue(object))
                } else {
                    indices
                        .get(index - 3)
                        .and_then(|arg| arg.value.as_ref())
                        .map(expr_to_rvalue)
                }
            }
            Expr::IndexDouble { object, indices } => {
                if index == 1 {
                    Some(RValue::Language(Language::new(Expr::Symbol(
                        "[[".to_string(),
                    ))))
                } else if index == 2 {
                    Some(expr_to_rvalue(object))
                } else {
                    indices
                        .get(index - 3)
                        .and_then(|arg| arg.value.as_ref())
                        .map(expr_to_rvalue)
                }
            }
            Expr::Dollar { object, member } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    "$".to_string(),
                )))),
                2 => Some(expr_to_rvalue(object)),
                3 => Some(RValue::Language(Language::new(Expr::Symbol(
                    member.clone(),
                )))),
                _ => None,
            },
            Expr::Slot { object, member } => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    "@".to_string(),
                )))),
                2 => Some(expr_to_rvalue(object)),
                3 => Some(RValue::Language(Language::new(Expr::Symbol(
                    member.clone(),
                )))),
                _ => None,
            },
            Expr::Formula { lhs, rhs } => {
                if index == 1 {
                    Some(RValue::Language(Language::new(Expr::Symbol(
                        "~".to_string(),
                    ))))
                } else {
                    // Elements are lhs (if present) then rhs (if present)
                    let mut elems = Vec::new();
                    if let Some(l) = lhs {
                        elems.push(expr_to_rvalue(l));
                    }
                    if let Some(r) = rhs {
                        elems.push(expr_to_rvalue(r));
                    }
                    elems.into_iter().nth(index - 2)
                }
            }
            Expr::Return(arg) => match index {
                1 => Some(RValue::Language(Language::new(Expr::Symbol(
                    "return".to_string(),
                )))),
                2 => arg.as_ref().map(|e| expr_to_rvalue(e)),
                _ => None,
            },
            // Atomic: only index 1 returns the value itself
            _ => {
                if index == 1 {
                    Some(expr_to_rvalue(&self.inner))
                } else {
                    None
                }
            }
        }
    }

    /// Return a new Language with the i-th element (1-based) replaced by `val`.
    ///
    /// This is the write-side counterpart to `language_element` — it implements
    /// `[[<-` on language objects.  Returns `None` if the index is out of bounds.
    pub fn set_element(&self, index: usize, val: &RValue) -> Option<Language> {
        if index == 0 || index > self.language_length() {
            return None;
        }
        let new_expr = rvalue_to_expr(val);
        let mut result = (*self.inner).clone();
        match &mut result {
            Expr::Call { func, args, .. } => {
                if index == 1 {
                    **func = new_expr;
                } else {
                    // Find the (index-2)th arg with a value
                    let mut count = 0;
                    for arg in args.iter_mut() {
                        if arg.value.is_some() {
                            if count == index - 2 {
                                arg.value = Some(new_expr);
                                break;
                            }
                            count += 1;
                        }
                    }
                }
            }
            Expr::BinaryOp { lhs, rhs, .. } => match index {
                2 => **lhs = new_expr,
                3 => **rhs = new_expr,
                _ => return None,
            },
            Expr::UnaryOp { operand, .. } => {
                if index == 2 {
                    **operand = new_expr;
                } else {
                    return None;
                }
            }
            Expr::Block(exprs) => {
                if index >= 2 && index - 2 < exprs.len() {
                    exprs[index - 2] = new_expr;
                } else {
                    return None;
                }
            }
            Expr::If {
                condition,
                then_body,
                else_body,
            } => match index {
                2 => **condition = new_expr,
                3 => **then_body = new_expr,
                4 => *else_body = Some(Box::new(new_expr)),
                _ => return None,
            },
            Expr::For { var, iter, body } => match index {
                2 => {
                    if let Expr::Symbol(name) = new_expr {
                        *var = name;
                    }
                }
                3 => **iter = new_expr,
                4 => **body = new_expr,
                _ => return None,
            },
            Expr::While { condition, body } => match index {
                2 => **condition = new_expr,
                3 => **body = new_expr,
                _ => return None,
            },
            Expr::Repeat { body } => {
                if index == 2 {
                    **body = new_expr;
                } else {
                    return None;
                }
            }
            Expr::Assign { target, value, .. } => match index {
                2 => **target = new_expr,
                3 => **value = new_expr,
                _ => return None,
            },
            Expr::Function { body, .. } => {
                if index == 3 {
                    **body = new_expr;
                } else {
                    return None;
                }
            }
            Expr::Index { object, indices } | Expr::IndexDouble { object, indices } => {
                if index == 2 {
                    **object = new_expr;
                } else if index >= 3 && index - 3 < indices.len() {
                    indices[index - 3].value = Some(new_expr);
                } else {
                    return None;
                }
            }
            Expr::Dollar { object, member } | Expr::Slot { object, member } => match index {
                2 => **object = new_expr,
                3 => {
                    if let Expr::Symbol(name) = new_expr {
                        *member = name;
                    }
                }
                _ => return None,
            },
            Expr::Formula { lhs, rhs } => {
                let has_lhs = lhs.is_some();
                match (index, has_lhs) {
                    (2, true) => *lhs = Some(Box::new(new_expr)),
                    (2, false) => *rhs = Some(Box::new(new_expr)),
                    (3, true) => *rhs = Some(Box::new(new_expr)),
                    _ => return None,
                }
            }
            Expr::Return(arg) => {
                if index == 2 {
                    *arg = Some(Box::new(new_expr));
                } else {
                    return None;
                }
            }
            _ => return None,
        }
        let mut lang = Language::new(result);
        if let Some(ref attrs) = self.attrs {
            lang.attrs = Some(attrs.clone());
        }
        Some(lang)
    }
}

/// Convert an Expr to an RValue — atomic expressions become symbols/literals,
/// compound expressions become Language objects.
fn expr_to_rvalue(expr: &Expr) -> RValue {
    match expr {
        // Literals evaluate to their corresponding R values
        Expr::Null => RValue::Null,
        Expr::Bool(b) => RValue::vec(Vector::Logical(vec![Some(*b)].into())),
        Expr::Integer(i) => RValue::vec(Vector::Integer(vec![Some(*i)].into())),
        Expr::Double(d) => RValue::vec(Vector::Double(vec![Some(*d)].into())),
        Expr::Complex(d) => RValue::vec(Vector::Complex(
            vec![Some(num_complex::Complex64::new(0.0, *d))].into(),
        )),
        Expr::String(s) => RValue::vec(Vector::Character(vec![Some(s.clone())].into())),
        Expr::Inf => RValue::vec(Vector::Double(vec![Some(f64::INFINITY)].into())),
        Expr::NaN => RValue::vec(Vector::Double(vec![Some(f64::NAN)].into())),
        Expr::Na(na) => match na {
            NaType::Logical => RValue::vec(Vector::Logical(vec![None].into())),
            NaType::Integer => RValue::vec(Vector::Integer(vec![None].into())),
            NaType::Real => RValue::vec(Vector::Double(vec![None].into())),
            NaType::Character => RValue::vec(Vector::Character(vec![None].into())),
            NaType::Complex => RValue::vec(Vector::Complex(vec![None].into())),
        },
        // Symbols stay as language objects (names in R)
        Expr::Symbol(_) | Expr::Dots | Expr::DotDot(_) => {
            RValue::Language(Language::new(expr.clone()))
        }
        // Compound expressions become language objects
        _ => RValue::Language(Language::new(expr.clone())),
    }
}

/// Convert an RValue back to an Expr — the inverse of `expr_to_rvalue`.
///
/// Used by `Language::set_element` to splice RValues into AST nodes.
pub(crate) fn rvalue_to_expr(val: &RValue) -> Expr {
    match val {
        RValue::Null => Expr::Null,
        RValue::Language(lang) => (*lang.inner).clone(),
        RValue::Vector(rv) if rv.inner.len() == 1 => match &rv.inner {
            Vector::Logical(v) => match v[0] {
                Some(true) => Expr::Bool(true),
                Some(false) => Expr::Bool(false),
                None => Expr::Na(NaType::Logical),
            },
            Vector::Integer(v) => match v.get_opt(0) {
                Some(i) => Expr::Integer(i),
                None => Expr::Na(NaType::Integer),
            },
            Vector::Double(v) => match v.get_opt(0) {
                Some(d) if d.is_infinite() && d > 0.0 => Expr::Inf,
                Some(d) if d.is_nan() => Expr::NaN,
                Some(d) => Expr::Double(d),
                None => Expr::Na(NaType::Real),
            },
            Vector::Character(v) => match &v[0] {
                Some(s) => Expr::String(s.clone()),
                None => Expr::Na(NaType::Character),
            },
            Vector::Complex(v) => match &v[0] {
                Some(c) if c.re == 0.0 => Expr::Complex(c.im),
                Some(c) => {
                    // a+bi → BinaryOp(Add, Double(a), Complex(b))
                    Expr::BinaryOp {
                        op: BinaryOp::Add,
                        lhs: Box::new(Expr::Double(c.re)),
                        rhs: Box::new(Expr::Complex(c.im)),
                    }
                }
                None => Expr::Na(NaType::Complex),
            },
            Vector::Raw(_) => {
                // Raw scalars don't have a direct Expr form; wrap as integer
                Expr::Integer(rv.inner.to_integers()[0].unwrap_or(0))
            }
        },
        // Multi-element vectors: generate c(e1, e2, ...) call expression
        RValue::Vector(rv) => {
            let args: Vec<Arg> = (0..rv.inner.len())
                .map(|i| {
                    let expr = match &rv.inner {
                        Vector::Double(v) => match v.get_opt(i) {
                            Some(d) => Expr::Double(d),
                            None => Expr::Na(NaType::Real),
                        },
                        Vector::Integer(v) => match v.get_opt(i) {
                            Some(n) => Expr::Integer(n),
                            None => Expr::Na(NaType::Integer),
                        },
                        Vector::Character(v) => match &v[i] {
                            Some(s) => Expr::String(s.clone()),
                            None => Expr::Na(NaType::Character),
                        },
                        Vector::Logical(v) => match v[i] {
                            Some(b) => Expr::Bool(b),
                            None => Expr::Na(NaType::Logical),
                        },
                        Vector::Complex(v) => match &v[i] {
                            Some(c) if c.re == 0.0 => Expr::Complex(c.im),
                            Some(c) => Expr::BinaryOp {
                                op: BinaryOp::Add,
                                lhs: Box::new(Expr::Double(c.re)),
                                rhs: Box::new(Expr::Complex(c.im)),
                            },
                            None => Expr::Na(NaType::Complex),
                        },
                        Vector::Raw(v) => Expr::Integer(i64::from(v[i])),
                    };
                    Arg {
                        name: None,
                        value: Some(expr),
                    }
                })
                .collect();
            Expr::Call {
                func: Box::new(Expr::Symbol("c".to_string())),
                args,
                span: None,
            }
        }
        // Functions: reconstruct the function expression from closure params/body
        RValue::Function(f) => match f {
            RFunction::Closure { params, body, .. } => Expr::Function {
                params: params.clone(),
                body: Box::new(body.clone()),
            },
            RFunction::Builtin { name, .. } => Expr::Symbol(name.clone()),
        },
        // Lists: generate list(k1=v1, k2=v2, ...) call expression
        RValue::List(list) => {
            let args: Vec<Arg> = list
                .values
                .iter()
                .map(|(name, val)| Arg {
                    name: name.clone(),
                    value: Some(rvalue_to_expr(val)),
                })
                .collect();
            Expr::Call {
                func: Box::new(Expr::Symbol("list".to_string())),
                args,
                span: None,
            }
        }
        // Environments and promises: no meaningful Expr representation
        _ => Expr::Null,
    }
}

/// Map a BinaryOp to its R symbol name.
fn binary_op_symbol(op: &BinaryOp) -> String {
    match op {
        BinaryOp::Add => "+".to_string(),
        BinaryOp::Sub => "-".to_string(),
        BinaryOp::Mul => "*".to_string(),
        BinaryOp::Div => "/".to_string(),
        BinaryOp::Pow => "^".to_string(),
        BinaryOp::Mod => "%%".to_string(),
        BinaryOp::IntDiv => "%/%".to_string(),
        BinaryOp::Eq => "==".to_string(),
        BinaryOp::Ne => "!=".to_string(),
        BinaryOp::Lt => "<".to_string(),
        BinaryOp::Gt => ">".to_string(),
        BinaryOp::Le => "<=".to_string(),
        BinaryOp::Ge => ">=".to_string(),
        BinaryOp::And => "&".to_string(),
        BinaryOp::AndScalar => "&&".to_string(),
        BinaryOp::Or => "|".to_string(),
        BinaryOp::OrScalar => "||".to_string(),
        BinaryOp::Range => ":".to_string(),
        BinaryOp::Pipe => "|>".to_string(),
        BinaryOp::AssignPipe => "%<>%".to_string(),
        BinaryOp::TeePipe => "%T>%".to_string(),
        BinaryOp::ExpoPipe => "%$%".to_string(),
        BinaryOp::Special(SpecialOp::In) => "%in%".to_string(),
        BinaryOp::Special(SpecialOp::MatMul) => "%*%".to_string(),
        BinaryOp::Special(SpecialOp::Kronecker) => "%x%".to_string(),
        BinaryOp::Special(SpecialOp::Walrus) => ":=".to_string(),
        BinaryOp::Special(SpecialOp::Other(ref name)) => name.clone(),
        BinaryOp::Tilde => "~".to_string(),
        BinaryOp::DoubleTilde => "~~".to_string(),
    }
}

/// Map a UnaryOp to its R symbol name.
fn unary_op_symbol(op: &UnaryOp) -> String {
    match op {
        UnaryOp::Neg => "-".to_string(),
        UnaryOp::Pos => "+".to_string(),
        UnaryOp::Not => "!".to_string(),
        UnaryOp::Formula => "~".to_string(),
    }
}

/// Map an AssignOp to its R symbol name.
fn assign_op_symbol(op: &AssignOp) -> String {
    match op {
        AssignOp::LeftAssign => "<-".to_string(),
        AssignOp::SuperAssign => "<<-".to_string(),
        AssignOp::Equals => "=".to_string(),
        AssignOp::RightAssign => "->".to_string(),
        AssignOp::RightSuperAssign => "->>".to_string(),
    }
}

impl Deref for Language {
    type Target = Expr;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl DerefMut for Language {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

/// Lazy promise: wraps an unevaluated expression + its lexical environment.
///
/// Created when a closure is called — each argument becomes a promise that is
/// only evaluated (forced) when its value is actually needed. Once forced, the
/// result is cached so subsequent accesses return the same value.
///
/// The `forcing` flag detects recursive promise evaluation (e.g. `f(x = x)`).
#[derive(Debug, Clone)]
pub struct RPromise {
    pub expr: Expr,
    pub env: Environment,
    pub value: Option<RValue>,
    pub forcing: bool,
}

impl RPromise {
    pub fn new(expr: Expr, env: Environment) -> Self {
        RPromise {
            expr,
            env,
            value: None,
            forcing: false,
        }
    }
}

/// Shared promise handle — promises are mutable (cached once forced) and may
/// be referenced from multiple places (e.g. `...` forwarding), so they live
/// behind `Rc<RefCell<>>`.
pub type SharedPromise = std::rc::Rc<std::cell::RefCell<RPromise>>;

#[derive(Debug, Clone)]
pub enum RValue {
    /// NULL
    Null,
    /// Atomic vector (with optional attributes)
    Vector(RVector),
    /// List (generic vector)
    List(RList),
    /// Function (closure)
    Function(RFunction),
    /// Environment reference
    Environment(Environment),
    /// Language object (unevaluated expression)
    Language(Language),
    /// Lazy promise (unevaluated argument with cached result)
    Promise(SharedPromise),
}

/// Atomic vector with optional attributes (names, class, dim, etc.)
#[derive(Debug, Clone)]
pub struct RVector {
    pub inner: Vector,
    pub attrs: Option<Box<Attributes>>,
}

impl Deref for RVector {
    type Target = Vector;
    fn deref(&self) -> &Vector {
        &self.inner
    }
}

impl DerefMut for RVector {
    fn deref_mut(&mut self) -> &mut Vector {
        &mut self.inner
    }
}

impl From<Vector> for RVector {
    fn from(v: Vector) -> Self {
        RVector {
            inner: v,
            attrs: None,
        }
    }
}

impl RVector {
    pub fn get_attr(&self, name: &str) -> Option<&RValue> {
        self.attrs.as_ref().and_then(|a| a.get(name))
    }

    pub fn set_attr(&mut self, name: String, value: RValue) {
        self.attrs
            .get_or_insert_with(|| Box::new(IndexMap::new()))
            .insert(name, value);
    }

    pub fn class(&self) -> Option<Vec<String>> {
        match self.get_attr("class") {
            Some(RValue::Vector(rv)) => match &rv.inner {
                Vector::Character(v) => Some(v.iter().filter_map(|s| s.clone()).collect()),
                _ => None,
            },
            _ => None,
        }
    }
}

#[derive(Debug, Clone)]
pub struct RList {
    pub values: Vec<(Option<String>, RValue)>,
    pub attrs: Option<Box<Attributes>>,
}

impl RList {
    pub fn new(values: Vec<(Option<String>, RValue)>) -> Self {
        RList {
            values,
            attrs: None,
        }
    }

    pub fn get_attr(&self, name: &str) -> Option<&RValue> {
        self.attrs.as_ref().and_then(|a| a.get(name))
    }

    pub fn set_attr(&mut self, name: String, value: RValue) {
        self.attrs
            .get_or_insert_with(|| Box::new(IndexMap::new()))
            .insert(name, value);
    }

    #[allow(dead_code)]
    pub fn class(&self) -> Option<Vec<String>> {
        match self.get_attr("class") {
            Some(RValue::Vector(rv)) => match &rv.inner {
                Vector::Character(v) => Some(v.iter().filter_map(|s| s.clone()).collect()),
                _ => None,
            },
            _ => None,
        }
    }
}

#[derive(Debug, Clone)]
pub enum RFunction {
    Closure {
        params: Vec<Param>,
        body: Expr,
        env: Environment,
    },
    Builtin {
        name: String,
        implementation: BuiltinImplementation,
        min_args: usize,
        max_args: Option<usize>,
        formals: &'static [&'static str],
    },
}

// region: From / TryFrom impls

impl From<RVector> for RValue {
    fn from(rv: RVector) -> Self {
        RValue::Vector(rv)
    }
}

impl From<RList> for RValue {
    fn from(list: RList) -> Self {
        RValue::List(list)
    }
}

impl<'a> TryFrom<&'a RValue> for &'a RVector {
    type Error = RError;
    fn try_from(value: &'a RValue) -> Result<Self, Self::Error> {
        match value {
            RValue::Vector(rv) => Ok(rv),
            other => Err(RError::new(
                RErrorKind::Type,
                format!("expected vector, got {}", other.type_name()),
            )),
        }
    }
}

impl TryFrom<RValue> for RVector {
    type Error = RError;
    fn try_from(value: RValue) -> Result<Self, Self::Error> {
        match value {
            RValue::Vector(rv) => Ok(rv),
            other => Err(RError::new(
                RErrorKind::Type,
                format!("expected vector, got {}", other.type_name()),
            )),
        }
    }
}

impl<'a> TryFrom<&'a RValue> for &'a RList {
    type Error = RError;
    fn try_from(value: &'a RValue) -> Result<Self, Self::Error> {
        match value {
            RValue::List(l) => Ok(l),
            other => Err(RError::new(
                RErrorKind::Type,
                format!("expected list, got {}", other.type_name()),
            )),
        }
    }
}

impl TryFrom<RValue> for RList {
    type Error = RError;
    fn try_from(value: RValue) -> Result<Self, Self::Error> {
        match value {
            RValue::List(l) => Ok(l),
            other => Err(RError::new(
                RErrorKind::Type,
                format!("expected list, got {}", other.type_name()),
            )),
        }
    }
}

// endregion

// region: RValue impls

impl RValue {
    /// Convenience: wrap an atomic Vector into RValue::Vector with no attributes.
    pub fn vec(v: Vector) -> Self {
        RValue::Vector(RVector {
            inner: v,
            attrs: None,
        })
    }

    /// Create a lazy promise wrapping an unevaluated expression and its lexical env.
    pub fn promise(expr: Expr, env: Environment) -> Self {
        RValue::Promise(std::rc::Rc::new(std::cell::RefCell::new(RPromise::new(
            expr, env,
        ))))
    }

    pub fn is_null(&self) -> bool {
        matches!(self, RValue::Null)
    }

    pub fn as_vector(&self) -> Option<&Vector> {
        match self {
            RValue::Vector(rv) => Some(&rv.inner),
            _ => None,
        }
    }

    #[allow(dead_code)]
    pub fn into_vector(self) -> Result<Vector, RError> {
        match self {
            RValue::Vector(rv) => Ok(rv.inner),
            RValue::Null => Ok(Vector::Logical(Logical(vec![]))),
            _ => Err(RError::new(
                RErrorKind::Type,
                "cannot coerce to vector".to_string(),
            )),
        }
    }

    pub fn type_name(&self) -> &str {
        match self {
            RValue::Null => "NULL",
            RValue::Vector(rv) => rv.inner.type_name(),
            RValue::List(_) => "list",
            RValue::Function(_) => "function",
            RValue::Environment(_) => "environment",
            RValue::Language(_) => "language",
            RValue::Promise(_) => "promise",
        }
    }

    pub fn length(&self) -> usize {
        match self {
            RValue::Null => 0,
            RValue::Vector(rv) => rv.inner.len(),
            RValue::List(l) => l.values.len(),
            RValue::Function(_) => 1,
            RValue::Environment(_) => 0,
            RValue::Language(lang) => lang.language_length(),
            RValue::Promise(_) => 1,
        }
    }
}

// endregion

// region: Display

impl fmt::Display for RValue {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RValue::Null => write!(f, "NULL"),
            RValue::Vector(rv) => write!(f, "{}", format_vector(&rv.inner)),
            RValue::List(list) => {
                for (i, (name, val)) in list.values.iter().enumerate() {
                    match name {
                        Some(n) => writeln!(f, "${}", n)?,
                        None => writeln!(f, "[[{}]]", i + 1)?,
                    }
                    writeln!(f, "{}", val)?;
                }
                Ok(())
            }
            RValue::Function(func) => match func {
                RFunction::Closure { .. } => write!(f, "function(...)"),
                RFunction::Builtin { name, .. } => write!(f, ".Primitive(\"{}\")", name),
            },
            RValue::Environment(_env) => write!(f, "<environment>"),
            RValue::Language(expr) => write!(f, "{}", deparse_expr(expr)),
            RValue::Promise(p) => {
                let p = p.borrow();
                if let Some(ref val) = p.value {
                    write!(f, "{}", val)
                } else {
                    write!(f, "<promise: {}>", deparse_expr(&p.expr))
                }
            }
        }
    }
}

pub fn format_vector(v: &Vector) -> String {
    let len = v.len();
    if len == 0 {
        return match v {
            Vector::Raw(_) => "raw(0)".to_string(),
            Vector::Logical(_) => "logical(0)".to_string(),
            Vector::Integer(_) => "integer(0)".to_string(),
            Vector::Double(_) => "numeric(0)".to_string(),
            Vector::Complex(_) => "complex(0)".to_string(),
            Vector::Character(_) => "character(0)".to_string(),
        };
    }

    let elements: Vec<String> = match v {
        Vector::Raw(vals) => vals.iter().map(|b| format!("{:02x}", b)).collect(),
        Vector::Logical(vals) => vals
            .iter()
            .map(|x| match x {
                Some(true) => "TRUE".to_string(),
                Some(false) => "FALSE".to_string(),
                None => "NA".to_string(),
            })
            .collect(),
        Vector::Integer(vals) => vals
            .iter()
            .map(|x| match x {
                Some(i) => i.to_string(),
                None => "NA".to_string(),
            })
            .collect(),
        Vector::Double(vals) => vals
            .iter()
            .map(|x| match x {
                Some(f) => format_r_double(f),
                None => "NA".to_string(),
            })
            .collect(),
        Vector::Complex(vals) => vals
            .iter()
            .map(|x| match x {
                Some(c) => format_r_complex(*c),
                None => "NA".to_string(),
            })
            .collect(),
        Vector::Character(vals) => vals
            .iter()
            .map(|x| match x {
                Some(s) => format!("\"{}\"", s),
                None => "NA".to_string(),
            })
            .collect(),
    };

    // Right-align all elements to the width of the widest, matching R's output.
    let max_elem_width = elements
        .iter()
        .map(|e| UnicodeWidthStr::width(e.as_str()))
        .max()
        .unwrap_or(1);
    let padded: Vec<String> = elements
        .iter()
        .map(|e| format!("{:>width$}", e, width = max_elem_width))
        .collect();

    if len == 1 {
        return format!("[1] {}", padded[0]);
    }

    // Format with line indices like R does.
    // Label width is based on the largest index label.
    let max_label = format!("[{}]", len);
    let label_pad = UnicodeWidthStr::width(max_label.as_str());
    let max_width = 80;
    let mut result = String::new();
    let mut pos = 0;
    let elem_col_width = max_elem_width + 1; // +1 for space between elements

    while pos < padded.len() {
        let label = format!("[{}]", pos + 1);
        let mut line = format!("{:>width$}", label, width = label_pad);
        let mut current_width = label_pad;
        let line_start = pos;

        while pos < padded.len() {
            if current_width + elem_col_width > max_width && pos > line_start {
                break;
            }
            line.push(' ');
            line.push_str(&padded[pos]);
            current_width += elem_col_width;
            pos += 1;
        }

        if !result.is_empty() {
            result.push('\n');
        }
        result.push_str(&line);
    }

    result
}

// endregion

// region: deparse

use crate::parser::ast::{AssignOp, BinaryOp, NaType, SpecialOp, UnaryOp};

/// Convert an AST expression back to R source code (deparse).
pub fn deparse_expr(expr: &Expr) -> String {
    match expr {
        Expr::Null => "NULL".to_string(),
        Expr::Na(NaType::Logical) => "NA".to_string(),
        Expr::Na(NaType::Integer) => "NA_integer_".to_string(),
        Expr::Na(NaType::Real) => "NA_real_".to_string(),
        Expr::Na(NaType::Character) => "NA_character_".to_string(),
        Expr::Na(NaType::Complex) => "NA_complex_".to_string(),
        Expr::Inf => "Inf".to_string(),
        Expr::NaN => "NaN".to_string(),
        Expr::Bool(true) => "TRUE".to_string(),
        Expr::Bool(false) => "FALSE".to_string(),
        Expr::Integer(i) => format!("{}L", i),
        Expr::Double(d) => format_r_double(*d),
        Expr::Complex(d) => format!("{}i", d),
        Expr::String(s) => format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\"")),
        Expr::Symbol(s) => s.clone(),
        Expr::Dots => "...".to_string(),
        Expr::DotDot(n) => format!("..{}", n),
        Expr::UnaryOp { op, operand } => {
            let o = deparse_expr(operand);
            match op {
                UnaryOp::Neg => format!("-{}", o),
                UnaryOp::Pos => format!("+{}", o),
                UnaryOp::Not => format!("!{}", o),
                UnaryOp::Formula => format!("~{}", o),
            }
        }
        Expr::BinaryOp { op, lhs, rhs } => {
            let l = deparse_expr(lhs);
            let r = deparse_expr(rhs);
            let op_str = match op {
                BinaryOp::Add => "+",
                BinaryOp::Sub => "-",
                BinaryOp::Mul => "*",
                BinaryOp::Div => "/",
                BinaryOp::Pow => "^",
                BinaryOp::Mod => "%%",
                BinaryOp::IntDiv => "%/%",
                BinaryOp::Eq => "==",
                BinaryOp::Ne => "!=",
                BinaryOp::Lt => "<",
                BinaryOp::Gt => ">",
                BinaryOp::Le => "<=",
                BinaryOp::Ge => ">=",
                BinaryOp::And => "&",
                BinaryOp::AndScalar => "&&",
                BinaryOp::Or => "|",
                BinaryOp::OrScalar => "||",
                BinaryOp::Range => ":",
                BinaryOp::Pipe => "|>",
                BinaryOp::AssignPipe => "%<>%",
                BinaryOp::TeePipe => "%T>%",
                BinaryOp::ExpoPipe => "%$%",
                BinaryOp::Special(SpecialOp::In) => "%in%",
                BinaryOp::Special(SpecialOp::MatMul) => "%*%",
                BinaryOp::Special(SpecialOp::Kronecker) => "%x%",
                BinaryOp::Special(SpecialOp::Walrus) => ":=",
                BinaryOp::Special(SpecialOp::Other(ref name)) => name.as_str(),
                BinaryOp::Tilde => "~",
                BinaryOp::DoubleTilde => "~~",
            };
            format!("{} {} {}", l, op_str, r)
        }
        Expr::Assign { op, target, value } => {
            let t = deparse_expr(target);
            let v = deparse_expr(value);
            match op {
                AssignOp::LeftAssign => format!("{} <- {}", t, v),
                AssignOp::SuperAssign => format!("{} <<- {}", t, v),
                AssignOp::Equals => format!("{} = {}", t, v),
                AssignOp::RightAssign => format!("{} -> {}", v, t),
                AssignOp::RightSuperAssign => format!("{} ->> {}", v, t),
            }
        }
        Expr::Call { func, args, .. } => {
            let f = deparse_expr(func);
            format!("{}({})", f, args.iter().map(deparse_arg).join(", "))
        }
        Expr::Index { object, indices } => {
            let o = deparse_expr(object);
            format!("{}[{}]", o, indices.iter().map(deparse_arg).join(", "))
        }
        Expr::IndexDouble { object, indices } => {
            let o = deparse_expr(object);
            format!("{}[[{}]]", o, indices.iter().map(deparse_arg).join(", "))
        }
        Expr::Dollar { object, member } => format!("{}${}", deparse_expr(object), member),
        Expr::Slot { object, member } => format!("{}@{}", deparse_expr(object), member),
        Expr::NsGet { namespace, name } => format!("{}::{}", deparse_expr(namespace), name),
        Expr::NsGetInt { namespace, name } => format!("{}:::{}", deparse_expr(namespace), name),
        Expr::Formula { lhs, rhs } => {
            let l = lhs.as_ref().map(|e| deparse_expr(e)).unwrap_or_default();
            let r = rhs.as_ref().map(|e| deparse_expr(e)).unwrap_or_default();
            if l.is_empty() {
                format!("~{}", r)
            } else {
                format!("{} ~ {}", l, r)
            }
        }
        Expr::If {
            condition,
            then_body,
            else_body,
        } => {
            let c = deparse_expr(condition);
            let t = deparse_expr(then_body);
            match else_body {
                Some(e) => format!("if ({}) {} else {}", c, t, deparse_expr(e)),
                None => format!("if ({}) {}", c, t),
            }
        }
        Expr::For { var, iter, body } => {
            format!(
                "for ({} in {}) {}",
                var,
                deparse_expr(iter),
                deparse_expr(body)
            )
        }
        Expr::While { condition, body } => {
            format!("while ({}) {}", deparse_expr(condition), deparse_expr(body))
        }
        Expr::Repeat { body } => format!("repeat {}", deparse_expr(body)),
        Expr::Break => "break".to_string(),
        Expr::Next => "next".to_string(),
        Expr::Return(Some(e)) => format!("return({})", deparse_expr(e)),
        Expr::Return(None) => "return()".to_string(),
        Expr::Block(exprs) => {
            if exprs.len() == 1 {
                deparse_expr(&exprs[0])
            } else {
                format!(
                    "{{\n    {}\n}}",
                    exprs.iter().map(deparse_expr).join("\n    ")
                )
            }
        }
        Expr::Function { params, body } => {
            let p = params
                .iter()
                .map(|p| {
                    if p.is_dots {
                        "...".to_string()
                    } else if let Some(ref d) = p.default {
                        format!("{} = {}", p.name, deparse_expr(d))
                    } else {
                        p.name.clone()
                    }
                })
                .join(", ");
            format!("function({}) {}", p, deparse_expr(body))
        }
        Expr::Program(exprs) => exprs.iter().map(deparse_expr).join("\n"),
    }
}

fn deparse_arg(arg: &Arg) -> String {
    match (&arg.name, &arg.value) {
        (Some(n), Some(v)) => format!("{} = {}", n, deparse_expr(v)),
        (None, Some(v)) => deparse_expr(v),
        (Some(n), None) => format!("{} = ", n),
        (None, None) => String::new(),
    }
}

// endregion