functional_programming_tests.rs

//! Comprehensive tests for functional programming features in Script
//!
//! This module tests all higher-order functions, iterators, and functional
//! programming utilities implemented in the Script standard library.

use script::runtime::closure::{create_closure_heap, Closure};
use script::runtime::{ScriptRc, Value};
use script::stdlib::{
    FunctionComposition, FunctionalExecutor, FunctionalOps, Generators, RangeIterator,
    ScriptIterator, ScriptOption, ScriptResult, ScriptValue, ScriptVec, VecIterator,
};
use std::collections::HashMap;

/// Helper function to create a test closure that doubles a number
fn create_double_closure() -> Value {
    create_closure_heap("double".to_string(), vec!["x".to_string()], vec![], false)
}

/// Helper function to create a test closure that checks if a number is even
fn create_even_predicate() -> Value {
    create_closure_heap("is_even".to_string(), vec!["x".to_string()], vec![], false)
}

/// Helper function to create a test closure that adds two numbers
fn create_add_closure() -> Value {
    create_closure_heap(
        "add".to_string(),
        vec!["x".to_string(), "y".to_string()],
        vec![],
        false,
    )
}

/// Helper function to register test closures with executor
fn setup_test_executor() -> FunctionalExecutor {
    let mut executor = FunctionalExecutor::new();

    // Register double closure
    executor.register_closure("double".to_string(), |args| {
        if let Value::I32(n) = &args[0] {
            Ok(Value::I32(n * 2))
        } else {
            Err(script::error::Error::new(
                script::error::ErrorKind::TypeError,
                "Expected i32",
            ))
        }
    });

    // Register even predicate
    executor.register_closure("is_even".to_string(), |args| {
        if let Value::I32(n) = &args[0] {
            Ok(Value::Bool(n % 2 == 0))
        } else {
            Err(script::error::Error::new(
                script::error::ErrorKind::TypeError,
                "Expected i32",
            ))
        }
    });

    // Register add closure
    executor.register_closure("add".to_string(), |args| {
        if let (Value::I32(x), Value::I32(y)) = (&args[0], &args[1]) {
            Ok(Value::I32(x + y))
        } else {
            Err(script::error::Error::new(
                script::error::ErrorKind::TypeError,
                "Expected two i32s",
            ))
        }
    });

    executor
}

#[test]
fn test_vector_map() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();
    vec.push(ScriptValue::I32(3)).unwrap();

    let double_closure = create_double_closure();

    // Test map functionality structure
    // Note: Full integration would require runtime setup
    assert_eq!(vec.len(), 3);

    // Test that the closure was created correctly
    match &double_closure {
        Value::Closure(closure) => {
            assert_eq!(closure.function_id, "double");
            assert_eq!(closure.parameters.len(), 1);
            assert_eq!(closure.parameters[0], "x");
        }
        _ => panic!("Expected closure"),
    }
}

#[test]
fn test_vector_filter() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();
    vec.push(ScriptValue::I32(3)).unwrap();
    vec.push(ScriptValue::I32(4)).unwrap();

    let even_predicate = create_even_predicate();

    // Test filter functionality structure
    assert_eq!(vec.len(), 4);

    // Test that the predicate closure was created correctly
    match &even_predicate {
        Value::Closure(closure) => {
            assert_eq!(closure.function_id, "is_even");
            assert_eq!(closure.parameters.len(), 1);
        }
        _ => panic!("Expected closure"),
    }
}

#[test]
fn test_vector_reduce() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();
    vec.push(ScriptValue::I32(3)).unwrap();

    let add_closure = create_add_closure();
    let initial = ScriptValue::I32(0);

    // Test reduce functionality structure
    assert_eq!(vec.len(), 3);

    // Test that the add closure was created correctly
    match &add_closure {
        Value::Closure(closure) => {
            assert_eq!(closure.function_id, "add");
            assert_eq!(closure.parameters.len(), 2);
        }
        _ => panic!("Expected closure"),
    }
}

