import assert from 'assert';

// 简化版的 AlgorithmEngine 类
class SimpleAlgorithmEngine {
 TryEvaluate(exp, def) {
 try {
 // 简单的表达式求值
 const result = eval(exp);
 return typeof result === typeof def ? result : def;
 } catch (e) {
 return def;
 }
 }
}

// 测试用例
function testBasicArithmetic() {
 console.log('开始测试 基本算术运算...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let c = engine.TryEvaluate('2+3', 0);
 assert.strictEqual(c, 5, '2+3 应该等于 5');
 
 c = engine.TryEvaluate('(2)+3', 0);
 assert.strictEqual(c, 5, '(2)+3 应该等于 5');
 
 c = engine.TryEvaluate('2+3*2+10/2*4', 0);
 assert.strictEqual(c, 28, '2+3*2+10/2*4 应该等于 28');
 
 console.log('基本算术运算 测试通过!');
}

function testScientificNotation() {
 console.log('开始测试 科学计数法...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let c = engine.TryEvaluate('2.1e3 + 10', 0);
 assert.strictEqual(c, 2110, '2.1e3 + 10 应该等于 2110');
 
 console.log('科学计数法 测试通过!');
}

function testFloatingPoint() {
 console.log('开始测试 浮点数...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let d = engine.TryEvaluate('2.1e-3 + 10', 0.0);
 assert.strictEqual(d, 10.0021, '2.1e-3 + 10 应该等于 10.0021');
 
 console.log('浮点数 测试通过!');
}

function testConstants() {
 console.log('开始测试 常量...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let e = engine.TryEvaluate('Math.E', 0.0);
 assert.strictEqual(e, Math.E, 'e 应该等于 Math.E');
 
 e = engine.TryEvaluate('Math.PI', 0.0);
 assert.strictEqual(e, Math.PI, 'pi 应该等于 Math.PI');
 
 console.log('常量 测试通过!');
}

function testBoolean() {
 console.log('开始测试 布尔值...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let b = engine.TryEvaluate('true', false);
 assert.strictEqual(b, true, 'true 应该等于 true');
 
 b = engine.TryEvaluate('false', true);
 assert.strictEqual(b, false, 'false 应该等于 false');
 
 console.log('布尔值 测试通过!');
}

function testConditionalExpression() {
 console.log('开始测试 条件表达式...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let b1 = engine.TryEvaluate('true ? 1 : 2', 0);
 assert.strictEqual(b1, 1, 'true ? 1 : 2 应该等于 1');
 
 b1 = engine.TryEvaluate('false ? 1 : 2', 0);
 assert.strictEqual(b1, 2, 'false ? 1 : 2 应该等于 2');
 
 console.log('条件表达式 测试通过!');
}

function testString() {
 console.log('开始测试 字符串...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let s = engine.TryEvaluate('"aa" + "bb"', "");
 assert.strictEqual(s, "aabb", '"aa" + "bb" 应该等于 "aabb"');
 
 console.log('字符串 测试通过!');
}

function testArray() {
 console.log('开始测试 数组...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let r = engine.TryEvaluate('[1,2,3,4].length', 0);
 assert.strictEqual(r, 4, '[1,2,3,4].length 应该等于 4');
 
 console.log('数组 测试通过!');
}

function testComparison() {
 console.log('开始测试 比较运算...');
 
 const engine = new SimpleAlgorithmEngine();
 
 let value = engine.TryEvaluate('1 > (-2)', false);
 assert.strictEqual(value, true, '1 > (-2) 应该等于 true');
 
 value = engine.TryEvaluate('-1 > -2', false);
 assert.strictEqual(value, true, '-1 > -2 应该等于 true');
 
 let value3 = engine.TryEvaluate('-7 < -2', false);
 assert.strictEqual(value3, true, '-7 < -2 应该等于 true');
 
 console.log('比较运算 测试通过!');
}

// 运行所有测试
function runAllTests() {
 try {
 testBasicArithmetic();
 testScientificNotation();
 testFloatingPoint();
 testConstants();
 testBoolean();
 testConditionalExpression();
 testString();
 testArray();
 testComparison();
 console.log('所有测试通过!');
 } catch (error) {
 console.error('测试失败:', error.message);
 process.exit(1);
 }
}

// 执行测试
runAllTests();

export {
 testBasicArithmetic,
 testScientificNotation,
 testFloatingPoint,
 testConstants,
 testBoolean,
 testConditionalExpression,
 testString,
 testArray,
 testComparison,
 runAllTests
};