module math

fn abs(n) {
  if n < 0 {
    return -n
  }
  return n
}

fn bin(value) {
  return _format_with_prefix(value, 2, "0b", false)
}

fn ceil_div(a, b) {
  if b == 0 {
    return error("ceil_div div by zero")
  }
  if a % b == 0 {
    return a / b
  }
  if a > 0 && b > 0 {
    return a / b + 1
  }
  if a < 0 && b < 0 {
    return a / b + 1
  }
  return a / b
}

fn clamp(value, low, high) {
  if low > high {
    return error("clamp range is inverted")
  }
  if value < low {
    return low
  }
  if value > high {
    return high
  }
  return value
}

fn cos_scaled(degrees, bits) {
  pair := sin_cos_scaled(degrees, bits)
  if is_error(pair) {
    return pair
  }
  return pair[1]
}

fn div_mod(value, divisor) {
  quotient := value / divisor
  remainder := value % divisor
  if remainder < 0 {
    remainder = remainder + divisor
    quotient = quotient - 1
  }
  return [quotient, remainder]
}

fn format_int(args...) {
  // check if len(args) is between 2 and 3
  count := len(args)
  if count < 2 || count > 3 {
    return error("math.format_int expects 2 or 3 arguments")
  }
  value := args[0]
  base := args[1]
  if !typing.is_int(base) {
    return error("math.format_int base must be an integer")
  }
  if base < 2 || base > 36 {
    return error("math.format_int base must be between 2 and 36")
  }
  uppercaseFlag := false
  if len(args) == 3 {
    if !typing.is_bool(args[2]) {
      return error("math.format_int uppercase flag must be a boolean")
    }
    uppercaseFlag = args[2]
  }
  return _format_signed(value, base, uppercaseFlag)
}

fn gcd(a, b) {
  if a < 0 {
    a = -a
  }
  if b < 0 {
    b = -b
  }
  while b != 0 {
    t := b
    b = a % b
    a = t
  }
  return a
}

fn hex(value) {
  return _format_with_prefix(value, 16, "0x", false)
}

fn is_even(n) {
  return n % 2 == 0
}

fn is_odd(n) {
  return n % 2 != 0
}

fn max(a, b) {
  if a > b {
    return a
  }
  return b
}

fn min(a, b) {
  if a < b {
    return a
  }
  return b
}

fn normalise_degrees(degrees) {
  h := degrees % 360
  if h < 0 {
    h = h + 360
  }
  return h
}

fn num_digits(n) {
  if n == 0 {
    return 1
  }
  if n < 0 {
    n = -n
  }
  d := 0
  while n > 0 {
    n = n / 10
    d = d + 1
  }
  return d
}

fn oct(value) {
  return _format_with_prefix(value, 8, "0o", false)
}

fn parse_bin(text) {
  return _parse_int_text(text, 2, "0b", "math.parse_bin")
}

fn parse_hex(text) {
  return _parse_int_text(text, 16, "0x", "math.parse_hex")
}

fn parse_int(args...) {
  count := len(args)
  if count < 1 || count > 2 {
    return error("math.parse_int expects 1 or 2 arguments")
  }
  text := args[0]
  base := 10
  if count == 2 {
    baseArg := args[1]
    if !typing.is_int(baseArg) {
      return error("math.parse_int base must be an integer")
    }
    base = baseArg
  }
  if base < 2 || base > 36 {
    return error("math.parse_int base must be between 2 and 36")
  }
  return _parse_int_text(text, base, nil, "math.parse_int")
}

fn parse_oct(text) {
  return _parse_int_text(text, 8, "0o", "math.parse_oct")
}

fn pow_10(k) {
  n := 1
  i := 0
  while i < k {
    n = n * 10
    i = i + 1
  }
  return n
}

fn sign(n) {
  if n < 0 {
    return -1
  }
  if n > 0 {
    return 1
  }
  return 0
}

fn sin_cos_scaled(degrees, bits) {
  if !typing.is_int(degrees) {
    return error("math.sin_cos_scaled expects integer degrees, got " + type(degrees))
  }
  if !typing.is_int(bits) || bits < 0 || bits > _TRIG_BITS {
    return error("math.sin_cos_scaled expects bits in 0.." + str(_TRIG_BITS) + ", got " + inspect(bits))
  }
  pair := _sin_cos_q30(degrees)
  if bits == _TRIG_BITS {
    return pair
  }
  shift := _TRIG_BITS - bits
  return [pair[0] >> shift, pair[1] >> shift]
}

fn sin_scaled(degrees, bits) {
  pair := sin_cos_scaled(degrees, bits)
  if is_error(pair) {
    return pair
  }
  return pair[0]
}

fn sqrt(n) {
  if n < 0 {
    return error("Square root of a negative number is undefined.")
  }

  if n < 2 {
    return n
  }

  // Initial guess: n // 2 or closer approximation
  x := n
  y := (x + 1) / 2

  while y < x {
    x = y
    y = (x + n / x) / 2
  }

  return x
}