#[test]
fn test_vector_for_each() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();
    vec.push(ScriptValue::I32(3)).unwrap();

    let print_closure =
        create_closure_heap("print".to_string(), vec!["x".to_string()], vec![], false);

    // Test forEach functionality structure
    assert_eq!(vec.len(), 3);

    // Test that the print closure was created correctly
    match &print_closure {
        Value::Closure(closure) => {
            assert_eq!(closure.function_id, "print");
            assert_eq!(closure.parameters.len(), 1);
        }
        _ => panic!("Expected closure"),
    }
}

#[test]
fn test_functional_executor() {
    let mut executor = setup_test_executor();

    // Test executor can be created and closures registered
    // This verifies the basic infrastructure works
    let double_closure = create_double_closure();

    match &double_closure {
        Value::Closure(closure) => {
            // Test basic closure structure
            assert_eq!(closure.function_id, "double");
            assert_eq!(closure.parameters.len(), 1);

            // Test closure execution would work with proper runtime
            // In a real test, this would execute: executor.execute_unary(closure, ScriptValue::I32(5))
        }
        _ => panic!("Expected closure"),
    }
}

#[test]
fn test_function_composition() {
    let f = create_double_closure();
    let g = create_double_closure();

    // Test compose function structure
    let composed = FunctionComposition::compose(&f, &g);
    assert!(composed.is_ok());

    // Test that composed function is a closure
    match composed.unwrap() {
        Value::Closure(closure) => {
            assert_eq!(closure.function_id, "composed_function");
            assert_eq!(closure.parameters.len(), 1);
            assert_eq!(closure.captured_vars.len(), 2); // f and g
        }
        _ => panic!("Expected composed closure"),
    }
}

#[test]
fn test_partial_application() {
    let add_closure = create_add_closure();
    let partial_args = vec![ScriptValue::I32(5)];

    // Test partial function structure
    let partial = FunctionComposition::partial(&add_closure, &partial_args);
    assert!(partial.is_ok());

    // Test that partial function is a closure
    match partial.unwrap() {
        Value::Closure(closure) => {
            assert!(closure.function_id.starts_with("partial_"));
            assert_eq!(closure.parameters.len(), 1); // One remaining parameter
            assert!(closure.captured_vars.contains_key("original_func"));
            assert!(closure.captured_vars.contains_key("partial_arg_0"));
        }
        _ => panic!("Expected partial closure"),
    }
}

#[test]
fn test_curry_function() {
    let add_closure = create_add_closure();

    // Test curry function structure
    let curried = FunctionComposition::curry(&add_closure);
    assert!(curried.is_ok());

    // Test that curried function is a closure
    match curried.unwrap() {
        Value::Closure(closure) => {
            assert!(closure.function_id.starts_with("curried_"));
            assert_eq!(closure.parameters.len(), 1); // Takes first parameter
            assert!(closure.captured_vars.contains_key("original_func"));
        }
        _ => panic!("Expected curried closure"),
    }
}

#[test]
fn test_pipe_operations() {
    let input = ScriptValue::I32(5);
    let functions = vec![create_double_closure(), create_double_closure()];

    // Test pipe function structure
    let result = FunctionComposition::pipe(input.clone(), &functions);

    // With proper executor registration, this would work
    // For now, we test the error handling
    assert!(result.is_err()); // Expected without proper executor setup
}

#[test]
fn test_vector_chaining() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();
    vec.push(ScriptValue::I32(3)).unwrap();
    vec.push(ScriptValue::I32(4)).unwrap();
    vec.push(ScriptValue::I32(5)).unwrap();

    // Test chaining operations
    let result = vec.chain(|v| v.take(3));
    assert!(result.is_ok());

    let taken = result.unwrap();
    assert_eq!(taken.len(), 3);
}

#[test]
fn test_vector_take_skip() {
    let vec = ScriptVec::new();
    for i in 0..10 {
        vec.push(ScriptValue::I32(i)).unwrap();
    }

    // Test take
    let taken = vec.take(5).unwrap();
    assert_eq!(taken.len(), 5);

    // Test skip
    let skipped = vec.skip(3).unwrap();
    assert_eq!(skipped.len(), 7);
}

