ruchy 4.1.1

//! Core method dispatch logic
//!
//! Extracted from interpreter_methods.rs for coverage attribution.

#![allow(clippy::unused_self)]
#![allow(clippy::only_used_in_recursion)]
#![allow(clippy::uninlined_format_args)]
#![allow(clippy::cast_precision_loss)]
#![allow(clippy::expect_used)]
#![allow(clippy::cast_possible_truncation)]
#![allow(clippy::rc_buffer)]

use crate::frontend::ast::{Expr, ExprKind};
use crate::runtime::interpreter::Interpreter;
use crate::runtime::{InterpreterError, Value};
use std::collections::HashMap;
use std::sync::Arc;

impl Interpreter {
    /// Evaluate a method call
    pub(crate) fn eval_method_call(
        &mut self,
        receiver: &Expr,
        method: &str,
        args: &[Expr],
    ) -> Result<Value, InterpreterError> {
        // Special handling for stdlib namespace methods (e.g., Html.parse())
        if let ExprKind::Identifier(namespace) = &receiver.kind {
            // Check if this is a stdlib namespace call before trying to look it up as a variable
            let namespace_method = format!("{namespace}_{method}");

            // Try to evaluate as builtin function first
            let arg_values: Result<Vec<_>, _> =
                args.iter().map(|arg| self.eval_expr(arg)).collect();
            let arg_values = arg_values?;

            if let Ok(Some(result)) =
                crate::runtime::eval_builtin::eval_builtin_function(&namespace_method, &arg_values)
            {
                return Ok(result);
            }
        }

        // Special handling for mutating array methods on simple identifiers
        // e.g., messages.push(item)
        if let ExprKind::Identifier(var_name) = &receiver.kind {
            if method == "push" && args.len() == 1 {
                // Get current array value
                if let Ok(Value::Array(arr)) = self.lookup_variable(var_name) {
                    // Evaluate the argument
                    let arg_value = self.eval_expr(&args[0])?;

                    // Create new array with item added
                    let mut new_arr = arr.to_vec();
                    new_arr.push(arg_value);

                    // Update the variable binding - CRITICAL: Use env_set_mut to update
                    // in parent scopes (e.g., when push is called inside while loops)
                    self.env_set_mut(var_name.clone(), Value::Array(Arc::from(new_arr)));

                    return Ok(Value::Nil); // push returns nil
                }
            } else if method == "pop" && args.is_empty() {
                // Get current array value
                if let Ok(Value::Array(arr)) = self.lookup_variable(var_name) {
                    // Create new array with last item removed
                    let mut new_arr = arr.to_vec();
                    let popped_value = new_arr.pop().unwrap_or(Value::Nil);

                    // Update the variable binding - CRITICAL: Use env_set_mut to update
                    // in parent scopes (e.g., when pop is called inside while loops)
                    self.env_set_mut(var_name.clone(), Value::Array(Arc::from(new_arr)));

                    return Ok(popped_value); // pop returns the removed item
                }
            }
        }

        // Special handling for mutating array methods on ObjectMut fields
        // e.g., self.messages.push(item)
        if let ExprKind::FieldAccess { object, field } = &receiver.kind {
            if let Ok(object_value) = self.eval_expr(object) {
                if let Value::ObjectMut(cell_rc) = object_value {
                    // Check if this is a mutating array method
                    if method == "push" && args.len() == 1 {
                        // Evaluate the argument
                        let arg_value = self.eval_expr(&args[0])?;

                        // Get mutable access to the object
                        let mut obj = cell_rc
                            .lock()
                            .expect("Mutex poisoned: object lock is corrupted");

                        // Get the field value
                        if let Some(field_value) = obj.get(field) {
                            // If it's an array, push to it
                            if let Value::Array(arr) = field_value {
                                let mut new_arr = arr.to_vec();
                                new_arr.push(arg_value);
                                obj.insert(field.clone(), Value::Array(Arc::from(new_arr)));
                                return Ok(Value::Nil); // push returns nil
                            }
                        }
                    }
                }
            }
        }

        let receiver_value = self.eval_expr(receiver)?;

        // Special handling for Module method calls - look up function and call it
        // This allows `mod math { pub fun add(a, b) { ... } }; math.add(1, 2)`
        if let Value::Object(ref obj) = receiver_value {
            if let Some(Value::String(type_name)) = obj.get("__type") {
                if type_name.as_ref() == "Module" {
                    // Look up the function in the module
                    let func_value = obj.get(method).ok_or_else(|| {
                        InterpreterError::RuntimeError(format!(
                            "Module has no function named '{}'",
                            method
                        ))
                    })?;

                    // Evaluate arguments
                    let arg_values: Result<Vec<_>, _> =
                        args.iter().map(|arg| self.eval_expr(arg)).collect();
                    let arg_values = arg_values?;

                    // Call the function using the existing call_function infrastructure
                    return self.call_function(func_value.clone(), &arg_values);
                }
            }
        }

        // Special handling for DataFrame methods with closures - don't pre-evaluate the closure argument
        if matches!(receiver_value, Value::DataFrame { .. }) {
            match method {
                "filter" => return self.eval_dataframe_filter_method(&receiver_value, args),
                "with_column" => {
                    return self.eval_dataframe_with_column_method(&receiver_value, args)
                }
                "transform" => return self.eval_dataframe_transform_method(&receiver_value, args),
                _ => {}
            }
        }

        // Special handling for actor send/ask methods - convert undefined identifiers to messages
        if (method == "send" || method == "ask") && args.len() == 1 {
            // Check if receiver is an actor instance (immutable or mutable)
            let is_actor = match &receiver_value {
                Value::Object(ref obj) => obj.contains_key("__actor"),
                Value::ObjectMut(ref cell) => cell
                    .lock()
                    .expect("Mutex poisoned: object lock is corrupted")
                    .contains_key("__actor"),
                _ => false,
            };

            if is_actor {
                // Try to evaluate the argument as a message
                let arg_value = match &args[0].kind {
                    ExprKind::Identifier(name) => {
                        // Try to evaluate as variable first
                        if let Ok(val) = self.lookup_variable(name) {
                            val
                        } else {
                            // Treat as a zero-argument message constructor
                            let mut message = HashMap::new();
                            message.insert(
                                "__type".to_string(),
                                Value::from_string("Message".to_string()),
                            );
                            message.insert("type".to_string(), Value::from_string(name.clone()));
                            message.insert("data".to_string(), Value::Array(Arc::from(vec![])));
                            Value::Object(Arc::new(message))
                        }
                    }
                    _ => self.eval_expr(&args[0])?,
                };
                return self.dispatch_method_call(&receiver_value, method, &[arg_value], false);
            }
        }

        let arg_values: Result<Vec<_>, _> = args.iter().map(|arg| self.eval_expr(arg)).collect();
        let arg_values = arg_values?;

        // RUNTIME-099 FIX: For mutable method calls on identifiers, ensure variable binding
        // is updated after the method executes (similar to array.push/pop pattern)
        if let ExprKind::Identifier(var_name) = &receiver.kind {
            if matches!(receiver_value, Value::ObjectMut(_)) {
                // Call the mutable method
                let result = self.dispatch_method_call(
                    &receiver_value,
                    method,
                    &arg_values,
                    args.is_empty(),
                )?;

                // Update the variable binding to ensure mutations persist
                // (ObjectMut uses Arc, so this just ensures the binding is current)
                self.set_variable(var_name, receiver_value);

                return Ok(result);
            }

            // RUNTIME-ISSUE-148 FIX: Handle Value::Struct method calls with &mut self
            // Structs use value semantics - method modifications create a new struct that must replace the variable
            if let Value::Struct { name, fields } = &receiver_value {
                // Check if this struct has impl methods (not just generic object methods)
                let qualified_method_name = format!("{}::{}", name, method);
                if self.lookup_variable(&qualified_method_name).is_ok() {
                    // This is a struct with custom methods - use capture version
                    let (result, modified_fields_opt) = self
                        .eval_struct_instance_method_with_self_capture(
                            fields,
                            name,
                            method,
                            &arg_values,
                        )?;

                    // If method modified self, update the variable with modified struct
                    if let Some(modified_fields) = modified_fields_opt {
                        let new_struct = Value::Struct {
                            name: name.clone(),
                            fields: modified_fields,
                        };
                        self.set_variable(var_name, new_struct);
                    }

                    return Ok(result);
                }
            }
        }

        self.dispatch_method_call(&receiver_value, method, &arg_values, args.is_empty())
    }

