ranch 0.6.0

use core::num::NonZero;

use as_repr::AsRepr;

use crate::{Error, Quotient, RangedI64, RangedU32, Result};

/// [`i64`] not to equal zero with a specified minimum and maximum value
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(transparent)]
pub struct RangedNonZeroI64<const MIN: i64, const MAX: i64>(
    pub(crate) NonZero<i64>,
);

impl<const MIN: i64, const MAX: i64> RangedNonZeroI64<MIN, MAX> {
    /// The size of this integer type in bits.
    pub const BITS: u32 = i64::BITS;
    /// The largest value that can be represented by this integer type.
    pub const MAX: Self = Self::new::<MAX>();
    /// The smallest value that can be represented by this integer type.
    pub const MIN: Self = Self::new::<MIN>();

    /// Create a new ranged integer.
    ///
    /// Won't compile if out of bounds.
    ///
    /// Compiles:
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// RangedNonZeroI64::<-1, 3>::new::<1>();
    /// RangedNonZeroI64::<-1, 3>::new::<2>();
    /// RangedNonZeroI64::<-1, 3>::new::<3>();
    /// ```
    ///
    /// Does not compile:
    ///
    /// ```compile_fail
    /// RangedNonZeroI64::<-1, 3>::new::<-2>();
    /// ```
    ///
    /// ```compile_fail
    /// RangedNonZeroI64::<-1, 3>::new::<0>();
    /// ```
    ///
    /// ```compile_fail
    /// RangedNonZeroI64::<-1, 3>::new::<4>();
    /// ```
    #[must_use]
    pub const fn new<const N: i64>() -> Self {
        const {
            Self::assert_range();

            if N < MIN || N > MAX {
                panic!("Out of bounds");
            }

            Self(NonZero::new(N).unwrap())
        }
    }

    /// Try to create a new ranged integer.
    ///
    /// Returns `Err` if out of bounds, `Ok(None)` if zero.
    ///
    /// ```rust
    /// # use ranch::{RangedNonZeroI64, Error};
    /// RangedNonZeroI64::<-1, 1>::with_i64(-1).unwrap().unwrap();
    /// RangedNonZeroI64::<-1, 1>::with_i64(1).unwrap().unwrap();
    /// assert_eq!(RangedNonZeroI64::<-1, 1>::with_i64(0), Ok(None));
    /// assert_eq!(RangedNonZeroI64::<-1, 1>::with_i64(-2).unwrap_err(), Error::NegOverflow);
    /// assert_eq!(RangedNonZeroI64::<-1, 1>::with_i64(2).unwrap_err(), Error::PosOverflow);
    /// ```
    pub const fn with_i64(value: impl AsRepr<i64>) -> Result<Option<Self>> {
        const { Self::assert_range() };

        let value = as_repr::as_repr(value);
        let Some(value) = NonZero::new(value) else {
            return Ok(None);
        };

        match Self::with_nonzero(value) {
            Ok(v) => Ok(Some(v)),
            Err(e) => Err(e),
        }
    }

    /// Convert from [`NonZero`].
    ///
    /// ```rust
    /// # use std::num::NonZero;
    /// # use ranch::RangedNonZeroI64;
    /// assert_eq!(
    ///     RangedNonZeroI64::<1, 100>::with_nonzero(NonZero::new(42).unwrap()).unwrap(),
    ///     RangedNonZeroI64::<1, 100>::new::<42>(),
    /// );
    /// ```
    pub const fn with_nonzero(
        nonzero: impl AsRepr<NonZero<i64>>,
    ) -> Result<Self> {
        const { Self::assert_range() };

        let nonzero = as_repr::as_repr(nonzero);

        if nonzero.get() < MIN {
            return Err(Error::NegOverflow);
        }

        if nonzero.get() > MAX {
            return Err(Error::PosOverflow);
        }

        Ok(Self(nonzero))
    }

