// Copyright (c) 2019-2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module decimal

import math.big
import strings

// default_division_precision is used by the `/` operator when the quotient
// needs a rounded decimal expansion.
pub const default_division_precision = 16

// zero is the canonical zero value for Decimal.
pub const zero = Decimal{
	coefficient_value: big.zero_int
	scale_value:       0
}

// Decimal represents an arbitrary-precision fixed-point decimal value.
// Its numeric value is `coefficient * 10^-scale`.
pub struct Decimal {
	coefficient_value big.Integer
	scale_value       int
}

// new creates a decimal from `coefficient * 10^-scale`.
pub fn new(coefficient big.Integer, scale int) Decimal {
	if scale < 0 {
		panic('math.decimal: scale cannot be negative')
	}
	return normalize(coefficient, scale)
}

// from_int creates a decimal from an int.
pub fn from_int(value int) Decimal {
	return Decimal{
		coefficient_value: big.integer_from_int(value)
		scale_value:       0
	}
}

// from_i64 creates a decimal from an i64.
pub fn from_i64(value i64) Decimal {
	return Decimal{
		coefficient_value: big.integer_from_i64(value)
		scale_value:       0
	}
}

// from_u64 creates a decimal from a u64.
pub fn from_u64(value u64) Decimal {
	return Decimal{
		coefficient_value: big.integer_from_u64(value)
		scale_value:       0
	}
}

// from_string parses a decimal string without exponent notation.
pub fn from_string(input string) !Decimal {
	value := input.trim_space()
	if value.len == 0 {
		return error('math.decimal: empty input')
	}
	mut negative := false
	mut seen_dot := false
	mut digit_count := 0
	mut scale := 0
	mut digits := strings.new_builder(value.len)
	for index, ch in value {
		if index == 0 && (ch == `+` || ch == `-`) {
			negative = ch == `-`
			continue
		}
		if ch >= `0` && ch <= `9` {
			digits.write_u8(ch)
			digit_count++
			if seen_dot {
				scale++
			}
			continue
		}
		if ch == `.` && !seen_dot {
			seen_dot = true
			continue
		}
		return error('math.decimal: invalid decimal value `${input}`')
	}
	if digit_count == 0 {
		return error('math.decimal: invalid decimal value `${input}`')
	}
	mut coefficient_string := digits.str()
	if negative {
		coefficient_string = '-' + coefficient_string
	}
	coefficient := big.integer_from_string(coefficient_string)!
	return new(coefficient, scale)
}

// coefficient returns the integer coefficient stored by `d`.
pub fn (d Decimal) coefficient() big.Integer {
	return d.coefficient_value
}

// scale returns the number of decimal places stored by `d`.
pub fn (d Decimal) scale() int {
	return d.scale_value
}

// is_zero returns true when `d == 0`.
pub fn (d Decimal) is_zero() bool {
	return d.coefficient_value.signum == 0
}

// abs returns the absolute value of `d`.
pub fn (d Decimal) abs() Decimal {
	return Decimal{
		coefficient_value: d.coefficient_value.abs()
		scale_value:       d.scale_value
	}
}

// neg returns the negated value of `d`.
pub fn (d Decimal) neg() Decimal {
	return Decimal{
		coefficient_value: d.coefficient_value.neg()
		scale_value:       d.scale_value
	}
}

// str returns the canonical decimal representation of `d`.
pub fn (d Decimal) str() string {
	if d.coefficient_value.signum == 0 {
		return '0'
	}
	if d.scale_value == 0 {
		return d.coefficient_value.str()
	}
	mut prefix := ''
	if d.coefficient_value.signum < 0 {
		prefix = '-'
	}
	absolute := d.coefficient_value.abs().str()
	if d.scale_value >= absolute.len {
		padding := strings.repeat(`0`, d.scale_value - absolute.len)
		return '${prefix}0.${padding}${absolute}'
	}
	split := absolute.len - d.scale_value
	return '${prefix}${absolute[..split]}.${absolute[split..]}'
}

