const assert = require('assert');
const { createLexer } = require('../src/core/lexer');
const { createParser } = require('../src/core/parser');
const { createInterpreter } = require('../src/core/interpreter');

describe('Arrow Functions in Table Literals', () => {
  function interpret(code) {
    const lexer = createLexer(code);
    const tokens = lexer.allTokens();
    const parser = createParser(tokens);
    const ast = parser.parse();
    const interpreter = createInterpreter(ast);
    return interpreter.interpret();
  }

  it('should correctly parse and execute single arrow function in table', () => {
    const code = `calculator : {
  add: x y -> x + y;
};
result : calculator.add 5 3;
result`;
    
    const result = interpret(code);
    assert.strictEqual(result.value, 8);
    assert.strictEqual(result.isFloat, false);
  });

  it('should correctly handle arrow function with single parameter', () => {
    const code = `calculator : {
  double: x -> x * 2;
};
result : calculator.double 5;
result`;
    
    const result = interpret(code);
    assert.strictEqual(result.value, 10);
    assert.strictEqual(result.isFloat, false);
  });

  it('should correctly handle arrow function with complex body', () => {
    const code = `calculator : {
  complex: x y -> (x + y) * (x - y);
};
result : calculator.complex 5 3;
result`;
    
    const result = interpret(code);
    assert.strictEqual(result.value, 16);
    assert.strictEqual(result.isFloat, false);
  });

  it('should correctly handle arrow function with parentheses for precedence', () => {
    const code = `calculator : {
  multiply: x y -> x * (y + 1);
};
result : calculator.multiply 3 2;
result`;
    
    const result = interpret(code);
    assert.strictEqual(result.value, 9);
    assert.strictEqual(result.isFloat, false);
  });

  it('should correctly handle multiple arrow functions in table', () => {
    const code = `calculator : {
  add: x y -> x + y;
  subtract: x y -> x - y;
  multiply: x y -> x * (y + 1);
  complex: x y -> (x + y) * (x - y);
};
result1 : calculator.add 5 3;
result2 : calculator.subtract 10 4;
result3 : calculator.multiply 3 2;
result4 : calculator.complex 5 3;
result1`;
    
    const result = interpret(code);
    assert.strictEqual(result.value, 8);
    assert.strictEqual(result.isFloat, false);
  });

  it('should correctly handle arrow functions with different parameter counts', () => {
    const code = `calculator : {
  add: x y -> x + y;
  double: x -> x * 2;
  identity: x -> x;
  constant: -> 42;
};
result1 : calculator.add 5 3;
result2 : calculator.double 7;
result3 : calculator.identity 99;
result4 : calculator.constant;
result1`;
    
    const result = interpret(code);
    assert.strictEqual(result.value, 8);
    assert.strictEqual(result.isFloat, false);
  });
});