    /// Return the contained value as a primitive type.
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// assert_eq!(42, RangedNonZeroI64::<1, 100>::new::<42>().get());
    /// ```
    #[must_use]
    pub const fn get(self) -> i64 {
        self.0.get()
    }

    /// Convert to [`NonZero`].
    ///
    /// ```rust
    /// # use std::num::NonZero;
    /// # use ranch::RangedNonZeroI64;
    /// assert_eq!(
    ///     NonZero::new(42).unwrap(),
    ///     RangedNonZeroI64::<1, 100>::new::<42>().to_nonzero(),
    /// );
    /// ```
    #[must_use]
    pub const fn to_nonzero(self) -> NonZero<i64> {
        self.0
    }

    /// Convert to [`RangedI64`].
    ///
    /// ```rust
    /// # use ranch::{RangedNonZeroI64, RangedI64};
    /// assert_eq!(
    ///     RangedI64::<1, 100>::new::<42>(),
    ///     RangedNonZeroI64::<1, 100>::new::<42>().to_ranged(),
    /// );
    /// ```
    #[must_use]
    pub const fn to_ranged(self) -> RangedI64<MIN, MAX> {
        RangedI64(self.get())
    }

    /// Return the number of leading zeros in the binary representation of
    /// `self`.
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// let n = RangedNonZeroI64::<{ i64::MIN }, { i64::MAX }>::MAX;
    ///
    /// assert_eq!(n.leading_zeros().get(), 1);
    /// ```
    #[must_use]
    pub const fn leading_zeros(self) -> RangedU32<0, { i64::BITS }> {
        RangedU32(self.get().leading_zeros())
    }

    /// Return the number of trailing zeros in the binary representation of
    /// `self`.
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// let n = RangedNonZeroI64::<-128, 127>::new::<0b0101000>();
    ///
    /// assert_eq!(n.trailing_zeros().get(), 3);
    /// ```
    #[must_use]
    pub const fn trailing_zeros(self) -> RangedU32<0, { i64::BITS }> {
        RangedU32(self.get().trailing_zeros())
    }

    /// Return the number of ones in the binary representation of `self`.
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// let a = RangedNonZeroI64::<-128, 127>::new::<0b100_0000>();
    /// let b = RangedNonZeroI64::<-128, 127>::new::<0b100_0011>();
    ///
    /// assert_eq!(a.count_ones().get(), 1);
    /// assert_eq!(b.count_ones().get(), 3);
    /// ```
    #[must_use]
    pub const fn count_ones(self) -> RangedU32<0, { i64::BITS }> {
        RangedU32(self.get().count_ones())
    }

