class SimpleTimer() {
    var start = System.nanoTime()
    var timer = System.nanoTime()

    fun getSet(): Double {
        val now = System.nanoTime()
        val result = (now - timer) / 1000000.0
        this.timer = now
        return result
    }

    fun totalTime(): Double {
        val now = System.nanoTime()
        return (now - start) / 1000000.0
    }
}

interface EngineTest {
    fun name(): String
    fun init()
    fun eval(code: String, data: Map<String, Any>): Any?
    fun invokeMethod(obj: Any, method: String, vararg args: Any): Any?
    fun invokeFunction(method: String, vararg args: Any): Any?
    fun express(express: String, data: Map<String, Any>): Any?
}

class JSREngineTest(val engineName: String) : EngineTest {
    lateinit var engine: ScriptEngine

    override fun name() = "JSR-$engineName"

    override fun init() {
        engine = ScriptEngineManager().getEngineByName(engineName)
    }

    override fun eval(code: String, data: Map<String, Any>): Any? {
        for ((key, value) in data) {
            engine.put(key, value)
        }
        return engine.eval(code)
    }

    override fun invokeMethod(obj: Any, method: String, vararg args: Any): Any? {
        val invocable = engine as Invocable
        return invocable.invokeMethod(obj, method, *args)
    }

    override fun invokeFunction(method: String, vararg args: Any): Any? {
        val invocable = engine as Invocable
        return invocable.invokeFunction(method, *args)
    }

    override fun express(express: String, data: Map<String, Any>): Any? {
        for ((key, value) in data) {
            engine.put(key, value)
        }
        return engine.eval(express)
    }
}

class JexlTest() : EngineTest {
    lateinit var engine: JexlEngine
    lateinit var context: JexlContext

    override fun name() = "jexl"

    override fun init() {
        engine = JexlBuilder().create()
        context = MapContext()
    }

    override fun eval(code: String, data: Map<String, Any>): Any? {
        for ((key, value) in data) {
            context.set(key, value)
        }
        return engine.createScript(code).execute(context)
    }

    override fun invokeMethod(obj: Any, method: String, vararg args: Any): Any? {
        return engine.invokeMethod(obj, method, *args)
    }

    override fun invokeFunction(method: String, vararg args: Any): Any? {
        return engine.createScript(method).execute(context, *args)
    }

    override fun express(express: String, data: Map<String, Any>): Any? {
        for ((key, value) in data) {
            context.set(key, value)
        }
        return engine.createExpression(express).evaluate(context)
    }
}

class GraalTest() : EngineTest {
    override fun name() = "graal.js"
    lateinit var context: Context
    lateinit var bindings: Value

    override fun init() {
        context = Context.newBuilder()
            .allowAllAccess(true)
            .build()
        bindings = context.getBindings("js")
    }

    override fun eval(code: String, data: Map<String, Any>): Any? {
        for ((key, value) in data) {
            bindings.putMember(key, value)
        }
        return context.eval("js", code)
    }

    override fun invokeMethod(obj: Any, method: String, vararg args: Any): Any? {
        val value = context.asValue(obj)
        return value.invokeMember(method, *args)
    }

    override fun invokeFunction(method: String, vararg args: Any): Any? {
        return bindings.getMember(method)
            .execute(*args)
//        return bindings.invokeMember(method, *args)
    }

    override fun express(express: String, data: Map<String, Any>): Any? {
        for ((key, value) in data) {
            bindings.putMember(key, value)
        }
        return context.eval("js", express)
    }
}

fun main() {
    // 屏蔽 slf4j 和 GraalJS 输出的警告
    System.err.close()
    // 屏蔽 GraalJS 输出的警告
    System.setProperty("polyglot.engine.WarnInterpreterOnly", "false")
    // 开启 GraalJS 的 nashorn 兼容模式
    System.setProperty("polyglot.js.nashorn-compat", "true")
    // [记录成绩]
    // key  : 引擎名称
    // value: 引擎成绩
    // [引擎成绩]:
    // key  : 项目
    // value: 耗时
    val engineScore = linkedMapOf<String, MutableMap<String, Double>>()
    // 可以更换这个列表来改变引擎的先后测试顺序
    val engineList = listOf(
        JSREngineTest("jexl"), JSREngineTest("rhino"),
        JSREngineTest("nashorn"), JSREngineTest("graal.js"),
        JexlTest(), GraalTest(),
    )
    val round = 10
    for (i in 0 until round) {
        println("round: $i")
        for (engine in engineList) {
            val roundScore = linkedMapOf<String, Double>()
            val timer = SimpleTimer()

            if (i == 0) {
                // 第一轮时初始化引擎
                engine.init()
                roundScore["init"] = timer.getSet()
            }

            // 执行测试代码
            test(engine, timer, roundScore)

            // 记录本轮总共耗时
            roundScore["total"] = timer.totalTime()

            // 输出本轮成绩
            val list = roundScore.map { String.format("%s = %-8.2f", it.key, it.value) }
            println(String.format("%12s: %s", engine.name(), list.joinToString(" | ")))

            Thread.sleep(1000)
            if (i == 0) {
                // 第一轮冷启动不计入成绩
                continue
            }

            // 将本轮成绩计入最终得分
            val totalScore = engineScore.computeIfAbsent(engine.name()) { linkedMapOf() }
            for ((key, value) in roundScore) {
                val score = totalScore.getOrDefault(key, 0.0) + value
                totalScore[key] = score
            }
        }
    }
    // 输出最终得分
    println("average score:")
    for ((engineName, map) in engineScore) {
        val list = map.map { String.format("%s = %-8.2f", it.key, it.value / (round - 1)) }
        println(String.format("%12s: %s", engineName, list.joinToString(" | ")))
    }
}

