/*!

Provides convenience routines for escaping raw bytes.

This was copied from `regex-automata` with a few light edits.

*/

use super::utf8;

/// Provides a convenient `Debug` implementation for a `u8`.

///

/// The `Debug` impl treats the byte as an ASCII, and emits a human

/// readable representation of it. If the byte isn't ASCII, then it's

/// emitted as a hex escape sequence.

#[derive(Clone, Copy)]

pub(crate) struct Byte(pub u8);

impl core::fmt::Display for Byte {

    #[inline(never)]

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        if self.0 == b' ' {

            return f.write_str(" ");

        }

        // 10 bytes is enough for any output from ascii::escape_default.

        let mut bytes = [0u8; 10];

        let mut len = 0;

        for (i, mut b) in core::ascii::escape_default(self.0).enumerate() {

            // capitalize \xab to \xAB

            if i >= 2 && b'a' <= b && b <= b'f' {

                b -= 32;

            }

            bytes[len] = b;

            len += 1;

        }

        f.write_str(core::str::from_utf8(&bytes[..len]).unwrap())

    }

}

impl core::fmt::Debug for Byte {

    #[inline(never)]

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        f.write_str("\"")?;

        core::fmt::Display::fmt(self, f)?;

        f.write_str("\"")?;

        Ok(())

    }

}

/// Provides a convenient `Debug` implementation for `&[u8]`.

///

/// This generally works best when the bytes are presumed to be mostly

/// UTF-8, but will work for anything. For any bytes that aren't UTF-8,

/// they are emitted as hex escape sequences.

#[derive(Clone, Copy)]

pub(crate) struct Bytes<'a>(pub &'a [u8]);

impl<'a> core::fmt::Display for Bytes<'a> {

    #[inline(never)]

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        // This is a sad re-implementation of a similar impl found in bstr.

        let mut bytes = self.0;

        while let Some(result) = utf8::decode(bytes) {

            let ch = match result {

                Ok(ch) => ch,

                Err(err) => {

                    // The decode API guarantees `errant_bytes` is non-empty.

                    write!(f, r"\x{:02x}", err.as_slice()[0])?;

                    bytes = &bytes[1..];

                    continue;

                }

            };

            bytes = &bytes[ch.len_utf8()..];

            match ch {

                '\0' => f.write_str(r"\0")?,

                '\x01'..='\x7f' => {

                    core::fmt::Display::fmt(&(ch as u8).escape_ascii(), f)?;

                }

                _ => {

                    core::fmt::Display::fmt(&ch.escape_debug(), f)?;

                }

            }

        }

        Ok(())

    }

}

impl<'a> core::fmt::Debug for Bytes<'a> {

    #[inline(never)]

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        f.write_str("\"")?;

        core::fmt::Display::fmt(self, f)?;

        f.write_str("\"")?;

        Ok(())

    }

}

/// A helper for repeating a single byte utilizing `Byte`.

///

/// This is limited to repeating a byte up to `u8::MAX` times in order

/// to reduce its size overhead. And in practice, Jiff just doesn't

/// need more than this (at time of writing, 2025-11-29).

pub(crate) struct RepeatByte {

    pub(crate) byte: u8,

    pub(crate) count: u8,

}

impl core::fmt::Display for RepeatByte {

    #[inline(never)]

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        for _ in 0..self.count {

            core::fmt::Display::fmt(&Byte(self.byte), f)?;

        }

        Ok(())

    }

}

impl core::fmt::Debug for RepeatByte {

    #[inline(never)]

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

        f.write_str("\"")?;

        core::fmt::Display::fmt(self, f)?;

        f.write_str("\"")?;

        Ok(())

    }

}