module decimal

DIV_MODE := "half_even"

DIV_SCALE := 15

MODES := ["trunc", "round", "half_even"]

OPS := {
  "+": fn(a, b) { d := _coerce(a)  if is_error(d) { return d }  return d.add(b) },
  "-": fn(a, b) { d := _coerce(a)  if is_error(d) { return d }  return d.sub(b) },
  "*": fn(a, b) { d := _coerce(a)  if is_error(d) { return d }  return d.mul(b) },
  "%": fn(a, b) { d := _coerce(a)  if is_error(d) { return d }  return d.mod(b) },
  "**": fn(a, b) { d := _coerce(a)  if is_error(d) { return d }  return d.pow(b) },
  // Normalized, unlike an explicit .div() -- there the scale was asked for, so
  // it is kept. Here DIV_SCALE is a ceiling nobody chose, and `7.5 / 2.5`
  // answering "3.000000000000000" would be an artifact of that ceiling. The
  // other arithmetic entries normalize for the same reason.
  "/": fn(a, b) {
    d := _coerce(a)
    if is_error(d) {
      return d
    }
    q := d.div(b, DIV_SCALE, DIV_MODE)
    if is_error(q) {
      return q
    }
    return q.normalize()
  },

  "<": fn(a, b) { c := _cmp3(a, b)  if is_error(c) { return c }  return c < 0 },
  ">": fn(a, b) { c := _cmp3(a, b)  if is_error(c) { return c }  return c > 0 },
  "<=": fn(a, b) { c := _cmp3(a, b)  if is_error(c) { return c }  return c <= 0 },
  ">=": fn(a, b) { c := _cmp3(a, b)  if is_error(c) { return c }  return c >= 0 },
  // `==` answers FALSE for something it cannot compare, never an error. That is
  // what every other type does -- `1 == nil` is false, not "unsupported types"
  // -- and it is what `!=` needs to be a clean negation. Ordering is genuinely
  // different: mu reports "unsupported types for comparison" there, so the four
  // entries above keep the error.
  "==": fn(a, b) { c := _cmp3(a, b)  if is_error(c) { return false }  return c == 0 },

  // Unary and value protocol.
  "neg": fn(a) { d := _coerce(a)  if is_error(d) { return d }  return d.neg() },
  "str": fn(a) { d := _coerce(a)  if is_error(d) { return d }  return d.str() },
  "bool": fn(a) { d := _coerce(a)  if is_error(d) { return d }  return d.coeff != 0 },

  // Canonical scalar for hashing. The invariant the host relies on is that
  // a == b implies key(a) == key(b), which normalising before formatting gives.
  "key": fn(a) { d := _coerce(a)  if is_error(d) { return d }  return d.normalize().str() },
}

digits := "0123456789"

Decimal := fn(coeff, scale) {
  norm := _normalize_coeff_scale(coeff, scale)
  return _Decimal_raw(norm[0], norm[1])
}

fn from_int(n) {
  if !typing.is_int(n) {
    return error("from_int expects INTEGER")
  }
  return Decimal(n, 0)
}

fn log(value) {
  kind := type(value)

  if kind != "INTEGER" && kind != "Decimal" {
    return error("decimal.log expects INTEGER or Decimal, got " + kind)
  }

  if value <= 0 {
    return error("decimal.log expects a positive value, got " + str(value))
  }

  x := value
  if kind == "INTEGER" {
    x = from_int(value)
  }

  // Reduce x into [1, 2).
  k := 0

  while x >= 2 {
    x = x.div(2, _LOG_SCALE, "half_even")
    if is_error(x) {
      return x
    }
    k = k + 1
  }

  while x < 1 {
    x = x.mul(2)
    if is_error(x) {
      return x
    }
    k = k - 1
  }

  // z = (x - 1) / (x + 1)
  numerator := x.sub(1)
  denominator := x.add(1)

  z := numerator.div(
    denominator,
    _LOG_SCALE,
    "half_even"
  )
  if is_error(z) {
    return z
  }

  z2 := _log_mul(z, z)
  if is_error(z2) {
    return z2
  }

  // z + z^3/3 + z^5/5 + ...
  term := z
  sum := z
  divisor := 3

  while true {
    term = _log_mul(term, z2)
    if is_error(term) {
      return term
    }

    if term.coeff == 0 {
      break
    }

    add := term.div(
      divisor,
      _LOG_SCALE,
      "half_even"
    )
    if is_error(add) {
      return add
    }

    // At our working precision there is nothing further
    // for the series to contribute.
    if add.coeff == 0 {
      break
    }

    sum = sum.add(add)
    divisor = divisor + 2
  }

  // ln(x) = 2*series + k*ln(2)
  result := sum.mul(2)
  if is_error(result) {
    return result
  }

  offset := _ln2().mul(k)
  if is_error(offset) {
    return offset
  }

  result = result.add(offset)
  if is_error(result) {
    return result
  }

  return result.rescale(
    _LOG_SCALE,
    "half_even"
  ).normalize()
}

fn parse(text) {
  if !typing.is_str(text) {
    return error("parse expects STRING")
  }

  n := len(text)
  if n == 0 {
    return error("empty string")
  }

  i := 0
  neg := false

  if text[0] == "-" {
    neg = true
    i = 1
    if i >= n {
      return error("invalid decimal")
    }
  }

  coeff := 0
  scale := 0
  saw_digit := false

  // integer part
  while i < n && text[i] != "." {
    ch := text[i]
    d := -1
    j := 0
    while j < 10 {
      if digits[j] == ch {
        d = j
      }
      j = j + 1
    }
    if d < 0 {
      return error("invalid digit")
    }
    coeff = coeff * 10 + d
    saw_digit = true
    i = i + 1
  }

  // fractional part
  if i < n && text[i] == "." {
    i = i + 1
    if i >= n {
      return error("invalid decimal")
    }

    while i < n {
      ch := text[i]
      d := -1
      j := 0
      while j < 10 {
        if digits[j] == ch {
          d = j
        }
        j = j + 1
      }
      if d < 0 {
        return error("invalid digit")
      }
      coeff = coeff * 10 + d
      scale = scale + 1
      saw_digit = true
      i = i + 1
    }
  }

  if !saw_digit {
    return error("invalid decimal")
  }

  if neg {
    coeff = -coeff
  }

  return Decimal(coeff, scale)
}

fn ratio(a, b, scale, mode) {
  if !typing.is_int(a) {
    return error("ratio expects INTEGER a")
  }
  if !typing.is_int(b) {
    return error("ratio expects INTEGER b")
  }
  return from_int(a).div(from_int(b), scale, mode)
}