/*!
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(())
    }
}
