primitive_fixed_point_decimal 1.2.0

use crate::{ParseError, Rounding};

use core::{
    fmt,
    mem::MaybeUninit,
    num::{IntErrorKind, ParseIntError},
    ops::{AddAssign, SubAssign},
};

use num_traits::{
    identities::{ConstOne, ConstZero, Zero},
    int::PrimInt,
    ops::wrapping::WrappingAdd,
    Num, SaturatingAdd,
};

/// The trait for underlying representation.
///
/// Normal users don't need to use this trait.
pub trait FpdecInner:
    PrimInt + ConstOne + ConstZero + AddAssign + SubAssign + WrappingAdd + SaturatingAdd + Zero
{
    const MAX: Self;
    const MIN: Self;
    const TEN: Self;
    const MAX_POWERS: Self;
    const DIGITS: u32;
    const NEG_MIN_STR: &'static str;

    /// Used by unsigned_abs() method.
    type Unsigned: FpdecInner + fmt::Display;

    /// For signed types, this should call their unsigned_abs();
    /// for unsigned types, this should return self directly.
    fn unsigned_abs(self) -> Self::Unsigned;

    /// Return 10 to the power of `i`.
    fn get_exp(i: usize) -> Option<Self>;

    /// Calculate `self * b / c`.
    fn calc_mul_div(self, b: Self, c: Self, rounding: Rounding) -> Option<Self>;

    // works only when: diff_scale in range [-Self::DIGITS, Self::DIGITS]
    // diff_scale = scale (self + rhs - result)
    fn checked_mul_ext(self, rhs: Self, diff_scale: i32, rounding: Rounding) -> Option<Self> {
        if diff_scale > 0 {
            // self * rhs / diff_exp

            // If diff_scale is in range [Self::DIGITS+1, Self::DIGITS*2], we
            // could do division twice (with exp[DIGITS] and exp[diff_scale-DIGITS])
            // to avoid returning `None` directly, but that's not enough.
            // Because `MAX * MAX / exp[DIGITS]` still overflows. For
            // simplicity's sake, we do not handle this case which is rare.
            let exp = Self::get_exp(diff_scale as usize)?;
            self.calc_mul_div(rhs, exp, rounding)
        } else if diff_scale < 0 {
            // self * rhs * diff_exp
            let exp = Self::get_exp(-diff_scale as usize)?;
            self.checked_mul(&rhs)?.checked_mul(&exp)
        } else {
            self.checked_mul(&rhs)
        }
    }

    // works only when: diff_scale in range [-Self::DIGITS, Self::DIGITS]
    // diff_scale = scale (self + rhs - result)
    fn checked_div_ext(self, rhs: Self, diff_scale: i32, rounding: Rounding) -> Option<Self> {
        if diff_scale > 0 {
            // self / rhs / diff_exp
            let exp = Self::get_exp(diff_scale as usize)?;
            let q = self.rounding_div(rhs, rounding)?;
            q.rounding_div(exp, rounding)
        } else if diff_scale < 0 {
            // self * diff_exp / rhs

            // If diff_scale is in range [-Self::DIGITS*2, -Self::DIGITS-1], we
            // could do multiplication twice (with exp[DIGITS] and exp[-diff_scale-DIGITS])
            // to avoid returning `None` directly. But keep same with
            // `checked_mul()`, we do not handle this case which is rare.
            let exp = Self::get_exp(-diff_scale as usize)?;
            self.calc_mul_div(exp, rhs, rounding)
        } else {
            self.rounding_div(rhs, rounding)
        }
    }

    // diff_scale = scale (src - dst)
    fn round_diff_with_rounding(self, diff_scale: i32, rounding: Rounding) -> Self {
        if diff_scale <= 0 {
            return self;
        }

        match Self::get_exp(diff_scale as usize) {
            None => Self::ZERO,
            Some(exp) => {
                // self / exp * exp
                self.rounding_div(exp, rounding).unwrap() * exp
            }
        }
    }

    /// Calculate rounding division.
    ///
    /// Examples:
    ///
    /// ```
    /// use primitive_fixed_point_decimal::{FpdecInner, Rounding};
    /// assert_eq!(8.rounding_div(3, Rounding::Floor), Some(2));
    /// assert_eq!(8.rounding_div(3, Rounding::Round), Some(3));
    /// assert_eq!(8.rounding_div(3, Rounding::Ceiling), Some(3));
    /// assert_eq!(8.rounding_div(-3, Rounding::Floor), Some(-3));
    /// assert_eq!(8.rounding_div(-3, Rounding::Round), Some(-3));
    /// assert_eq!(8.rounding_div(-3, Rounding::Ceiling), Some(-2));
    /// assert_eq!(120_i8.rounding_div(121_i8, Rounding::Round), Some(1));
    /// assert_eq!(120_i8.rounding_div(-121_i8, Rounding::Round), Some(-1));
    /// ```
    fn rounding_div(self, b: Self, rounding: Rounding) -> Option<Self> {
        let q = self.checked_div(&b)?;
        let remain = self % b;
        if remain == Self::ZERO {
            return Some(q);
        }

        let ret = if (self ^ b) > Self::ZERO {
            // unsigned types, or signed types and self and b have same sign
            match rounding {
                Rounding::Floor | Rounding::TowardsZero => q,
                Rounding::Ceiling | Rounding::AwayFromZero => q + Self::ONE,
                Rounding::Round => {
                    if remain.saturating_add(remain) >= b {
                        q + Self::ONE
                    } else {
                        q
                    }
                }
            }
        } else {
            // signed types and self and b have different sign.
            match rounding {
                Rounding::Floor | Rounding::AwayFromZero => q - Self::ONE,
                Rounding::Ceiling | Rounding::TowardsZero => q,
                Rounding::Round => {
                    let r = remain.unsigned_abs();
                    if r.saturating_add(&r) >= b.unsigned_abs() {
                        q - Self::ONE
                    } else {
                        q
                    }
                }
            }
        };
        Some(ret)
    }

    // INTERNAL
    // Parse an string as negative.
    // We try to parse it as positive first. If fail for overflow,
    // then it maybe the MIN value.
    fn parse_int_as_negative(s: &str) -> Result<Self, ParseIntError>
    where
        Self: Num<FromStrRadixErr = ParseIntError>,
    {
        match Self::from_str_radix(s, 10) {
            Ok(num) => {
                // Return -num.
                // The FpdecInner works for both signed and unsigned types.
                // But unsigned type does not support negative operation.
                // So we use Two's Complement to calculate negative.
                Ok((!num).wrapping_add(&Self::ONE))
            }
            Err(err) => {
                if err.kind() == &IntErrorKind::PosOverflow
                    && s.trim_start_matches('0') == Self::NEG_MIN_STR
                {
                    Ok(Self::MIN)
                } else {
                    Err(err)
                }
            }
        }
    }

    fn try_from_str(s: &str, scale: i32) -> Result<Self, ParseError>
    where
        Self: Num<FromStrRadixErr = ParseIntError>,
    {
        let (num, raw_scale) = Self::try_from_str_only(s)?;
        if num.is_zero() {
            Ok(num)
        } else if raw_scale == scale {
            Ok(num)
        } else if raw_scale > scale {
            Err(ParseError::Precision)
        } else {
            Self::get_exp((scale - raw_scale) as usize)
                .ok_or(ParseError::Precision)?
                .checked_mul(&num)
                .ok_or(ParseError::Overflow)
        }
    }

    // Guess and return the scale by the input string.
    fn try_from_str_only(s: &str) -> Result<(Self, i32), ParseError>
    where
        Self: Num<FromStrRadixErr = ParseIntError>,
    {
        if s.is_empty() {
            return Err(ParseError::Empty);
        }

        if let Some((int_str, frac_str)) = s.split_once('.') {
            let int_num = Self::from_str_radix(int_str, 10)?;

            let frac_num = if s.as_bytes()[0] == b'-' {
                Self::parse_int_as_negative(frac_str)?
            } else {
                Self::from_str_radix(frac_str, 10)?
            };

            let inner = if int_num.is_zero() {
                // only fraction part
                frac_num
            } else {
                // exp * integer + fraction
                Self::get_exp(frac_str.len())
                    .ok_or(ParseError::Precision)?
                    .checked_mul(&int_num)
                    .ok_or(ParseError::Overflow)?
                    .checked_add(&frac_num)
                    .ok_or(ParseError::Overflow)?
            };
            Ok((inner, frac_str.len() as i32))
        } else {
            // only integer part
            if s == "0" || s == "-0" || s == "+0" {
                return Ok((Self::ZERO, 0));
            }
            let new_int_str = s.trim_end_matches('0');
            let diff = s.len() - new_int_str.len();
            Ok((Self::from_str_radix(new_int_str, 10)?, -(diff as i32)))
        }
    }

    fn display_fmt(self, scale: i32, f: &mut fmt::Formatter) -> fmt::Result {
        if f.width().is_some() {
            // First, dump the number into this buffer, and then call
            // pad_integral() for formatting options.
            //
            // If the number is too long (the scale out of [-1000, 1000]),
            // this will return error, which will make Display panic.
            let mut buf = ArrayWriter::<1050>::new();
            display_num(self.unsigned_abs(), scale, f.precision(), &mut buf)?;
            f.pad_integral(self >= Self::ZERO, "", buf.ref_str())
        } else {
            // Dump the sign and the number directly. Hope this is faster.
            if self < Self::ZERO {
                write!(f, "-")?;
            } else if f.sign_plus() {
                write!(f, "+")?;
            }
            display_num(self.unsigned_abs(), scale, f.precision(), f)
        }
    }

    fn checked_from_int(self, scale: i32) -> Result<Self, ParseError> {
        if scale > 0 {
            let exp = Self::get_exp(scale as usize).ok_or(ParseError::Overflow)?;
            self.checked_mul(&exp).ok_or(ParseError::Overflow)
        } else if scale < 0 {
            let exp = Self::get_exp(-scale as usize).ok_or(ParseError::Precision)?;
            if !(self % exp).is_zero() {
                return Err(ParseError::Precision);
            }
            Ok(self / exp)
        } else {
            Ok(self)
        }
    }
}