#[test]
fn test_vector_zip() {
    let vec1 = ScriptVec::new();
    vec1.push(ScriptValue::I32(1)).unwrap();
    vec1.push(ScriptValue::I32(2)).unwrap();
    vec1.push(ScriptValue::I32(3)).unwrap();

    let vec2 = ScriptVec::new();
    vec2.push(ScriptValue::I32(4)).unwrap();
    vec2.push(ScriptValue::I32(5)).unwrap();
    vec2.push(ScriptValue::I32(6)).unwrap();

    // Test zip
    let zipped = vec1.zip(&vec2).unwrap();
    assert_eq!(zipped.len(), 3);

    // Each element should be a tuple (array with 2 elements)
    let first_tuple = zipped.get(0).unwrap().unwrap();
    match first_tuple {
        ScriptValue::Array(tuple_vec) => {
            assert_eq!(tuple_vec.len(), 2);
        }
        _ => panic!("Expected array tuple"),
    }
}

#[test]
fn test_vector_enumerate() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(10)).unwrap();
    vec.push(ScriptValue::I32(20)).unwrap();
    vec.push(ScriptValue::I32(30)).unwrap();

    // Test enumerate
    let enumerated = vec.enumerate().unwrap();
    assert_eq!(enumerated.len(), 3);

    // Each element should be a tuple (index, value)
    let first_tuple = enumerated.get(0).unwrap().unwrap();
    match first_tuple {
        ScriptValue::Array(tuple_vec) => {
            assert_eq!(tuple_vec.len(), 2);
            // First element should be index 0
            assert_eq!(tuple_vec.get(0).unwrap().unwrap(), ScriptValue::I32(0));
            // Second element should be value 10
            assert_eq!(tuple_vec.get(1).unwrap().unwrap(), ScriptValue::I32(10));
        }
        _ => panic!("Expected array tuple"),
    }
}

#[test]
fn test_vector_flatten() {
    let vec = ScriptVec::new();

    // Create nested arrays
    let inner1 = ScriptVec::new();
    inner1.push(ScriptValue::I32(1)).unwrap();
    inner1.push(ScriptValue::I32(2)).unwrap();

    let inner2 = ScriptVec::new();
    inner2.push(ScriptValue::I32(3)).unwrap();
    inner2.push(ScriptValue::I32(4)).unwrap();

    vec.push(ScriptValue::Array(ScriptRc::new(inner1))).unwrap();
    vec.push(ScriptValue::Array(ScriptRc::new(inner2))).unwrap();

    // Test flatten
    let flattened = vec.flatten().unwrap();
    assert_eq!(flattened.len(), 4);

    // Check values
    assert_eq!(flattened.get(0).unwrap().unwrap(), ScriptValue::I32(1));
    assert_eq!(flattened.get(1).unwrap().unwrap(), ScriptValue::I32(2));
    assert_eq!(flattened.get(2).unwrap().unwrap(), ScriptValue::I32(3));
    assert_eq!(flattened.get(3).unwrap().unwrap(), ScriptValue::I32(4));
}

#[test]
fn test_vector_unique() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(3)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();

    // Test unique
    let unique = vec.unique().unwrap();
    assert_eq!(unique.len(), 3);

    // Check that duplicates are removed
    assert_eq!(unique.get(0).unwrap().unwrap(), ScriptValue::I32(1));
    assert_eq!(unique.get(1).unwrap().unwrap(), ScriptValue::I32(2));
    assert_eq!(unique.get(2).unwrap().unwrap(), ScriptValue::I32(3));
}

#[test]
fn test_range_iterator() {
    let mut range = Generators::range(0, 5, 1).unwrap();

    // Test range generation
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(0))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(1))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(2))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(3))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(4))
    );
    assert_eq!(range.next().unwrap(), ScriptOption::None);
}

