// bench_object.ce — object/record and string benchmark
// Tests: property read/write, string concat, string interpolation, method-like dispatch

var time = use('time')

def iterations = 200000

// 1. Record create + property write
function bench_record_create() {
  var i = 0
  var r = null
  for (i = 0; i < iterations; i++) {
    r = {x: i, y: i + 1, z: i + 2}
  }
  return r.z
}

// 2. Property read in loop
function bench_prop_read() {
  var obj = {x: 10, y: 20, z: 30, w: 40}
  var i = 0
  var s = 0
  for (i = 0; i < iterations; i++) {
    s = s + obj.x + obj.y + obj.z + obj.w
  }
  return s
}

// 3. Dynamic property access (computed keys)
function bench_dynamic_prop() {
  var obj = {a: 1, b: 2, c: 3, d: 4, e: 5}
  var keys = ["a", "b", "c", "d", "e"]
  var i = 0
  var j = 0
  var s = 0
  for (i = 0; i < iterations; i++) {
    for (j = 0; j < 5; j++) {
      s = s + obj[keys[j]]
    }
  }
  return s
}

// 4. String concatenation
function bench_string_concat() {
  var i = 0
  var s = ""
  def n = 10000
  for (i = 0; i < n; i++) {
    s = s + "x"
  }
  return length(s)
}

// 5. String interpolation
function bench_interpolation() {
  var i = 0
  var s = ""
  def n = 50000
  for (i = 0; i < n; i++) {
    s = `item_${i}`
  }
  return s
}

// 6. Prototype chain / method-like call
function make_point(x, y) {
  return {
    x: x,
    y: y,
    sum: function(self) {
      return self.x + self.y
    }
  }
}

function bench_method_call() {
  var p = make_point(3, 4)
  var i = 0
  var s = 0
  for (i = 0; i < iterations; i++) {
    s = s + p.sum(p)
  }
  return s
}

// 7. Function call overhead (simple recursion depth)
function fib(n) {
  if (n <= 1) return n
  return fib(n - 1) + fib(n - 2)
}

function bench_fncall() {
  var i = 0
  var s = 0
  for (i = 0; i < 20; i++) {
    s = s + fib(25)
  }
  return s
}

function run(name, fn) {
  var start = time.number()
  var result = fn()
  var elapsed = time.number() - start
  var ms = whole(elapsed * 100000) / 100
  log.console(`  ${name}: ${ms} ms  (result: ${result})`)
}

log.console("=== Object / String / Call Benchmark ===")
log.console(`  iterations: ${iterations}`)
run("record_create ", bench_record_create)
run("prop_read     ", bench_prop_read)
run("dynamic_prop  ", bench_dynamic_prop)
run("string_concat ", bench_string_concat)
run("interpolation ", bench_interpolation)
run("method_call   ", bench_method_call)
run("fncall_fib25  ", bench_fncall)