// + returns the exact sum of `left` and `right`.
pub fn (left Decimal) + (right Decimal) Decimal {
	scale := max_scale(left.scale_value, right.scale_value)
	return new(left.rescaled_coefficient(scale) + right.rescaled_coefficient(scale), scale)
}

// - returns the exact difference of `left` and `right`.
pub fn (left Decimal) - (right Decimal) Decimal {
	scale := max_scale(left.scale_value, right.scale_value)
	return new(left.rescaled_coefficient(scale) - right.rescaled_coefficient(scale), scale)
}

// * returns the exact product of `left` and `right`.
pub fn (left Decimal) * (right Decimal) Decimal {
	return new(left.coefficient_value * right.coefficient_value, left.scale_value +
		right.scale_value)
}

// / divides `dividend` by `divisor` using `default_division_precision`.
pub fn (dividend Decimal) / (divisor Decimal) Decimal {
	return dividend.div_prec(divisor, default_division_precision) or { panic(err) }
}

// div_prec divides `dividend` by `divisor` and rounds half up to `precision`
// digits after the decimal point.
pub fn (dividend Decimal) div_prec(divisor Decimal, precision int) !Decimal {
	if precision < 0 {
		return error('math.decimal: precision cannot be negative')
	}
	if divisor.coefficient_value.signum == 0 {
		return error('math.decimal: cannot divide by zero')
	}
	mut quotient, remainder := scaled_div_mod(dividend, divisor, precision)
	if remainder.signum != 0 {
		twice_remainder := remainder * big.two_int
		if !(twice_remainder < scaled_divisor(dividend, divisor)) {
			quotient += big.one_int
		}
	}
	if dividend.coefficient_value.signum * divisor.coefficient_value.signum < 0 {
		quotient = quotient.neg()
	}
	return new(quotient, precision)
}

// == returns true when `left` and `right` represent the same value.
pub fn (left Decimal) == (right Decimal) bool {
	return left.scale_value == right.scale_value
		&& left.coefficient_value == right.coefficient_value
}

// < returns true when `left` is smaller than `right`.
pub fn (left Decimal) < (right Decimal) bool {
	scale := max_scale(left.scale_value, right.scale_value)
	return left.rescaled_coefficient(scale) < right.rescaled_coefficient(scale)
}

fn normalize(coefficient big.Integer, scale int) Decimal {
	if coefficient.signum == 0 {
		return zero
	}
	mut normalized_coefficient := coefficient
	mut normalized_scale := scale
	for normalized_scale > 0 {
		quotient, remainder := normalized_coefficient.div_mod(big.c10)
		if remainder.signum != 0 {
			break
		}
		normalized_coefficient = quotient
		normalized_scale--
	}
	return Decimal{
		coefficient_value: normalized_coefficient
		scale_value:       normalized_scale
	}
}

fn (d Decimal) rescaled_coefficient(scale int) big.Integer {
	if scale <= d.scale_value || d.coefficient_value.signum == 0 {
		return d.coefficient_value
	}
	return d.coefficient_value * pow10(scale - d.scale_value)
}

fn pow10(exponent int) big.Integer {
	if exponent <= 0 {
		return big.one_int
	}
	return big.c10.pow(u32(exponent))
}

fn scaled_divisor(dividend Decimal, divisor Decimal) big.Integer {
	return divisor.coefficient_value.abs() * pow10(dividend.scale_value)
}

fn scaled_div_mod(dividend Decimal, divisor Decimal, precision int) (big.Integer, big.Integer) {
	numerator := dividend.coefficient_value.abs() * pow10(divisor.scale_value + precision)
	return numerator.div_mod(scaled_divisor(dividend, divisor))
}

fn max_scale(a int, b int) int {
	if a > b {
		return a
	}
	return b
}