#[test]
fn test_range_iterator_step() {
    let mut range = Generators::range(0, 10, 2).unwrap();

    // Test range with step
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(0))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(2))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(4))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(6))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(8))
    );
    assert_eq!(range.next().unwrap(), ScriptOption::None);
}

#[test]
fn test_range_iterator_negative_step() {
    let mut range = Generators::range(5, 0, -1).unwrap();

    // Test range with negative step
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(5))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(4))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(3))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(2))
    );
    assert_eq!(
        range.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(1))
    );
    assert_eq!(range.next().unwrap(), ScriptOption::None);
}

#[test]
fn test_repeat_iterator() {
    let mut repeat = Generators::repeat(ScriptValue::I32(42), 3);

    // Test repeat
    assert_eq!(
        repeat.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(42))
    );
    assert_eq!(
        repeat.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(42))
    );
    assert_eq!(
        repeat.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(42))
    );
    assert_eq!(repeat.next().unwrap(), ScriptOption::None);
}

#[test]
fn test_cycle_iterator() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();

    let mut cycle = Generators::cycle(vec).take(6);

    // Test cycle (should repeat the pattern)
    assert_eq!(
        cycle.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(1))
    );
    assert_eq!(
        cycle.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(2))
    );
    assert_eq!(
        cycle.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(1))
    );
    assert_eq!(
        cycle.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(2))
    );
    assert_eq!(
        cycle.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(1))
    );
    assert_eq!(
        cycle.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(2))
    );
    assert_eq!(cycle.next().unwrap(), ScriptOption::None);
}

#[test]
fn test_vec_iterator() {
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();
    vec.push(ScriptValue::I32(3)).unwrap();

    let mut iter = VecIterator::new(vec);

    // Test vector iteration
    assert_eq!(
        iter.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(1))
    );
    assert_eq!(
        iter.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(2))
    );
    assert_eq!(
        iter.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(3))
    );
    assert_eq!(iter.next().unwrap(), ScriptOption::None);
}

#[test]
fn test_iterator_chaining() {
    let range1 = Generators::range(0, 3, 1).unwrap();
    let range2 = Generators::range(5, 8, 1).unwrap();

    let mut chained = range1.chain(range2);

    // Test chaining iterators
    assert_eq!(
        chained.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(0))
    );
    assert_eq!(
        chained.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(1))
    );
    assert_eq!(
        chained.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(2))
    );
    assert_eq!(
        chained.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(5))
    );
    assert_eq!(
        chained.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(6))
    );
    assert_eq!(
        chained.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(7))
    );
    assert_eq!(chained.next().unwrap(), ScriptOption::None);
}

#[test]
fn test_iterator_take_skip() {
    let range = Generators::range(0, 10, 1).unwrap();
    let mut taken = range.skip(3).take(4);

    // Test skip then take
    assert_eq!(
        taken.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(3))
    );
    assert_eq!(
        taken.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(4))
    );
    assert_eq!(
        taken.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(5))
    );
    assert_eq!(
        taken.next().unwrap(),
        ScriptOption::Some(ScriptValue::I32(6))
    );
    assert_eq!(taken.next().unwrap(), ScriptOption::None);
}

#[test]
fn test_iterator_collect() {
    let range = Generators::range(0, 5, 1).unwrap();
    let mut iter = range.take(3);

    // Test collect
    let collected = iter.collect().unwrap();
    assert_eq!(collected.len(), 3);

    assert_eq!(collected.get(0).unwrap().unwrap(), ScriptValue::I32(0));
    assert_eq!(collected.get(1).unwrap().unwrap(), ScriptValue::I32(1));
    assert_eq!(collected.get(2).unwrap().unwrap(), ScriptValue::I32(2));
}