// We assume the number is non-negative here. The caller should handle the sign.
fn display_num<I, W>(uns: I, scale: i32, precision: Option<usize>, w: &mut W) -> fmt::Result
where
    I: FpdecInner + fmt::Display,
    W: fmt::Write,
{
    if scale <= 0 {
        write!(w, "{}", uns)?;

        if scale < 0 && !uns.is_zero() {
            let width = (-scale) as usize;
            write!(w, "{:0>width$}", 0)?;
        }

        let precision = precision.unwrap_or(0);
        if precision != 0 {
            write!(w, ".{:0>precision$}", 0)?;
        }

        return Ok(());
    }

    // scale > 0
    let scale = scale as usize;

    // calculate integer and fraction parts
    let (int, frac, exp) = match I::get_exp(scale) {
        Some(exp) => (uns / exp, uns % exp, Some(exp)),
        None => (I::ZERO, uns, None),
    };

    match precision {
        // no precition set, remove fraction tailing zeros
        None => {
            if frac.is_zero() {
                return write!(w, "{}", int);
            }

            // remove fraction tailing zeros
            let (frac, zeros) = {
                let mut zeros = 0;
                let mut n = frac;
                while (n % I::TEN).is_zero() {
                    n = n / I::TEN;
                    zeros += 1;
                }
                (n, zeros)
            };

            write!(w, "{}.{:0>width$}", int, frac, width = scale - zeros)
        }

        // set precision = 0, do not show the '.' char
        Some(precision) if precision == 0 => match exp {
            Some(exp) => {
                if frac.saturating_add(frac) >= exp {
                    write!(w, "{}", int + I::ONE)
                } else {
                    write!(w, "{}", int)
                }
            }
            None => write!(w, "0"),
        },

        // set precision > 0
        Some(precision) => {
            if precision == scale {
                write!(w, "{}.{:0>scale$}", int, frac)
            } else if precision > scale {
                let pad = precision - scale;
                write!(w, "{}.{:0>scale$}{:0>pad$}", int, frac, 0)
            } else {
                let frac = match I::get_exp(scale - precision) {
                    Some(exp) => frac.rounding_div(exp, Rounding::Round).unwrap(),
                    None => I::ZERO,
                };
                write!(w, "{}.{:0>precision$}", int, frac)
            }
        }
    }
}