val fibCode = """
    function fib(n) {
        if (n <= 1) {
            return n;
        } else {
            return fib(n - 1) + fib(n - 2);
        }
    }
""".trimIndent()

fun test(engine: EngineTest, timer: SimpleTimer, roundScore: MutableMap<String, Double>) {
    engine.eval(fibCode, mapOf())
    for (i in listOf(10, 20, 30)) {
        try {
            engine.invokeFunction("fib", i)
            roundScore["fib(${i})"] = timer.getSet()
        } catch (e: Exception) {
            e.printStackTrace()
            // 如果不支持该语法，则成绩为 -1
            roundScore["fib(${i})"] = -1.0
        }
    }
}

val fibCode = """
    function fib(n) {
        if (n <= 1) {
            return n;
        } else {
            return fib(n - 1) + fib(n - 2);
        }
    }
    fib(count);
""".trimIndent()

fun test(engine: EngineTest, timer: SimpleTimer, roundScore: MutableMap<String, Double>) {
    for (i in listOf(10, 20, 30)) {
        try {
            engine.eval(fibCode, mapOf("count" to i))
            roundScore["fib(${i})"] = timer.getSet()
        } catch (e: Exception) {
            e.printStackTrace()
            // 如果不支持该语法，则成绩为 -1
            roundScore["fib(${i})"] = -1.0
        }
    }
}

// 冒泡排序
val sortCode = """
    function sort() {
        for (var i = 0; i < array.length; i++) {
            for (var j = i + 1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    var temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
    sort();
""".trimIndent()

val random = Random(System.currentTimeMillis())

fun test(engine: EngineTest, timer: SimpleTimer, roundScore: MutableMap<String, Double>) {
      val testName = "Bubble Sort"
      val array = IntArray(1000)
      for (n in 0 until array.size) {
          array[n] = random.nextInt(10240)
      }
      try {
          if (engine.name().contains("jexl")) {
              engine.eval(sortCode.replace("array.length", "size(array)"), mapOf("array" to array))
          } else {
              engine.eval(sortCode, mapOf("array" to array))
          }
          roundScore[testName] = timer.getSet()
      } catch (e: Exception) {
          e.printStackTrace()
          // 如果不支持该语法，则成绩为 -1
          roundScore[testName] = -1.0
      }
}

// 快速排序
val sortCode = """
    function partition(arr, left, right) {
      // 选择最右侧元素作为基准值
      var pivotValue = arr[right];
      var storeIndex = left; // 存储小于基准的元素位置
    
      // 遍历当前分区（left到right-1）
      var i = left;
      while (i < right) {
        if (arr[i] < pivotValue) {
          // 将小于基准的元素交换到存储位置
          var temp = arr[i];
          arr[i] = arr[storeIndex];
          arr[storeIndex] = temp;
          storeIndex++;
        }
        i++;
      }
    
      // 将基准值放到正确位置
      var temp = arr[storeIndex];
      arr[storeIndex] = arr[right];
      arr[right] = temp;
      return storeIndex; // 返回基准值的最终位置
    }
    function sort(arr, left, right) {
      // 递归终止条件：子数组长度<=1
      if (left >= right) return;
    
      // 分区操作
      var pivotIndex = partition(arr, left, right);
    
      // 递归排序左子数组和右子数组
      sort(arr, left, pivotIndex - 1);
      sort(arr, pivotIndex + 1, right);
    }
    sort(array, 0, array.length - 1);
""".trimIndent()

val random = Random(System.currentTimeMillis())

fun test(engine: EngineTest, timer: SimpleTimer, roundScore: MutableMap<String, Double>) {
    val testName = "Quick Sort"
    val array = IntArray(10000)
    for (n in 0 until array.size) {
        array[n] = random.nextInt(102400)
    }
    try {
        if (engine.name().contains("jexl")) {
            engine.eval(sortCode.replace("array.length", "size(array)"), mapOf("array" to array))
        } else {
            engine.eval(sortCode, mapOf("array" to array))
        }
        roundScore[testName] = timer.getSet()
    } catch (e: Exception) {
        e.printStackTrace()
        // 如果不支持该语法，则成绩为 -1
        roundScore[testName] = -1.0
    }
}

