glyph-runtime 0.0.1

//! Test complex pattern matching scenarios

use glyph_parser::parse_glyph;
use glyph_runtime::{
    ast_to_ir::ast_to_ir,
    capability::CapabilitySet,
    ir_to_bytecode::ir_to_bytecode,
    vm::{VMConfig, VM},
};
use glyph_types::Value;

fn main() {
    println!("=== Testing Complex Pattern Matching ===\n");

    // Test 1: Nested match statements
    let nested_match = r#"
@program(name="nested_match", version="1.0", requires=[])

def main() -> int:
    let x = 42
    let y = "hello"
    
    match x:
        case 42:
            match y:
                case "hello":
                    return 1
                case "world":
                    return 2
                case _:
                    return 3
        case 0:
            return 4
        case _:
            return 5
"#;

    test_program("Nested match", nested_match, Value::Int(1));

    // Test 2: Multiple variable patterns
    let multi_var = r#"
@program(name="multi_var", version="1.0", requires=[])

def main() -> int:
    let x = 100
    
    match x:
        case 42:
            return 1
        case y:
            return y + 1
"#;

    test_program("Variable pattern with use", multi_var, Value::Int(101));

    // Test 3: Pattern matching with function calls
    let with_functions = r#"
@program(name="with_functions", version="1.0", requires=[])

def double(x: int) -> int:
    return x * 2

def main() -> int:
    let x = 5
    
    match double(x):
        case 10:
            return 1
        case 20:
            return 2
        case _:
            return 3
"#;

    test_program("Pattern with function call", with_functions, Value::Int(1));

    // Test 4: Pattern matching with no default
    let no_default = r#"
@program(name="no_default", version="1.0", requires=[])

def main() -> int:
    let x = 42
    
    match x:
        case 42:
            return 1
        case 0:
            return 2
"#;

    test_program("No default case", no_default, Value::Int(1));

    // Test 5: Complex expression in match subject
    let complex_subject = r#"
@program(name="complex_subject", version="1.0", requires=[])

def main() -> int:
    let x = 10
    let y = 32
    
    match x + y:
        case 42:
            return 100
        case 50:
            return 200
        case _:
            return 300
"#;

    test_program(
        "Complex subject expression",
        complex_subject,
        Value::Int(100),
    );
}

fn test_program(name: &str, code: &str, expected: Value) {
    println!("Testing {name}: ");

    match parse_glyph(code) {
        Ok(module) => {
            let ir_module = ast_to_ir(&module);
            let bytecode = ir_to_bytecode(&ir_module);

            let config = VMConfig {
                capabilities: CapabilitySet::new(),
                max_stack_size: 1024,
                max_call_depth: 100,
                max_execution_steps: 10000,
            };
            let mut vm = VM::new(config);
            vm.load_bytecode(bytecode);
            match vm.execute() {
                Ok(result) => {
                    if result == expected {
                        println!("  ✓ PASSED - got {result:?}");
                    } else {
                        println!("  ✗ FAILED - expected {expected:?}, got {result:?}");
                    }
                }
                Err(e) => {
                    println!("  ✗ FAILED - runtime error: {e:?}");
                }
            }
        }
        Err(e) => {
            println!("  ✗ FAILED - parse error: {e:?}");
        }
    }
    println!();
}