// A simple stack array writer.
// Used for formatting display.
// It returns error if writing too long, which will make the Display panic.
struct ArrayWriter<const CAP: usize> {
    pos: usize,
    buf: MaybeUninit<[u8; CAP]>,
}

impl<const CAP: usize> ArrayWriter<CAP> {
    fn new() -> Self {
        Self {
            pos: 0,
            buf: MaybeUninit::uninit(),
        }
    }
    fn ref_str(&self) -> &str {
        unsafe {
            // SAFETY: self.pos was updated with self.buf.
            let buf = &self.buf.assume_init_ref()[..self.pos];

            // SAFETY: data was written by Display, so we make sure it's valid.
            str::from_utf8_unchecked(buf)
        }
    }
}

impl<const CAP: usize> fmt::Write for ArrayWriter<CAP> {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        let len = s.len();
        if self.pos + len > CAP {
            return Err(fmt::Error);
        }

        // SAFETY: self.pos was updated with self.buf.
        let buf = unsafe { &mut self.buf.assume_init_mut()[self.pos..self.pos + len] };

        buf.copy_from_slice(s.as_bytes());
        self.pos += len;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    extern crate std;
    use std::fmt;

    struct TestFmt<I> {
        n: I,
        scale: i32,
    }
    impl<I: FpdecInner + fmt::Display> fmt::Display for TestFmt<I> {
        fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
            self.n.display_fmt(self.scale, f)
        }
    }
    fn do_test_format<I>(s: &str, scale: i32, n: I)
    where
        I: FpdecInner + fmt::Display + fmt::Debug + Num<FromStrRadixErr = ParseIntError>,
    {
        //println!("test: {s}, {scale}, {n}");
        assert_eq!(I::try_from_str(s, scale), Ok(n));

        //println!("test: {s} {scale} {n}");
        let (n1, scale1) = I::try_from_str_only(s).unwrap();
        let n2 = n1 * I::TEN.pow((scale - scale1) as u32);
        assert_eq!(n2, n);

        let ts = TestFmt { n, scale };
        assert_eq!(std::format!("{}", &ts), s);
    }

    fn do_test_format_num_only<I>(n: I)
    where
        I: FpdecInner + fmt::Display + fmt::Debug + Num<FromStrRadixErr = ParseIntError>,
    {
        for scale in -100..100 {
            let ts = TestFmt { n, scale };
            let out = std::format!("{}", ts);

            //println!("scale:{scale}, n:{n}, out:{out}");
            assert_eq!(I::try_from_str(&out, scale), Ok(n));
        }
    }

    #[test]
    fn test_format() {
        // empty
        assert_eq!(i8::try_from_str("", 2), Err(ParseError::Empty));

        // zero
        assert_eq!(i8::try_from_str("0", 2), Ok(0));
        assert_eq!(i8::try_from_str("0.0", 2), Ok(0));
        assert_eq!(i8::try_from_str("-0", 2), Ok(0));
        assert_eq!(i8::try_from_str("-0.0", 2), Ok(0));
        assert_eq!(i8::try_from_str("+0", 2), Ok(0));
        assert_eq!(i8::try_from_str("+0.0", 2), Ok(0));

        // positive
        do_test_format("12300", -2, 123_i8);
        do_test_format("1230", -1, 123_i8);
        do_test_format("123", 0, 123_i8);
        do_test_format("12.3", 1, 123_i8);
        do_test_format("1.23", 2, 123_i8);
        do_test_format("0.123", 3, 123_i8);
        do_test_format("0.0123", 4, 123_i8);
        do_test_format("0.00123", 5, 123_i8);
        do_test_format("0.000123", 6, 123_i8);

        do_test_format("12000", -2, 120_i8);
        do_test_format("1200", -1, 120_i8);
        do_test_format("120", 0, 120_i8);
        do_test_format("12", 1, 120_i8);
        do_test_format("1.2", 2, 120_i8);
        do_test_format("0.12", 3, 120_i8);
        do_test_format("0.012", 4, 120_i8);
        do_test_format("0.0012", 5, 120_i8);
        do_test_format("0.00012", 6, 120_i8);

        // negative with i8::MIN
        do_test_format("-12800", -2, -128_i8);
        do_test_format("-1280", -1, -128_i8);
        do_test_format("-128", 0, -128_i8);
        do_test_format("-12.8", 1, -128_i8);
        do_test_format("-1.28", 2, -128_i8);
        do_test_format("-0.128", 3, -128_i8);
        do_test_format("-0.0128", 4, -128_i8);
        do_test_format("-0.00128", 5, -128_i8);
        do_test_format("-0.000128", 6, -128_i8);

        // u8
        // positive
        do_test_format("12300", -2, 123_u8);
        do_test_format("1230", -1, 123_u8);
        do_test_format("123", 0, 123_u8);
        do_test_format("12.3", 1, 123_u8);
        do_test_format("1.23", 2, 123_u8);
        do_test_format("0.123", 3, 123_u8);
        do_test_format("0.0123", 4, 123_u8);
        do_test_format("0.00123", 5, 123_u8);
        do_test_format("0.000123", 6, 123_u8);

        do_test_format("12000", -2, 120_u8);
        do_test_format("1200", -1, 120_u8);
        do_test_format("120", 0, 120_u8);
        do_test_format("12", 1, 120_u8);
        do_test_format("1.2", 2, 120_u8);
        do_test_format("0.12", 3, 120_u8);
        do_test_format("0.012", 4, 120_u8);
        do_test_format("0.0012", 5, 120_u8);
        do_test_format("0.00012", 6, 120_u8);

        do_test_format("25500", -2, 255_u8);
        do_test_format("2550", -1, 255_u8);
        do_test_format("255", 0, 255_u8);
        do_test_format("25.5", 1, 255_u8);
        do_test_format("2.55", 2, 255_u8);
        do_test_format("0.255", 3, 255_u8);
        do_test_format("0.0255", 4, 255_u8);
        do_test_format("0.00255", 5, 255_u8);
        do_test_format("0.000255", 6, 255_u8);
    }

    #[test]
    fn test_format_num_only() {
        do_test_format_num_only(0);
        do_test_format_num_only(1_u8);
        do_test_format_num_only(12_u8);
        do_test_format_num_only(123_u8);
        do_test_format_num_only(255_u8);
        do_test_format_num_only(1_i8);
        do_test_format_num_only(12_i8);
        do_test_format_num_only(123_i8);
        do_test_format_num_only(-1_i8);
        do_test_format_num_only(-12_i8);
        do_test_format_num_only(-123_i8);
        do_test_format_num_only(-128_i8);

        do_test_format_num_only(1_i128);
        do_test_format_num_only(12_i128);
        do_test_format_num_only(123_i128);
        do_test_format_num_only(-1_i128);
        do_test_format_num_only(-12_i128);
        do_test_format_num_only(-123_i128);

        do_test_format_num_only(i32::MAX);
        do_test_format_num_only(i32::MIN);
        do_test_format_num_only(i64::MAX);
        do_test_format_num_only(i64::MIN);
        do_test_format_num_only(i128::MAX);
        do_test_format_num_only(i128::MIN);
        do_test_format_num_only(i32::MAX / 2);
        do_test_format_num_only(i32::MIN / 2);
        do_test_format_num_only(i64::MAX / 2);
        do_test_format_num_only(i64::MIN / 2);
        do_test_format_num_only(i128::MAX / 2);
        do_test_format_num_only(i128::MIN / 2);

        do_test_format_num_only(1_u128);
        do_test_format_num_only(12_u128);
        do_test_format_num_only(123_u128);

        do_test_format_num_only(u32::MAX);
        do_test_format_num_only(u64::MAX);
        do_test_format_num_only(u128::MAX);
        do_test_format_num_only(u32::MAX / 2);
        do_test_format_num_only(u64::MAX / 2);
        do_test_format_num_only(u128::MAX / 2);
    }

    #[test]
    fn test_options() {
        let d = TestFmt {
            n: 12_3470,
            scale: 4,
        };
        let d2 = TestFmt {
            n: 12_5470,
            scale: 4,
        };
        let n = TestFmt {
            n: -12_3470,
            scale: 4,
        };
        let z = TestFmt { n: 0, scale: 4 };

        assert_eq!(std::format!("{}", &d), "12.347");
        assert_eq!(std::format!("{}", &n), "-12.347");
        assert_eq!(std::format!("{}", &z), "0");

        // width, fill, alignment
        assert_eq!(std::format!("{:x>10}", &d), "xxxx12.347");
        assert_eq!(std::format!("{:0>10}", &d), "000012.347");
        assert_eq!(std::format!("{:x>10}", &n), "xxx-12.347");
        assert_eq!(std::format!("{:010}", &n), "-00012.347");

        // precision
        assert_eq!(std::format!("{:.0}", &d), "12");
        assert_eq!(std::format!("{:.0}", &d2), "13");
        assert_eq!(std::format!("{:.2}", &d), "12.35");
        assert_eq!(std::format!("{:.4}", &d), "12.3470");
        assert_eq!(std::format!("{:.6}", &d), "12.347000");
        assert_eq!(std::format!("{:.0}", &n), "-12");
        assert_eq!(std::format!("{:.2}", &n), "-12.35");
        assert_eq!(std::format!("{:.4}", &n), "-12.3470");
        assert_eq!(std::format!("{:.6}", &n), "-12.347000");
        assert_eq!(std::format!("{:.0}", &z), "0");
        assert_eq!(std::format!("{:.2}", &z), "0.00");
        assert_eq!(std::format!("{:.4}", &z), "0.0000");
        assert_eq!(std::format!("{:.6}", &z), "0.000000");

        // sign
        assert_eq!(std::format!("{:+}", &d), "+12.347");
        assert_eq!(std::format!("{:+}", &n), "-12.347");
        assert_eq!(std::format!("{:+}", &z), "+0");

        // all
        assert_eq!(std::format!("{:x>+10.2}", &d), "xxxx+12.35");
        assert_eq!(std::format!("{:+010.2}", &d), "+000012.35");

        // neg-scale
        let d = TestFmt { n: 12, scale: -4 };
        assert_eq!(std::format!("{}", &d), "120000");
        assert_eq!(std::format!("{:.0}", &d), "120000");
        assert_eq!(std::format!("{:.2}", &d), "120000.00");
    }
}