///|
const DECIMAL_MAX_DIGITS : Int32 = 1024

///|
const DECIMAL_MAX_SCALE : Int32 = 128

///|
pub(all) struct Decimal {
  coefficient : @bigint.BigInt
  scale : Int32
} derive(Eq, @debug.Debug)

///|
fn decimal_pow10(exponent : Int32) -> @bigint.BigInt {
  let builder = StringBuilder()
  builder.write_char('1')
  let mut index = 0
  while index < exponent {
    builder.write_char('0')
    index += 1
  }
  @bigint.BigInt::from_string(builder.to_string())
}

///|
fn decimal_digit_count(value : @bigint.BigInt) -> Int32 {
  let text = value.to_string()
  let offset = if text.has_prefix("-") { 1 } else { 0 }
  text.length() - offset
}

///|
fn decimal_result(
  coefficient : @bigint.BigInt,
  scale : Int32,
  offset : Int32,
) -> Result[Decimal, XbrlError] {
  if scale < 0 || scale > DECIMAL_MAX_SCALE {
    return Err(InvalidDecimal("scale exceeds the supported limit", offset))
  }
  if decimal_digit_count(coefficient) > DECIMAL_MAX_DIGITS {
    return Err(
      InvalidDecimal("coefficient exceeds the supported limit", offset),
    )
  }
  Ok(Decimal::normalize({ coefficient, scale, }))
}

///|
pub fn Decimal::zero() -> Decimal {
  { coefficient: @bigint.BigInt::from_int(0), scale: 0, }
}

///|
pub fn Decimal::normalize(self : Decimal) -> Decimal {
  let mut coefficient = self.coefficient
  let mut scale = self.scale
  if coefficient.is_zero() {
    return { coefficient: @bigint.BigInt::from_int(0), scale: 0, }
  }
  while scale > 0 && (coefficient % @bigint.BigInt::from_int(10)).is_zero() {
    coefficient = coefficient / @bigint.BigInt::from_int(10)
    scale -= 1
  }
  { coefficient, scale, }
}

///|
pub fn Decimal::parse(value : StringView) -> Result[Decimal, XbrlError] {
  let text = value.trim()
  let length = text.length()
  if length == 0 {
    return Err(InvalidDecimal("decimal is empty", 0))
  }
  let mut index = 0
  let negative = text.at(0) == 45
  if negative || text.at(0) == 43 {
    index += 1
    if index == length {
      return Err(InvalidDecimal("decimal sign requires digits", index))
    }
  }
  let builder = StringBuilder()
  if negative {
    builder.write_char('-')
  }
  let mut digit_count = 0
  let mut fractional_digits = 0
  let mut seen_dot = false
  while index < length {
    let code = text.at(index)
    if code == 46 {
      if seen_dot {
        return Err(InvalidDecimal("decimal contains multiple points", index))
      }
      seen_dot = true
      index += 1
      continue
    }
    if !is_ascii_digit(code) {
      return Err(
        InvalidDecimal("decimal contains a non-digit character", index),
      )
    }
    builder.write_char(code.unsafe_to_char())
    digit_count += 1
    if seen_dot {
      fractional_digits += 1
    }
    if digit_count > DECIMAL_MAX_DIGITS {
      return Err(
        InvalidDecimal("coefficient exceeds the supported limit", index),
      )
    }
    if fractional_digits > DECIMAL_MAX_SCALE {
      return Err(InvalidDecimal("scale exceeds the supported limit", index))
    }
    index += 1
  }
  if digit_count == 0 {
    return Err(InvalidDecimal("decimal requires at least one digit", 0))
  }
  let coefficient = @bigint.BigInt::from_string(builder.to_string())
  Ok(Decimal::normalize({ coefficient, scale: fractional_digits, }))
}

///|
fn Decimal::scaled_coefficient(self : Decimal, scale : Int32) -> @bigint.BigInt {
  if scale == self.scale {
    self.coefficient
  } else {
    self.coefficient * decimal_pow10(scale - self.scale)
  }
}

///|
pub fn Decimal::compare(self : Decimal, other : Decimal) -> Int32 {
  let scale = if self.scale > other.scale { self.scale } else { other.scale }
  self.scaled_coefficient(scale).compare(other.scaled_coefficient(scale))
}

///|
pub fn Decimal::add(
  self : Decimal,
  other : Decimal,
  offset : Int32,
) -> Result[Decimal, XbrlError] {
  let scale = if self.scale > other.scale { self.scale } else { other.scale }
  decimal_result(
    self.scaled_coefficient(scale) + other.scaled_coefficient(scale),
    scale,
    offset,
  )
}

///|
pub fn Decimal::sub(
  self : Decimal,
  other : Decimal,
  offset : Int32,
) -> Result[Decimal, XbrlError] {
  let scale = if self.scale > other.scale { self.scale } else { other.scale }
  decimal_result(
    self.scaled_coefficient(scale) - other.scaled_coefficient(scale),
    scale,
    offset,
  )
}

///|
pub fn Decimal::mul(
  self : Decimal,
  other : Decimal,
  offset : Int32,
) -> Result[Decimal, XbrlError] {
  decimal_result(
    self.coefficient * other.coefficient,
    self.scale + other.scale,
    offset,
  )
}

///|
pub fn Decimal::neg(self : Decimal) -> Decimal {
  Decimal::normalize({ coefficient: -self.coefficient, scale: self.scale, })
}

///|
pub fn Decimal::is_zero(self : Decimal) -> Bool {
  self.coefficient.is_zero()
}

///|
pub fn Decimal::to_canonical_string(self : Decimal) -> String {
  let normalized = Decimal::normalize(self)
  if normalized.coefficient.is_zero() {
    return "0"
  }
  let negative = normalized.coefficient.compare_int(0) < 0
  let absolute = if negative {
    -normalized.coefficient
  } else {
    normalized.coefficient
  }
  let digits = absolute.to_string()
  let sign = if negative { "-" } else { "" }
  if normalized.scale == 0 {
    sign + digits
  } else if digits.length() > normalized.scale {
    let split = digits.length() - normalized.scale
    sign +
    digits.view(start_offset=0, end_offset=split).to_owned() +
    "." +
    digits.view(start_offset=split).to_owned()
  } else {
    let builder = StringBuilder()
    builder.write_string(sign)
    builder.write_string("0.")
    let mut zeros = normalized.scale - digits.length()
    while zeros > 0 {
      builder.write_char('0')
      zeros -= 1
    }
    builder.write_string(digits)
    builder.to_string()
  }
}

///|
pub fn Decimal::to_scaled_integer(
  self : Decimal,
  scale : Int32,
) -> Result[@bigint.BigInt, XbrlError] {
  if scale < self.scale {
    return Err(
      InvalidDecimal("cannot scale decimal to fewer fractional digits", 0),
    )
  }
  Ok(self.scaled_coefficient(scale))
}

///|
pub extend Decimal with Eq::{not_equal, equal}

///|
pub extend Decimal with @debug.Debug::{to_repr}