package benchmarks

import org.openjdk.jmh.annotations._

@State(Scope.Benchmark)
class SumBenchmark:
  val bigArray: Array[Int] = (1 to 10000).toArray
  val bigList: List[Int] = (1 to 10000).toList

  @Benchmark
  def arrayMethod =
    bigArray.sum

  @Benchmark
  def arrayWhileLoopIndex(): Int =
    val length = bigArray.length
    var i = 0
    var sum = 0
    while i < length do
      sum += bigArray(i)
      i = i + 1
    sum

  @Benchmark
  def arrayForLoopIndex(): Int =
    var sum = 0
    for i <- 0 until bigArray.length do sum += bigArray(i)
    sum

  final class OptimizedRange(from: Int, to: Int):
    inline def foreach(inline f: Int => Unit): Unit =
      var i = from
      while i < to do
        f(i)
        i = i + 1

  @Benchmark
  def arrayInlinedForLoopIndex() =
    var sum = 0
    for i <- OptimizedRange(0, bigArray.length) do sum += bigArray(i)
    sum

  @Benchmark
  def arrayForLoop() =
    var sum = 0
    for n <- bigArray do sum += n
    sum

  extension (array: Array[Int])
    inline def optimizedForeach(inline f: Int => Unit): Unit =
      val to = array.length
      var i = 0
      while i < to do
        f(i)
        i = i + 1

  @Benchmark
  def arrayOptimizedForeach() =
    var sum = 0
    bigArray.optimizedForeach(sum += _)
    sum

  @Benchmark
  def listMethod =
    bigList.sum

  @Benchmark
  def listForLoopIndex(): Int =
    var sum = 0
    for i <- 0 until bigList.length do sum += bigList(i)
    sum

  @Benchmark
  def listForLoop() =
    var sum = 0
    for n <- bigList do sum += n
    sum

  extension (list: List[Int])
    inline def optimizedForeach(inline f: Int => Unit): Unit =
      var curr = list
      while curr != Nil do
        f(curr.head)
        curr = curr.tail

  @Benchmark
  def listOptimizedForeach() =
    var sum = 0
    bigList.optimizedForeach(sum += _)
    sum