    /// Add two ranged integers together.
    ///
    /// Returns an [`Error`] on overflow.
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// let a = RangedNonZeroI64::<1, 100>::new::<50>();
    /// let b = RangedNonZeroI64::<1, 100>::new::<5>();
    /// let c = a.checked_add(b).unwrap().unwrap();
    ///
    /// assert!(c.checked_add(a).is_err());
    /// assert_eq!(c.get(), 55);
    /// assert_eq!(a.checked_add(a).unwrap().unwrap().get(), 100);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    pub const fn checked_add(
        self,
        other: impl AsRepr<i64>,
    ) -> Result<Option<Self>> {
        match self.to_ranged().checked_add(other) {
            Ok(value) => Ok(value.to_ranged_nonzero()),
            Err(e) => Err(e),
        }
    }

    /// Multiply two ranged integers together.
    ///
    /// Returns an [`Error`] on overflow.
    ///
    /// ```rust
    /// # use ranch::{Error, RangedNonZeroI64};
    /// let a = RangedNonZeroI64::<-100, 100>::new::<50>();
    /// let b = RangedNonZeroI64::<-100, 100>::new::<5>();
    /// let c = RangedNonZeroI64::<-100, 100>::new::<-75>();
    ///
    /// assert_eq!(b.checked_mul(b).unwrap().unwrap().get(), 25);
    /// assert_eq!(a.checked_mul(c).unwrap_err(), Error::NegOverflow);
    /// assert_eq!(c.checked_mul(c).unwrap_err(), Error::PosOverflow);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    pub const fn checked_mul(
        self,
        other: impl AsRepr<i64>,
    ) -> Result<Option<Self>> {
        match self.to_ranged().checked_mul(other) {
            Ok(value) => Ok(value.to_ranged_nonzero()),
            Err(e) => Err(e),
        }
    }

    /// Raise to an integer power.
    ///
    /// Returns an [`Error`] on overflow.
    ///
    /// ```rust
    /// # use ranch::{Error, RangedNonZeroI64};
    /// let a = RangedNonZeroI64::<-100, 100>::new::<50>();
    /// let b = RangedNonZeroI64::<-100, 100>::new::<5>();
    /// let c = RangedNonZeroI64::<-100, 100>::new::<-75>();
    /// let d = RangedNonZeroI64::<-100, 100>::new::<2>();
    ///
    /// assert_eq!(a.checked_pow(2).unwrap_err(), Error::PosOverflow);
    /// assert_eq!(b.checked_pow(2).unwrap().get(), 25);
    /// assert_eq!(c.checked_pow(3).unwrap_err(), Error::NegOverflow);
    /// assert_eq!(d.checked_pow(3).unwrap().get(), 8);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    pub const fn checked_pow(self, other: impl AsRepr<u32>) -> Result<Self> {
        match self.to_ranged().checked_pow(other) {
            Ok(value) => Ok(value.to_ranged_nonzero().unwrap()),
            Err(e) => Err(e),
        }
    }

    /// Checked integer division.
    ///
    /// Returns an [`Error`] on overflow; [`Quotient::Nan`] if `rhs == 0`.
    ///
    /// ```rust
    /// # use ranch::{Error, RangedNonZeroI64, Quotient};
    /// let a = RangedNonZeroI64::<-100, 10>::new::<-50>();
    /// let b = RangedNonZeroI64::<-10, 100>::new::<50>();
    ///
    /// assert_eq!(
    ///     a.checked_div(2),
    ///     Ok(Some(Quotient::Number(RangedNonZeroI64::new::<-25>()))),
    /// );
    /// assert_eq!(a.checked_div(0), Ok(Some(Quotient::Nan)));
    /// assert_eq!(a.checked_div(-1), Err(Error::PosOverflow));
    /// assert_eq!(b.checked_div(-2), Err(Error::NegOverflow));
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    pub const fn checked_div(
        self,
        rhs: impl AsRepr<i64>,
    ) -> Result<Option<Quotient<Self>>> {
        let value = match self.to_ranged().checked_div(rhs) {
            Ok(value) => value,
            Err(e) => return Err(e),
        };
        let Quotient::Number(number) = value else {
            return Ok(Some(Quotient::Nan));
        };
        let Some(number) = number.to_ranged_nonzero() else {
            return Ok(None);
        };

        Ok(Some(Quotient::Number(number)))
    }

    /// Subtract a ranged integers from another.
    ///
    /// Returns an [`Error`] on overflow.
    ///
    /// ```rust
    /// # use ranch::{Error, RangedNonZeroI64};
    /// let a = RangedNonZeroI64::<1, 100>::new::<50>();
    /// let b = a.checked_sub(5).unwrap().unwrap();
    ///
    /// assert_eq!(a.checked_sub(-51), Err(Error::PosOverflow));
    /// assert_eq!(b.get(), 45);
    /// assert_eq!(a.checked_sub(a), Err(Error::NegOverflow));
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    pub const fn checked_sub(
        self,
        other: impl AsRepr<i64>,
    ) -> Result<Option<Self>> {
        match self.to_ranged().checked_sub(other) {
            Ok(value) => Ok(value.to_ranged_nonzero()),
            Err(e) => Err(e),
        }
    }

    /// Return `true` if `self` is negative; `false` if zero or positive.
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// assert!(!RangedNonZeroI64::<-100, 100>::new::<10>().is_negative());
    /// assert!(RangedNonZeroI64::<-100, 100>::new::<-10>().is_negative());
    /// ```
    #[must_use]
    pub const fn is_negative(self) -> bool {
        self.get().is_negative()
    }

    /// Return `true` if `self` is positive; `false` if zero or negative.
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// assert!(RangedNonZeroI64::<-100, 100>::new::<10>().is_positive());
    /// assert!(!RangedNonZeroI64::<-100, 100>::new::<-10>().is_positive());
    /// ```
    #[must_use]
    pub const fn is_positive(self) -> bool {
        self.get().is_positive()
    }

    /// Multiply two numbers together.
    ///
    /// ```rust
    /// # use ranch::RangedNonZeroI64;
    /// let a = RangedNonZeroI64::<-2, 3>::new::<1>();
    /// let b = RangedNonZeroI64::<-1, 3>::new::<2>();
    /// let output: RangedNonZeroI64::<-6, 9> = a.mul_ranged(b);
    ///
    /// assert_eq!(output.get(), 2);
    /// ```
    ///
    /// Does not compile:
    ///
    /// ```compile_fail
    /// # use ranch::RangedNonZeroI64;
    /// let a = RangedNonZeroI64::<-2, 3>::new::<1>();
    /// let b = RangedNonZeroI64::<-1, 3>::new::<2>();
    /// let output: RangedNonZeroI64::<0, 9> = a.mul_ranged(b);
    ///
    /// assert_eq!(output.get(), 2);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    pub const fn mul_ranged<
        const RHS_MIN: i64,
        const RHS_MAX: i64,
        const OUTPUT_MIN: i64,
        const OUTPUT_MAX: i64,
    >(
        self,
        rhs: RangedNonZeroI64<RHS_MIN, RHS_MAX>,
    ) -> RangedNonZeroI64<OUTPUT_MIN, OUTPUT_MAX> {
        self.to_ranged()
            .mul_ranged::<RHS_MIN, RHS_MAX, OUTPUT_MIN, OUTPUT_MAX>(
                rhs.to_ranged(),
            )
            .to_ranged_nonzero()
            .unwrap()
    }

    /// Raise to an integer power.
    ///
    /// ```rust
    /// # use ranch::{RangedNonZeroI64, RangedU32};
    /// let a = RangedNonZeroI64::<-1, 3>::new::<2>();
    /// let b = RangedU32::<2, 3>::new::<2>();
    /// let output: RangedNonZeroI64::<-1, 27> = a.pow_ranged(b);
    ///
    /// assert_eq!(output.get(), 4);
    /// ```
    ///
    /// Does not compile:
    ///
    /// ```compile_fail
    /// # use ranch::{RangedNonZeroI64, RangedU32};
    /// let a = RangedNonZeroI64::<1, 3>::new::<2>();
    /// let b = RangedU32::<2, 3>::new::<2>();
    /// let output: RangedNonZeroI64::<0, 27> = a.pow_ranged(b);
    ///
    /// assert_eq!(output.get(), 4);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    pub const fn pow_ranged<
        const RHS_MIN: u32,
        const RHS_MAX: u32,
        const OUTPUT_MIN: i64,
        const OUTPUT_MAX: i64,
    >(
        self,
        rhs: RangedU32<RHS_MIN, RHS_MAX>,
    ) -> RangedNonZeroI64<OUTPUT_MIN, OUTPUT_MAX> {
        self.to_ranged()
            .pow_ranged::<RHS_MIN, RHS_MAX, OUTPUT_MIN, OUTPUT_MAX>(rhs)
            .to_ranged_nonzero()
            .unwrap()
    }
}

impl<const MIN: i64, const MAX: i64> crate::error::Clamp
    for RangedNonZeroI64<MIN, MAX>
{
    const MAX: Self = Self::MAX;
    const MIN: Self = Self::MIN;
}