use super::*;

/// A push-based, lossy decoder for UTF-8.
/// Errors are replaced with the U+FFFD replacement character.
///
/// Users "push" bytes into the decoder, which in turn "pushes" `&str` slices into a callback.
///
/// **Note:** Dropping the decoder signals the end of the input:
/// If the last input chunk ended with an incomplete byte sequence for a code point,
/// this is an error and a replacement character is emitted.
/// Use `std::mem::forget` to inhibit this behavior.
///
/// # Examples
///
/// Single-shot lossy decoding (like `String::from_utf8_lossy` but returning `String`):
///
/// ```
/// use utf8_zero::LossyDecoder;
///
/// fn string_from_utf8_lossy(input: &[u8]) -> String {
///     let mut string = String::new();
///     LossyDecoder::new(|s| string.push_str(s)).feed(input);
///     string
/// }
///
/// assert_eq!(string_from_utf8_lossy(b"Hello\xC0World"), "Hello\u{FFFD}World");
/// ```
///
/// Streaming chunks -- a multi-byte code point split across two feeds:
///
/// ```
/// use utf8_zero::LossyDecoder;
///
/// let mut output = String::new();
/// {
///     let mut decoder = LossyDecoder::new(|s| output.push_str(s));
///     decoder.feed(b"Hello \xC3");  // first byte of U+00E9
///     decoder.feed(b"\xA9!");       // second byte + excl mark
/// }
/// assert_eq!(output, "Hello \u{00E9}!");
/// ```
pub struct LossyDecoder<F: FnMut(&str)> {
    push_str: F,
    incomplete: Incomplete,
}

impl<F: FnMut(&str)> LossyDecoder<F> {
    /// Create a new decoder from a callback.
    #[inline]
    pub fn new(push_str: F) -> Self {
        LossyDecoder {
            push_str,
            incomplete: Incomplete {
                buffer: [0, 0, 0, 0],
                buffer_len: 0,
            },
        }
    }

    /// Feed one chunk of input into the decoder.
    ///
    /// The input is decoded lossily
    /// and the callback called once or more with `&str` string slices.
    ///
    /// If the UTF-8 byte sequence for one code point was split into this bytes chunk
    /// and previous bytes chunks, it will be correctly pieced back together.
    pub fn feed(&mut self, mut input: &[u8]) {
        if self.incomplete.buffer_len > 0 {
            match self.incomplete.try_complete(input) {
                Some((Ok(s), remaining)) => {
                    (self.push_str)(s);
                    input = remaining
                }
                Some((Err(_), remaining)) => {
                    (self.push_str)(REPLACEMENT_CHARACTER);
                    input = remaining
                }
                None => return,
            }
        }
        loop {
            match decode(input) {
                Ok(s) => {
                    (self.push_str)(s);
                    return;
                }
                Err(DecodeError::Incomplete {
                    valid_prefix,
                    incomplete_suffix,
                }) => {
                    (self.push_str)(valid_prefix);
                    self.incomplete = incomplete_suffix;
                    return;
                }
                Err(DecodeError::Invalid {
                    valid_prefix,
                    remaining_input,
                    ..
                }) => {
                    (self.push_str)(valid_prefix);
                    (self.push_str)(REPLACEMENT_CHARACTER);
                    input = remaining_input
                }
            }
        }
    }
}

impl<F: FnMut(&str)> Drop for LossyDecoder<F> {
    #[inline]
    fn drop(&mut self) {
        if self.incomplete.buffer_len > 0 {
            (self.push_str)(REPLACEMENT_CHARACTER)
        }
    }
}