RangeError: Maximum call stack size exceeded
	at <js> sort(Unnamed:25-35:512-746)
	at <js> sort(Unnamed:34:712-743)
	at <js> sort(Unnamed:34:712-743)
	at <js> sort(Unnamed:34:712-743)
	at <js> sort(Unnamed:34:712-743)
	at <js> sort(Unnamed:34:712-743)
	at <js> sort(Unnamed:34:712-743)
	at <js> sort(Unnamed:34:712-743)
	at <js> sort(Unnamed:34:712-743)
	at <js> sort(Unnamed:34:712-743)
	at org.graalvm.polyglot.Context.eval(Context.java:446)
	at cn.hamster3.test.GraalTest.eval(EngineTest.kt:297)
	at cn.hamster3.test.EngineTestKt.test(EngineTest.kt:179)
	at cn.hamster3.test.EngineTestKt.main(EngineTest.kt:350)
	at cn.hamster3.test.EngineTestKt.main(EngineTest.kt)

似乎GraalVM默认只有10个方法栈大小，超出就会报错，找遍了网上的资源也没找到怎么修复这个问题
后来自己调试的时候发现，开启 nashorn 兼容模式之后就好了

val express = listOf(
    "(1.2 + 3.4 - 5.6) * 7.8 / 9.0",
    "(1.2 + 3.4 - 5.6) * 7.8 / 9.0 > 0.9 + 8.7 - 6.5 * 4.3 / 2.1",
    "Math.max(width, height) * (screen_width + screen_height) / (limit - 10) + Math.min(width, height) * (screen_width - screen_height) * 2",
    """
        ((width * height) / (screen_width + screen_height)) * 
         (limit - (width + height) / 2) + 
         ((screen_width * screen_height) / (width * height)) - 
         (limit / (width + height + screen_width + screen_height)) * 
         ((width * screen_height) + (height * screen_width)) / 
         (limit + (screen_width - width) * (screen_height - height))
    """.trimIndent(),
    """
        (((screen_width - width) * 2) / 3 + height) / 
        ((screen_height / limit) + (width * height / (screen_width + width))) *
        (Math.sqrt(limit * limit + (screen_width - width) * (screen_height - height)) / 
         ((screen_width / screen_height) * height + width))
    """.trimIndent(),
    """
        (((screen_width * width) + (screen_height * height)) / 
         (width * height + screen_width * screen_height)) *
        ((limit * (screen_width + width + screen_height + height)) / 
         ((screen_width - width) * (screen_height - height) + 
          (screen_width * screen_height - width * height))) +
        ((screen_width * screen_height) - (width * height)) / 
        (limit * (screen_width / width + screen_height / height))
    """.trimIndent(),
    """
        (((screen_width * width) / (screen_width + width * 2)) *
         ((screen_height + height) / (screen_height - height / 2)) +
         (limit * (screen_width - width) * (screen_height - height)) / 
         (width * height * (screen_width / width + screen_height / height))) /
        (((screen_width * screen_height) - (width * height)) / 
         (limit + (screen_width + width) * (screen_height + height)) +
         ((screen_width / screen_height) * (width / height)) - 
         ((screen_width - width) * (screen_height - height) / 
          (limit + width + height)))
    """.trimIndent()
)

val random = Random(System.currentTimeMillis())

fun test(engine: EngineTest, timer: SimpleTimer, roundScore: MutableMap<String, Double>) {
    for ((index, string) in express.withIndex()) {
        val testName = "express_$index"
        try {
            engine.express(
                string, mapOf(
                    "screen_width" to random.nextInt(1280),
                    "screen_height" to random.nextInt(720),
                    "width" to random.nextInt(400),
                    "height" to random.nextInt(300),
                    "limit" to random.nextInt(1024)
                )
            )
            roundScore[testName] = timer.getSet()
        } catch (e: Exception) {
            e.printStackTrace()
            // 如果不支持该语法，则成绩为 -1
            roundScore[testName] = -1.0
        }
    }
}

val invoke1 = """
    map.put("num", number);
    
    var data = map.getOrDefault("data", 0);
    map.put("dat", data);
""".trimIndent()

class UINode {
    var x: Int = 0
    var y: Int = 0
    var width: Int = 400
    var height: Int = 300
}

val invoke2 = """
    node.x = screen_width / 2 - node.getWidth() / 2;
    node.y = screen_height / 2 - node.getHeight() / 2;
""".trimIndent()

fun test(engine: EngineTest, timer: SimpleTimer, roundScore: MutableMap<String, Double>) {
    try {
        engine.eval(
            invoke1, mapOf(
                "number" to Random.nextInt(),
                "data" to Random.nextInt(),
                "map" to mutableMapOf<String, Any>()
            )
        )
        roundScore["invoke1"] = timer.getSet()
    } catch (e: Exception) {
        e.printStackTrace()
        roundScore["invoke1"] = -1.0
    }
    try {
        engine.eval(
            invoke2, mapOf(
                "node" to UINode(),
                "screen_width" to 1280,
                "screen_height" to 720
            )
        )
        roundScore["invoke2"] = timer.getSet()
    } catch (e: Exception) {
        e.printStackTrace()
        roundScore["invoke2"] = -1.0
    }
}