///|
/// Shared by general, window and physical-row aggregates. Mirrors SQLite's
/// compensated summation and delayed integer-overflow decision (func.c SumCtx).
priv struct SumState {
  mut integer : Int64
  mut real : Double
  mut error : Double
  mut approximate : Bool
  mut overflow : Bool
  mut count : Int64
}

///|
fn sum_state() -> SumState {
  {
    integer: 0L,
    real: 0.0,
    error: 0.0,
    approximate: false,
    overflow: false,
    count: 0L,
  }
}

///|
fn SumState::add_real(self : SumState, value : Double) -> Unit {
  let before = self.real
  let after = before + value
  self.error += if before.abs() > value.abs() {
    before - after + value
  } else {
    value - after + before
  }
  self.real = after
}

///|
fn SumState::init_real(self : SumState) -> Unit {
  if self.integer > -4503599627370496L && self.integer < 4503599627370496L {
    self.real = self.integer.to_double()
    self.error = 0.0
    self.approximate = true
    return
  }
  let small = self.integer % 16384L
  self.real = (self.integer - small).to_double()
  self.error = small.to_double()
  self.approximate = true
}

///|
fn SumState::add_integer(self : SumState, n : Int64) -> Unit {
  if n <= -4503599627370496L || n >= 4503599627370496L {
    let small = n % 16384L
    self.add_real((n - small).to_double())
    self.add_real(small.to_double())
  } else {
    self.add_real(n.to_double())
  }
}

///|
fn SumState::add(self : SumState, value : Value) -> Unit {
  if value is Null {
    return
  }
  self.count += 1L
  let value = aggregate_number(value)
  if value is Integer(n) {
    if !self.approximate {
      let next = self.integer + n
      if (n >= 0L && next >= self.integer) || (n < 0L && next < self.integer) {
        self.integer = next
        return
      }
      self.overflow = true
      self.init_real()
    }
    self.add_integer(n)
  } else {
    if !self.approximate {
      self.init_real()
    }
    self.overflow = false
    self.add_real(as_double(value))
  }
}

///|
fn SumState::finish(self : SumState, name : String) -> Value raise SqlError {
  if self.count == 0L {
    return if name == "total" { Real(0.0) } else { Null }
  }
  if name == "sum" && self.overflow {
    fail("integer overflow")
  }
  if name == "sum" && !self.approximate {
    return Integer(self.integer)
  }
  let result = if !self.approximate {
    self.integer.to_double()
  } else if self.error.is_finite() {
    self.real + self.error
  } else {
    self.real
  }
  sql_real(if name == "avg" { result / self.count.to_double() } else { result })
}