    // Helper methods for method dispatch (complexity <10 each)

    /// Evaluate a message expression - if it's an undefined identifier, treat as message name
    /// Complexity: ≤5
    pub(crate) fn eval_message_expr(&mut self, message: &Expr) -> Result<Value, InterpreterError> {
        match &message.kind {
            ExprKind::Identifier(name) => {
                // Try to evaluate as variable first
                if let Ok(val) = self.lookup_variable(name) {
                    Ok(val)
                } else {
                    // Treat as a zero-argument message constructor
                    let mut msg_obj = HashMap::new();
                    msg_obj.insert(
                        "__type".to_string(),
                        Value::from_string("Message".to_string()),
                    );
                    msg_obj.insert("type".to_string(), Value::from_string(name.clone()));
                    msg_obj.insert("data".to_string(), Value::Array(Arc::from(vec![])));
                    Ok(Value::Object(Arc::new(msg_obj)))
                }
            }
            _ => self.eval_expr(message),
        }
    }

    pub(crate) fn dispatch_method_call(
        &mut self,
        receiver: &Value,
        method: &str,
        arg_values: &[Value],
        args_empty: bool,
    ) -> Result<Value, InterpreterError> {
        // EVALUATOR-001: Strip turbofish syntax from method names
        // Example: "parse::<i32>" becomes "parse"
        // Turbofish is for type hints only, not used in runtime method lookup
        let base_method = if let Some(pos) = method.find("::") {
            &method[..pos]
        } else {
            method
        };

        match receiver {
            Value::String(s) => self.eval_string_method(s, base_method, arg_values),
            Value::Array(arr) => self.eval_array_method(arr, base_method, arg_values),
            Value::Float(f) => self.eval_float_method(*f, base_method, args_empty),
            Value::Integer(n) => self.eval_integer_method(*n, base_method, arg_values),
            Value::DataFrame { columns } => {
                self.eval_dataframe_method(columns, base_method, arg_values)
            }
            Value::Object(obj) => {
                // Check if this is an actor instance
                if let Some(Value::String(actor_name)) = obj.get("__actor") {
                    self.eval_actor_instance_method(
                        obj,
                        actor_name.as_ref(),
                        base_method,
                        arg_values,
                    )
                }
                // Check if this is a class instance
                else if let Some(Value::String(class_name)) = obj.get("__class") {
                    self.eval_class_instance_method(
                        obj,
                        class_name.as_ref(),
                        base_method,
                        arg_values,
                    )
                }
                // Check if this is a struct instance with impl methods
                else if let Some(Value::String(struct_name)) =
                    obj.get("__struct_type").or_else(|| obj.get("__struct"))
                {
                    self.eval_struct_instance_method(
                        obj,
                        struct_name.as_ref(),
                        base_method,
                        arg_values,
                    )
                }
                // Check if this is a `DataFrame` builder
                else if let Some(Value::String(type_str)) = obj.get("__type") {
                    if type_str.as_ref() == "DataFrameBuilder" {
                        self.eval_dataframe_builder_method(obj, base_method, arg_values)
                    } else {
                        self.eval_object_method(obj, base_method, arg_values, args_empty)
                    }
                } else {
                    self.eval_object_method(obj, base_method, arg_values, args_empty)
                }
            }
            Value::ObjectMut(cell_rc) => {
                // Dispatch mutable objects the same way as immutable ones
                // Safe borrow: We only read metadata fields to determine dispatch
                let obj = cell_rc
                    .lock()
                    .expect("Mutex poisoned: object lock is corrupted");

                // Check if this is an actor instance
                if let Some(Value::String(actor_name)) = obj.get("__actor") {
                    let actor_name = actor_name.clone();
                    drop(obj); // Release borrow before recursive call
                    self.eval_actor_instance_method_mut(
                        cell_rc,
                        actor_name.as_ref(),
                        base_method,
                        arg_values,
                    )
                }
                // Check if this is a class instance
                else if let Some(Value::String(class_name)) = obj.get("__class") {
                    let class_name = class_name.clone();
                    drop(obj); // Release borrow before recursive call
                    self.eval_class_instance_method_mut(
                        cell_rc,
                        class_name.as_ref(),
                        base_method,
                        arg_values,
                    )
                }
                // Check if this is a struct instance with impl methods
                else if let Some(Value::String(struct_name)) =
                    obj.get("__struct_type").or_else(|| obj.get("__struct"))
                {
                    let struct_name = struct_name.clone();
                    drop(obj); // Release borrow before recursive call
                    self.eval_struct_instance_method_mut(
                        cell_rc,
                        struct_name.as_ref(),
                        base_method,
                        arg_values,
                    )
                }
                // ISSUE-116: Check if this is a File object
                else if let Some(Value::String(type_name)) = obj.get("__type") {
                    if type_name.as_ref() == "File" {
                        drop(obj); // Release borrow before recursive call
                        return self.eval_file_method_mut(cell_rc, base_method, arg_values);
                    }
                    drop(obj); // Release borrow before recursive call
                    self.eval_object_method_mut(cell_rc, base_method, arg_values, args_empty)
                } else {
                    drop(obj); // Release borrow before recursive call
                    self.eval_object_method_mut(cell_rc, base_method, arg_values, args_empty)
                }
            }
            Value::Struct { name, fields } => {
                // Dispatch struct instance method call
                self.eval_struct_instance_method(fields, name, base_method, arg_values)
            }
            Value::Class {
                class_name,
                fields,
                methods,
            } => {
                // Dispatch instance method call on Class
                self.eval_class_instance_method_on_class(
                    class_name,
                    fields,
                    methods,
                    base_method,
                    arg_values,
                )
            }
            #[cfg(not(target_arch = "wasm32"))]
            Value::HtmlDocument(doc) => {
                self.eval_html_document_method(doc, base_method, arg_values)
            }
            #[cfg(not(target_arch = "wasm32"))]
            Value::HtmlElement(elem) => {
                self.eval_html_element_method(elem, base_method, arg_values)
            }
            _ => self.eval_generic_method(receiver, base_method, args_empty),
        }
    }