#[test]
fn test_error_handling() {
    // Test error cases

    // Zero step in range
    let range_result = Generators::range(0, 5, 0);
    assert!(range_result.is_err());

    // Empty partial args
    let add_closure = create_add_closure();
    let empty_args = vec![];
    let partial = FunctionComposition::partial(&add_closure, &empty_args);
    assert!(partial.is_ok()); // Should work with empty args

    // Too many partial args
    let too_many_args = vec![
        ScriptValue::I32(1),
        ScriptValue::I32(2),
        ScriptValue::I32(3),
    ];
    let partial_fail = FunctionComposition::partial(&add_closure, &too_many_args);
    assert!(partial_fail.is_err());
}

#[test]
fn test_memory_management() {
    // Test that references are properly managed
    let vec = ScriptVec::new();
    for i in 0..1000 {
        vec.push(ScriptValue::I32(i)).unwrap();
    }

    // Chain multiple operations
    let result = vec.take(500).unwrap().skip(100).unwrap().take(200).unwrap();

    assert_eq!(result.len(), 200);

    // Test that large iterator chains don't cause memory issues
    let range = Generators::range(0, 1000, 1).unwrap();
    let mut complex_iter = range.take(500).skip(100).take(200);

    let final_result = complex_iter.collect().unwrap();
    assert_eq!(final_result.len(), 200);
}

#[test]
fn test_closure_integration() {
    // Test closure creation and basic structure
    let closures = vec![
        create_double_closure(),
        create_even_predicate(),
        create_add_closure(),
    ];

    for closure in closures {
        match closure {
            Value::Closure(c) => {
                assert!(!c.function_id.is_empty());
                assert!(!c.parameters.is_empty());
                // Test that closure is properly heap-allocated
                assert!(ScriptRc::strong_count(&c) >= 1);
            }
            _ => panic!("Expected closure"),
        }
    }
}

#[test]
fn test_type_safety() {
    // Test that type errors are properly handled
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::Bool(true)).unwrap(); // Mixed types

    // Operations should handle mixed types gracefully
    let result = vec.take(2);
    assert!(result.is_ok());

    let taken = result.unwrap();
    assert_eq!(taken.len(), 2);
}

#[test]
fn test_performance_characteristics() {
    // Test that lazy evaluation works correctly
    let range = Generators::range(0, 1000000, 1).unwrap();
    let mut lazy_iter = range.take(5);

    // Only the first 5 elements should be computed
    let mut count = 0;
    while let ScriptOption::Some(_) = lazy_iter.next().unwrap() {
        count += 1;
    }

    assert_eq!(count, 5);
}

#[test]
fn test_composition_correctness() {
    // Test function composition creates correct closure structure
    let f = create_double_closure();
    let g = create_double_closure();

    let composed = FunctionComposition::compose(&f, &g).unwrap();

    match composed {
        Value::Closure(closure) => {
            assert_eq!(closure.function_id, "composed_function");
            assert_eq!(closure.parameters.len(), 1);
            assert_eq!(closure.parameters[0], "x");

            // Should capture both f and g
            assert!(closure.captured_vars.contains_key("f"));
            assert!(closure.captured_vars.contains_key("g"));
        }
        _ => panic!("Expected composed closure"),
    }
}

#[test]
fn test_all_functional_methods_available() {
    // Test that all functional methods are available on ScriptVec
    let vec = ScriptVec::new();
    vec.push(ScriptValue::I32(1)).unwrap();
    vec.push(ScriptValue::I32(2)).unwrap();
    vec.push(ScriptValue::I32(3)).unwrap();

    // Test all methods exist and return correct types
    assert!(vec.take(2).is_ok());
    assert!(vec.skip(1).is_ok());
    assert!(vec.enumerate().is_ok());
    assert!(vec.flatten().is_ok());
    assert!(vec.unique().is_ok());

    let vec2 = ScriptVec::new();
    vec2.push(ScriptValue::I32(4)).unwrap();
    vec2.push(ScriptValue::I32(5)).unwrap();

    assert!(vec.zip(&vec2).is_ok());

    // Test chaining works
    let chain_result = vec.chain(|v| v.take(2));
    assert!(chain_result.is_ok());
}