// This file is part of ICU4X. For terms of use, please see the file

// called LICENSE at the top level of the ICU4X source tree

// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

pub(crate) trait MaybeSplitAt<T> {

    /// Like slice::split_at but returns an Option instead of panicking

    /// if the index is out of range.

    fn maybe_split_at(&self, mid: usize) -> Option<(&Self, &Self)>;

    /// Like slice::split_at but debug-panics and returns an empty second slice

    /// if the index is out of range.

    fn debug_split_at(&self, mid: usize) -> (&Self, &Self);

}

impl<T> MaybeSplitAt<T> for [T] {

    #[inline]

    fn maybe_split_at(&self, mid: usize) -> Option<(&Self, &Self)> {

        if mid > self.len() {

            None

        } else {

            // Note: We're trusting the compiler to inline this and remove the assertion

            // hiding on the top of slice::split_at: `assert(mid <= self.len())`

            Some(self.split_at(mid))

        }

    }

Unexecuted instantiation: <[u8] as zerotrie::helpers::MaybeSplitAt<u8>>::maybe_split_at

Unexecuted instantiation: <[_] as zerotrie::helpers::MaybeSplitAt<_>>::maybe_split_at

    #[inline]

    fn debug_split_at(&self, mid: usize) -> (&Self, &Self) {

        if mid > self.len() {

            debug_assert!(false, "debug_split_at: index expected to be in range");

            (self, &[])

        } else {

            // Note: We're trusting the compiler to inline this and remove the assertion

            // hiding on the top of slice::split_at: `assert(mid <= self.len())`

            self.split_at(mid)

        }

    }

}

pub(crate) trait DebugUnwrapOr<T> {

    /// Unwraps the option or panics in debug mode, returning the `gigo_value`

    fn debug_unwrap_or(self, gigo_value: T) -> T;

}

impl<T> DebugUnwrapOr<T> for Option<T> {

    #[inline]

    fn debug_unwrap_or(self, gigo_value: T) -> T {

        match self {

            Some(x) => x,

            None => {

                debug_assert!(false, "debug_unwrap_or called on a None value");

                gigo_value

            }

        }

    }

Unexecuted instantiation: <core::option::Option<&[u8]> as zerotrie::helpers::DebugUnwrapOr<&[u8]>>::debug_unwrap_or

Unexecuted instantiation: <core::option::Option<&u8> as zerotrie::helpers::DebugUnwrapOr<&u8>>::debug_unwrap_or

}

macro_rules! debug_unwrap {

    ($expr:expr, return $retval:expr, $($arg:tt)+) => {

        match $expr {

            Some(x) => x,

            None => {

                debug_assert!(false, $($arg)*);

                return $retval;

            }

        }

    };

    ($expr:expr, return $retval:expr) => {

        debug_unwrap!($expr, return $retval, "invalid trie")

    };

    ($expr:expr, break, $($arg:tt)+) => {

        match $expr {

            Some(x) => x,

            None => {

                debug_assert!(false, $($arg)*);

                break;

            }

        }

    };

    ($expr:expr, break) => {

        debug_unwrap!($expr, break, "invalid trie")

    };

    ($expr:expr, $($arg:tt)+) => {

        debug_unwrap!($expr, return (), $($arg)*)

    };

    ($expr:expr) => {

        debug_unwrap!($expr, return ())

    };

}

pub(crate) use debug_unwrap;

/// The maximum number of base-10 digits required for rendering a usize.

/// Note: 24/10 is an approximation of 8*log10(2)

pub(crate) const MAX_USIZE_LEN_AS_DIGITS: usize = core::mem::size_of::<usize>() * 24 / 10 + 1;

/// Formats a usize as a string of length N, padded with spaces,

/// with the given prefix.

///

/// If the string is too short, the function may panic. To prevent

/// this, N should be MAX_USIZE_LEN_AS_DIGITS larger than M.

pub(crate) const fn const_fmt_int<const M: usize, const N: usize>(

    prefix: [u8; M],

    value: usize,

) -> [u8; N] {

    let mut output = [b' '; N];

    let mut i = 0;

    while i < M {

        output[i] = prefix[i];

        i += 1;

    }

    let mut int_only = [b' '; MAX_USIZE_LEN_AS_DIGITS];

    let mut value = value;

    let mut i = MAX_USIZE_LEN_AS_DIGITS - 1;

    loop {

        let x = (value % 10) as u8;

        int_only[i] = x + b'0';

        value /= 10;

        if value == 0 {

            break;

        }

        i -= 1;

    }

    let mut j = M;

    while i < MAX_USIZE_LEN_AS_DIGITS {

        output[j] = int_only[i];

        j += 1;

        i += 1;

    }

    output

}

#[test]

fn test_const_fmt_int() {

    assert_eq!(*b"123", const_fmt_int::<0, 3>(*b"", 123));

    assert_eq!(*b"123   ", const_fmt_int::<0, 6>(*b"", 123));

    assert_eq!(*b"abc123", const_fmt_int::<3, 6>(*b"abc", 123));

}