    pub(crate) fn eval_float_method(
        &self,
        f: f64,
        method: &str,
        args_empty: bool,
    ) -> Result<Value, InterpreterError> {
        super::eval_method::eval_float_method(f, method, args_empty)
    }

    pub(crate) fn eval_integer_method(
        &self,
        n: i64,
        method: &str,
        arg_values: &[Value],
    ) -> Result<Value, InterpreterError> {
        super::eval_method::eval_integer_method(n, method, arg_values)
    }

    pub(crate) fn eval_generic_method(
        &self,
        receiver: &Value,
        method: &str,
        args_empty: bool,
    ) -> Result<Value, InterpreterError> {
        super::eval_method::eval_generic_method(receiver, method, args_empty)
    }
}

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

    fn make_interpreter() -> Interpreter {
        Interpreter::new()
    }

    fn make_expr(kind: ExprKind) -> Expr {
        Expr {
            kind,
            span: Span::default(),
            attributes: vec![],
            leading_comments: vec![],
            trailing_comment: None,
        }
    }

    // Test turbofish stripping
    #[test]
    fn test_dispatch_strips_turbofish() {
        let mut interp = make_interpreter();
        let s = Value::from_string("42".to_string());
        // parse::<i32> should become just "parse"
        let result = interp.dispatch_method_call(&s, "parse::<i32>", &[], false);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), Value::Integer(42));
    }

    // Test dispatch to string method
    #[test]
    fn test_dispatch_to_string_method() {
        let mut interp = make_interpreter();
        let s = Value::from_string("hello".to_string());
        let result = interp.dispatch_method_call(&s, "len", &[], false).unwrap();
        assert_eq!(result, Value::Integer(5));
    }

    // Test dispatch to array method
    #[test]
    fn test_dispatch_to_array_method() {
        let mut interp = make_interpreter();
        let arr = Value::Array(Arc::from(vec![Value::Integer(1), Value::Integer(2)]));
        let result = interp
            .dispatch_method_call(&arr, "len", &[], false)
            .unwrap();
        assert_eq!(result, Value::Integer(2));
    }

    // Test dispatch to float method
    #[test]
    fn test_dispatch_to_float_method() {
        let mut interp = make_interpreter();
        let f = Value::Float(3.7);
        let result = interp.dispatch_method_call(&f, "round", &[], true).unwrap();
        assert_eq!(result, Value::Float(4.0));
    }

    // Test dispatch to integer method
    #[test]
    fn test_dispatch_to_integer_method() {
        let mut interp = make_interpreter();
        let n = Value::Integer(-5);
        let result = interp.dispatch_method_call(&n, "abs", &[], false).unwrap();
        assert_eq!(result, Value::Integer(5));
    }

    // Test eval_message_expr with undefined identifier
    #[test]
    fn test_eval_message_expr_undefined_identifier() {
        let mut interp = make_interpreter();
        let expr = make_expr(ExprKind::Identifier("Increment".to_string()));
        let result = interp.eval_message_expr(&expr).unwrap();

        if let Value::Object(obj) = result {
            assert_eq!(
                obj.get("__type"),
                Some(&Value::from_string("Message".to_string()))
            );
            assert_eq!(
                obj.get("type"),
                Some(&Value::from_string("Increment".to_string()))
            );
        } else {
            panic!("Expected Object");
        }
    }

    // Test eval_message_expr with defined variable
    #[test]
    fn test_eval_message_expr_defined_variable() {
        let mut interp = make_interpreter();
        interp.set_variable("x", Value::Integer(42));
        let expr = make_expr(ExprKind::Identifier("x".to_string()));
        let result = interp.eval_message_expr(&expr).unwrap();
        assert_eq!(result, Value::Integer(42));
    }

    // Test eval_message_expr with literal
    #[test]
    fn test_eval_message_expr_literal() {
        let mut interp = make_interpreter();
        let expr = make_expr(ExprKind::Literal(crate::frontend::ast::Literal::Integer(
            100, None,
        )));
        let result = interp.eval_message_expr(&expr).unwrap();
        assert_eq!(result, Value::Integer(100));
    }

    // Test dispatch to object method - missing type marker
    #[test]
    fn test_dispatch_to_object_missing_type() {
        let mut interp = make_interpreter();
        let obj_map = HashMap::new();
        let obj = Value::Object(Arc::new(obj_map));

        let result = interp.dispatch_method_call(&obj, "test", &[], true);
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("missing __type marker"));
    }

    // Test dispatch to object method - unknown type
    #[test]
    fn test_dispatch_to_object_unknown_type() {
        let mut interp = make_interpreter();
        let mut obj_map = HashMap::new();
        obj_map.insert(
            "__type".to_string(),
            Value::from_string("UnknownType".to_string()),
        );
        let obj = Value::Object(Arc::new(obj_map));

        let result = interp.dispatch_method_call(&obj, "test", &[], true);
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("Unknown object type"));
    }

    // Test eval_generic_method
    #[test]
    fn test_eval_generic_method() {
        let interp = make_interpreter();
        let v = Value::Integer(42);
        let result = interp.eval_generic_method(&v, "to_string", false);
        // to_string might not be implemented for Integer in generic method
        // This test verifies the method is called without panic
        assert!(result.is_ok() || result.is_err());
    }

    // Test eval_float_method
    #[test]
    fn test_eval_float_method_ceil() {
        let interp = make_interpreter();
        let result = interp.eval_float_method(3.2, "ceil", true).unwrap();
        assert_eq!(result, Value::Float(4.0));
    }

    #[test]
    fn test_eval_float_method_floor() {
        let interp = make_interpreter();
        let result = interp.eval_float_method(3.8, "floor", true).unwrap();
        assert_eq!(result, Value::Float(3.0));
    }

    // Test eval_integer_method
    #[test]
    fn test_eval_integer_method_abs() {
        let interp = make_interpreter();
        let result = interp.eval_integer_method(-10, "abs", &[]).unwrap();
        assert_eq!(result, Value::Integer(10));
    }

    #[test]
    fn test_eval_integer_method_positive_abs() {
        let interp = make_interpreter();
        let result = interp.eval_integer_method(10, "abs", &[]).unwrap();
        assert_eq!(result, Value::Integer(10));
    }

    // Test push on array variable
    #[test]
    fn test_eval_method_call_push_on_array() {
        let mut interp = make_interpreter();
        interp.set_variable("arr", Value::Array(Arc::from(vec![Value::Integer(1)])));

        let receiver = make_expr(ExprKind::Identifier("arr".to_string()));
        let arg = make_expr(ExprKind::Literal(crate::frontend::ast::Literal::Integer(
            2, None,
        )));
        let result = interp.eval_method_call(&receiver, "push", &[arg]).unwrap();

        // push returns nil
        assert_eq!(result, Value::Nil);

        // Verify array was modified
        let arr = interp.lookup_variable("arr").unwrap();
        if let Value::Array(values) = arr {
            assert_eq!(values.len(), 2);
            assert_eq!(values[1], Value::Integer(2));
        } else {
            panic!("Expected Array");
        }
    }

    // Test pop on array variable
    #[test]
    fn test_eval_method_call_pop_on_array() {
        let mut interp = make_interpreter();
        interp.set_variable(
            "arr",
            Value::Array(Arc::from(vec![Value::Integer(1), Value::Integer(2)])),
        );

        let receiver = make_expr(ExprKind::Identifier("arr".to_string()));
        let result = interp.eval_method_call(&receiver, "pop", &[]).unwrap();

        // pop returns the removed item
        assert_eq!(result, Value::Integer(2));

        // Verify array was modified
        let arr = interp.lookup_variable("arr").unwrap();
        if let Value::Array(values) = arr {
            assert_eq!(values.len(), 1);
        } else {
            panic!("Expected Array");
        }
    }

    // Test pop on empty array
    #[test]
    fn test_eval_method_call_pop_empty_array() {
        let mut interp = make_interpreter();
        interp.set_variable("arr", Value::Array(Arc::from(vec![])));

        let receiver = make_expr(ExprKind::Identifier("arr".to_string()));
        let result = interp.eval_method_call(&receiver, "pop", &[]).unwrap();

        // pop returns nil for empty array
        assert_eq!(result, Value::Nil);
    }

    // Test push on ObjectMut field
    #[test]
    fn test_eval_method_call_push_on_objectmut_field() {
        use std::sync::Mutex;

        let mut interp = make_interpreter();

        // Create ObjectMut with an array field
        let mut obj = HashMap::new();
        obj.insert(
            "items".to_string(),
            Value::Array(Arc::from(vec![Value::Integer(1)])),
        );
        let obj_mut = Value::ObjectMut(Arc::new(Mutex::new(obj)));
        interp.set_variable("self", obj_mut);

        // Call self.items.push(2)
        let object = Box::new(make_expr(ExprKind::Identifier("self".to_string())));
        let receiver = make_expr(ExprKind::FieldAccess {
            object,
            field: "items".to_string(),
        });
        let arg = make_expr(ExprKind::Literal(crate::frontend::ast::Literal::Integer(
            2, None,
        )));
        let result = interp.eval_method_call(&receiver, "push", &[arg]).unwrap();

        // push returns nil
        assert_eq!(result, Value::Nil);
    }

    // Test Module method call
    #[test]
    fn test_eval_method_call_module() {
        use crate::frontend::ast::Literal;
        use std::cell::RefCell;
        use std::rc::Rc;

        let mut interp = make_interpreter();

        // Create a Module object with a function
        let mut module = HashMap::new();
        module.insert(
            "__type".to_string(),
            Value::from_string("Module".to_string()),
        );

        // Add a simple function that returns 42
        let body = make_expr(ExprKind::Literal(Literal::Integer(42, None)));
        let closure = Value::Closure {
            params: vec![],
            body: Arc::new(body),
            env: Rc::new(RefCell::new(HashMap::new())),
        };
        module.insert("get_answer".to_string(), closure);

        interp.set_variable("math", Value::Object(Arc::new(module)));

        // Call math.get_answer()
        let receiver = make_expr(ExprKind::Identifier("math".to_string()));
        let result = interp
            .eval_method_call(&receiver, "get_answer", &[])
            .unwrap();
        assert_eq!(result, Value::Integer(42));
    }

    // Test Module method not found
    #[test]
    fn test_eval_method_call_module_not_found() {
        let mut interp = make_interpreter();

        let mut module = HashMap::new();
        module.insert(
            "__type".to_string(),
            Value::from_string("Module".to_string()),
        );
        interp.set_variable("math", Value::Object(Arc::new(module)));

        let receiver = make_expr(ExprKind::Identifier("math".to_string()));
        let result = interp.eval_method_call(&receiver, "nonexistent", &[]);
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("no function named"));
    }

    // Test dispatch to actor with __actor marker
    #[test]
    fn test_dispatch_to_actor_object() {
        let mut interp = make_interpreter();

        let mut actor = HashMap::new();
        actor.insert(
            "__actor".to_string(),
            Value::from_string("Counter".to_string()),
        );
        let obj = Value::Object(Arc::new(actor));

        // Stop method returns true for any actor
        let result = interp
            .dispatch_method_call(&obj, "stop", &[], true)
            .unwrap();
        assert_eq!(result, Value::Bool(true));
    }

    // Test dispatch to class with __class marker
    #[test]
    fn test_dispatch_to_class_object() {
        let mut interp = make_interpreter();

        let mut class_obj = HashMap::new();
        class_obj.insert(
            "__class".to_string(),
            Value::from_string("MyClass".to_string()),
        );
        let obj = Value::Object(Arc::new(class_obj));

        // Should fail because no method registered
        let result = interp.dispatch_method_call(&obj, "unknown_method", &[], true);
        assert!(result.is_err());
    }

    // Test dispatch to struct with __struct marker
    #[test]
    fn test_dispatch_to_struct_object() {
        let mut interp = make_interpreter();

        let mut struct_obj = HashMap::new();
        struct_obj.insert(
            "__struct".to_string(),
            Value::from_string("Point".to_string()),
        );
        let obj = Value::Object(Arc::new(struct_obj));

        // Should fail because no impl method registered
        let result = interp.dispatch_method_call(&obj, "unknown_method", &[], true);
        assert!(result.is_err());
    }

    // Test dispatch to struct with __struct_type marker
    #[test]
    fn test_dispatch_to_struct_type_object() {
        let mut interp = make_interpreter();

        let mut struct_obj = HashMap::new();
        struct_obj.insert(
            "__struct_type".to_string(),
            Value::from_string("Point".to_string()),
        );
        let obj = Value::Object(Arc::new(struct_obj));

        // Should fail because no impl method registered
        let result = interp.dispatch_method_call(&obj, "unknown_method", &[], true);
        assert!(result.is_err());
    }

    // Test dispatch to DataFrameBuilder
    #[test]
    fn test_dispatch_to_dataframe_builder() {
        let mut interp = make_interpreter();

        let mut builder = HashMap::new();
        builder.insert(
            "__type".to_string(),
            Value::from_string("DataFrameBuilder".to_string()),
        );
        let obj = Value::Object(Arc::new(builder));

        // Unknown method on DataFrameBuilder should fail
        let result = interp.dispatch_method_call(&obj, "unknown", &[], true);
        assert!(result.is_err());
    }

    // Test dispatch to ObjectMut with __actor marker
    #[test]
    fn test_dispatch_to_actor_objectmut() {
        use std::sync::Mutex;

        let mut interp = make_interpreter();

        let mut actor = HashMap::new();
        actor.insert(
            "__actor".to_string(),
            Value::from_string("Counter".to_string()),
        );
        let obj = Value::ObjectMut(Arc::new(Mutex::new(actor)));

        // Stop method returns true for any actor
        let result = interp
            .dispatch_method_call(&obj, "stop", &[], true)
            .unwrap();
        assert_eq!(result, Value::Bool(true));
    }

    // Test dispatch to ObjectMut with __class marker
    #[test]
    fn test_dispatch_to_class_objectmut() {
        use std::sync::Mutex;

        let mut interp = make_interpreter();

        let mut class_obj = HashMap::new();
        class_obj.insert(
            "__class".to_string(),
            Value::from_string("MyClass".to_string()),
        );
        let obj = Value::ObjectMut(Arc::new(Mutex::new(class_obj)));

        // Should fail because no method registered
        let result = interp.dispatch_method_call(&obj, "unknown_method", &[], true);
        assert!(result.is_err());
    }

    // Test dispatch to ObjectMut with __struct marker
    #[test]
    fn test_dispatch_to_struct_objectmut() {
        use std::sync::Mutex;

        let mut interp = make_interpreter();

        let mut struct_obj = HashMap::new();
        struct_obj.insert(
            "__struct".to_string(),
            Value::from_string("Point".to_string()),
        );
        let obj = Value::ObjectMut(Arc::new(Mutex::new(struct_obj)));

        // Should fail because no impl method registered
        let result = interp.dispatch_method_call(&obj, "unknown_method", &[], true);
        assert!(result.is_err());
    }

    // Test dispatch to ObjectMut with File type
    #[test]
    fn test_dispatch_to_file_objectmut() {
        use std::sync::Mutex;

        let mut interp = make_interpreter();

        let mut file_obj = HashMap::new();
        file_obj.insert("__type".to_string(), Value::from_string("File".to_string()));
        let obj = Value::ObjectMut(Arc::new(Mutex::new(file_obj)));

        // close method should work on File
        let result = interp.dispatch_method_call(&obj, "close", &[], true);
        // May succeed or fail depending on actual File implementation
        assert!(result.is_ok() || result.is_err());
    }

    // Test dispatch to ObjectMut without special markers
    #[test]
    fn test_dispatch_to_generic_objectmut() {
        use std::sync::Mutex;

        let mut interp = make_interpreter();

        let mut obj_map = HashMap::new();
        obj_map.insert(
            "__type".to_string(),
            Value::from_string("GenericType".to_string()),
        );
        let obj = Value::ObjectMut(Arc::new(Mutex::new(obj_map)));

        let result = interp.dispatch_method_call(&obj, "test", &[], true);
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("Unknown object type"));
    }

    // Test dispatch to Value::Struct
    #[test]
    fn test_dispatch_to_value_struct() {
        let mut interp = make_interpreter();

        let fields: HashMap<String, Value> = HashMap::new();
        let v = Value::Struct {
            name: "Point".to_string(),
            fields: Arc::new(fields),
        };

        // Should fail because no impl method registered
        let result = interp.dispatch_method_call(&v, "unknown_method", &[], true);
        assert!(result.is_err());
    }

    // Test dispatch to Value::Class
    #[test]
    fn test_dispatch_to_value_class() {
        use std::sync::RwLock;

        let mut interp = make_interpreter();

        let v = Value::Class {
            class_name: "Person".to_string(),
            fields: Arc::new(RwLock::new(HashMap::new())),
            methods: Arc::new(HashMap::new()),
        };

        // Unknown method should fail
        let result = interp.dispatch_method_call(&v, "unknown_method", &[], true);
        assert!(result.is_err());
    }

    // Test dispatch to generic value (bool)
    #[test]
    fn test_dispatch_to_bool() {
        let mut interp = make_interpreter();
        let v = Value::Bool(true);

        // to_string should work
        let result = interp.dispatch_method_call(&v, "to_string", &[], true);
        // May not be implemented
        assert!(result.is_ok() || result.is_err());
    }

    // Test actor send with undefined identifier as message
    #[test]
    fn test_method_call_actor_send_undefined_message() {
        let mut interp = make_interpreter();

        // Create actor instance
        let mut actor = HashMap::new();
        actor.insert(
            "__actor".to_string(),
            Value::from_string("Counter".to_string()),
        );
        interp.set_variable("counter", Value::Object(Arc::new(actor)));

        // Call counter.send(Increment) where Increment is undefined
        let receiver = make_expr(ExprKind::Identifier("counter".to_string()));
        let arg = make_expr(ExprKind::Identifier("Increment".to_string()));

        // This will try to process the message
        let result = interp.eval_method_call(&receiver, "send", &[arg]);
        // Will fail because no handler for the constructed message
        assert!(result.is_err());
    }

    // Test actor ask with defined variable as message
    #[test]
    fn test_method_call_actor_ask_defined_variable() {
        let mut interp = make_interpreter();

        // Create actor instance
        let mut actor = HashMap::new();
        actor.insert(
            "__actor".to_string(),
            Value::from_string("Echo".to_string()),
        );
        interp.set_variable("echo", Value::Object(Arc::new(actor)));

        // Define message variable
        interp.set_variable("msg", Value::Integer(42));

        // Call echo.ask(msg) where msg is defined
        let receiver = make_expr(ExprKind::Identifier("echo".to_string()));
        let arg = make_expr(ExprKind::Identifier("msg".to_string()));

        // The ask method with a simple value echoes it back (default behavior)
        let result = interp.eval_method_call(&receiver, "ask", &[arg]).unwrap();
        // Echo behavior returns the message itself
        assert_eq!(result, Value::Integer(42));
    }

    // Test actor send with ObjectMut actor
    #[test]
    fn test_method_call_objectmut_actor_send() {
        use std::sync::Mutex;

        let mut interp = make_interpreter();

        // Create mutable actor instance
        let mut actor = HashMap::new();
        actor.insert(
            "__actor".to_string(),
            Value::from_string("Counter".to_string()),
        );
        interp.set_variable("counter", Value::ObjectMut(Arc::new(Mutex::new(actor))));

        // Call counter.send(Increment)
        let receiver = make_expr(ExprKind::Identifier("counter".to_string()));
        let arg = make_expr(ExprKind::Identifier("Increment".to_string()));

        let result = interp.eval_method_call(&receiver, "send", &[arg]);
        // Will fail because no handler
        assert!(result.is_err());
    }

    // Test non-actor with send method (not special handling)
    #[test]
    fn test_method_call_non_actor_send() {
        let mut interp = make_interpreter();

        // Create non-actor object
        let obj = HashMap::new();
        interp.set_variable("obj", Value::Object(Arc::new(obj)));

        // Call obj.send(x) - should not use actor special handling
        let receiver = make_expr(ExprKind::Identifier("obj".to_string()));
        let arg = make_expr(ExprKind::Literal(crate::frontend::ast::Literal::Integer(
            1, None,
        )));

        let result = interp.eval_method_call(&receiver, "send", &[arg]);
        // Will fail with missing type marker
        assert!(result.is_err());
    }

    // Test method call with ObjectMut identifier (RUNTIME-099 fix)
    #[test]
    fn test_method_call_objectmut_identifier() {
        use std::sync::Mutex;

        let mut interp = make_interpreter();

        // Create ObjectMut with __type
        let mut obj = HashMap::new();
        obj.insert(
            "__type".to_string(),
            Value::from_string("SomeType".to_string()),
        );
        interp.set_variable("obj", Value::ObjectMut(Arc::new(Mutex::new(obj))));

        let receiver = make_expr(ExprKind::Identifier("obj".to_string()));
        let result = interp.eval_method_call(&receiver, "test", &[]);
        assert!(result.is_err());
    }

    // Test method call with Struct identifier (RUNTIME-ISSUE-148 fix)
    #[test]
    fn test_method_call_struct_identifier_with_impl() {
        use crate::frontend::ast::Literal;
        use std::cell::RefCell;
        use std::rc::Rc;

        let mut interp = make_interpreter();

        // Register a method for Point struct
        let body = make_expr(ExprKind::Literal(Literal::Integer(99, None)));
        let closure = Value::Closure {
            params: vec![("self".to_string(), None)],
            body: Arc::new(body),
            env: Rc::new(RefCell::new(HashMap::new())),
        };
        interp.set_variable("Point::get_x", closure);

        // Create struct value
        let fields: HashMap<String, Value> = HashMap::new();
        let struct_val = Value::Struct {
            name: "Point".to_string(),
            fields: Arc::new(fields),
        };
        interp.set_variable("p", struct_val);

        let receiver = make_expr(ExprKind::Identifier("p".to_string()));
        let result = interp.eval_method_call(&receiver, "get_x", &[]).unwrap();
        assert_eq!(result, Value::Integer(99));
    }
}