use anstyle_parse::state::state_change;

use anstyle_parse::state::Action;

use anstyle_parse::state::State;

/// Strip ANSI escapes from a `&str`, returning the printable content

///

/// This can be used to take output from a program that includes escape sequences and write it

/// somewhere that does not easily support them, such as a log file.

///

/// For non-contiguous data, see [`StripStr`].

///

/// # Example

///

/// ```rust

/// use std::io::Write as _;

///

/// let styled_text = "\x1b[32mfoo\x1b[m bar";

/// let plain_str = anstream::adapter::strip_str(&styled_text).to_string();

/// assert_eq!(plain_str, "foo bar");

/// ```

#[inline]

pub fn strip_str(data: &str) -> StrippedStr<'_> {

    StrippedStr::new(data)

}

/// See [`strip_str`]

#[derive(Default, Clone, Debug, PartialEq, Eq)]

pub struct StrippedStr<'s> {

    bytes: &'s [u8],

    state: State,

}

impl<'s> StrippedStr<'s> {

    #[inline]

    fn new(data: &'s str) -> Self {

        Self {

            bytes: data.as_bytes(),

            state: State::Ground,

        }

    }

    /// Create a [`String`] of the printable content

    #[inline]

    #[allow(clippy::inherent_to_string_shadow_display)] // Single-allocation implementation

    pub fn to_string(&self) -> String {

        use std::fmt::Write as _;

        let mut stripped = String::with_capacity(self.bytes.len());

        let _ = write!(&mut stripped, "{self}");

        stripped

    }

}

impl std::fmt::Display for StrippedStr<'_> {

    /// **Note:** this does *not* exhaust the [`Iterator`]

    #[inline]

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        let iter = Self {

            bytes: self.bytes,

            state: self.state,

        };

        for printable in iter {

            printable.fmt(f)?;

        }

        Ok(())

    }

}

impl<'s> Iterator for StrippedStr<'s> {

    type Item = &'s str;

    #[inline]

    fn next(&mut self) -> Option<Self::Item> {

        next_str(&mut self.bytes, &mut self.state)

    }

}

/// Incrementally strip non-contiguous data

#[derive(Default, Clone, Debug, PartialEq, Eq)]

pub struct StripStr {

    state: State,

}

impl StripStr {

    /// Initial state

    pub fn new() -> Self {

        Default::default()

    }

    /// Strip the next segment of data

    pub fn strip_next<'s>(&'s mut self, data: &'s str) -> StripStrIter<'s> {

        StripStrIter {

            bytes: data.as_bytes(),

            state: &mut self.state,

        }

    }

}

/// See [`StripStr`]

#[derive(Debug, PartialEq, Eq)]

pub struct StripStrIter<'s> {

    bytes: &'s [u8],

    state: &'s mut State,

}

impl<'s> Iterator for StripStrIter<'s> {

    type Item = &'s str;

    #[inline]

    fn next(&mut self) -> Option<Self::Item> {

        next_str(&mut self.bytes, self.state)

    }

}

#[inline]

fn next_str<'s>(bytes: &mut &'s [u8], state: &mut State) -> Option<&'s str> {

    let offset = bytes.iter().copied().position(|b| {

        let (next_state, action) = state_change(*state, b);

        if next_state != State::Anywhere {

            *state = next_state;

        }

        is_printable_bytes(action, b)

    });

    let (_, next) = bytes.split_at(offset.unwrap_or(bytes.len()));

    *bytes = next;

    *state = State::Ground;

    let offset = bytes.iter().copied().position(|b| {

        let (_next_state, action) = state_change(State::Ground, b);

        !(is_printable_bytes(action, b) || is_utf8_continuation(b))

    });

    let (printable, next) = bytes.split_at(offset.unwrap_or(bytes.len()));

    *bytes = next;

    if printable.is_empty() {

        None

    } else {

        let printable = unsafe {

            from_utf8_unchecked(

                printable,

                "`bytes` was validated as UTF-8, the parser preserves UTF-8 continuations",

            )

        };

        Some(printable)

    }

}

#[inline]

unsafe fn from_utf8_unchecked<'b>(bytes: &'b [u8], safety_justification: &'static str) -> &'b str {

    unsafe {

        if cfg!(debug_assertions) {

            // Catch problems more quickly when testing

            std::str::from_utf8(bytes).expect(safety_justification)

        } else {

            std::str::from_utf8_unchecked(bytes)

        }

    }

}

#[inline]

fn is_utf8_continuation(b: u8) -> bool {

    matches!(b, 0x80..=0xbf)

}

/// Strip ANSI escapes from bytes, returning the printable content

///

/// This can be used to take output from a program that includes escape sequences and write it

/// somewhere that does not easily support them, such as a log file.

///

/// # Example

///

/// ```rust

/// use std::io::Write as _;

///

/// let styled_text = "\x1b[32mfoo\x1b[m bar";

/// let plain_str = anstream::adapter::strip_bytes(styled_text.as_bytes()).into_vec();

/// assert_eq!(plain_str.as_slice(), &b"foo bar"[..]);

/// ```

#[inline]

pub fn strip_bytes(data: &[u8]) -> StrippedBytes<'_> {

    StrippedBytes::new(data)

}

/// See [`strip_bytes`]

#[derive(Default, Clone, Debug, PartialEq, Eq)]

pub struct StrippedBytes<'s> {

    bytes: &'s [u8],

    state: State,

    utf8parser: Utf8Parser,

}

impl<'s> StrippedBytes<'s> {

    /// See [`strip_bytes`]

    #[inline]

    pub fn new(bytes: &'s [u8]) -> Self {

        Self {

            bytes,

            state: State::Ground,

            utf8parser: Default::default(),

        }

    }

    /// Strip the next slice of bytes

    ///

    /// Used when the content is in several non-contiguous slices

    ///

    /// # Panic

    ///

    /// May panic if it is not exhausted / empty

    #[inline]

    pub fn extend(&mut self, bytes: &'s [u8]) {

        debug_assert!(

            self.is_empty(),

            "current bytes must be processed to ensure we end at the right state"

        );

        self.bytes = bytes;

    }

    /// Report the bytes has been exhausted

    #[inline]

    pub fn is_empty(&self) -> bool {

        self.bytes.is_empty()

    }

    /// Create a [`Vec`] of the printable content

    #[inline]

    pub fn into_vec(self) -> Vec<u8> {

        let mut stripped = Vec::with_capacity(self.bytes.len());

        for printable in self {

            stripped.extend(printable);

        }

        stripped

    }

}

impl<'s> Iterator for StrippedBytes<'s> {

    type Item = &'s [u8];

    #[inline]

    fn next(&mut self) -> Option<Self::Item> {

        next_bytes(&mut self.bytes, &mut self.state, &mut self.utf8parser)

    }

}

/// Incrementally strip non-contiguous data

#[derive(Default, Clone, Debug, PartialEq, Eq)]

pub struct StripBytes {

    state: State,

    utf8parser: Utf8Parser,

}

impl StripBytes {

    /// Initial state

    pub fn new() -> Self {

        Default::default()

    }

    /// Strip the next segment of data

    pub fn strip_next<'s>(&'s mut self, bytes: &'s [u8]) -> StripBytesIter<'s> {

        StripBytesIter {

            bytes,

            state: &mut self.state,

            utf8parser: &mut self.utf8parser,

        }

    }

}

/// See [`StripBytes`]

#[derive(Debug, PartialEq, Eq)]

pub struct StripBytesIter<'s> {

    bytes: &'s [u8],

    state: &'s mut State,

    utf8parser: &'s mut Utf8Parser,

}

impl<'s> Iterator for StripBytesIter<'s> {

    type Item = &'s [u8];

    #[inline]

    fn next(&mut self) -> Option<Self::Item> {

        next_bytes(&mut self.bytes, self.state, self.utf8parser)

    }

}

#[inline]

fn next_bytes<'s>(

    bytes: &mut &'s [u8],

    state: &mut State,

    utf8parser: &mut Utf8Parser,

) -> Option<&'s [u8]> {

    let offset = bytes.iter().copied().position(|b| {

        if *state == State::Utf8 {

            true

        } else {

            let (next_state, action) = state_change(*state, b);

            if next_state != State::Anywhere {

                *state = next_state;

            }

            is_printable_bytes(action, b)

        }

    });

    let (_, next) = bytes.split_at(offset.unwrap_or(bytes.len()));

    *bytes = next;

    let offset = bytes.iter().copied().position(|b| {

        if *state == State::Utf8 {

            if utf8parser.add(b) {

                *state = State::Ground;

            }

            false

        } else {

            let (next_state, action) = state_change(State::Ground, b);

            if next_state != State::Anywhere {

                *state = next_state;

            }

            if *state == State::Utf8 {

                utf8parser.add(b);

                false

            } else {

                !is_printable_bytes(action, b)

            }

        }

    });

    let (printable, next) = bytes.split_at(offset.unwrap_or(bytes.len()));

    *bytes = next;

    if printable.is_empty() {

        None

    } else {

        Some(printable)

    }

}

#[derive(Default, Clone, Debug, PartialEq, Eq)]

pub(crate) struct Utf8Parser {

    utf8_parser: utf8parse::Parser,

}

impl Utf8Parser {

    fn add(&mut self, byte: u8) -> bool {

        let mut b = false;

        let mut receiver = VtUtf8Receiver(&mut b);

        self.utf8_parser.advance(&mut receiver, byte);

        b

    }

}

struct VtUtf8Receiver<'a>(&'a mut bool);

impl utf8parse::Receiver for VtUtf8Receiver<'_> {

    fn codepoint(&mut self, _: char) {

        *self.0 = true;

    }

    fn invalid_sequence(&mut self) {

        *self.0 = true;

    }

}

#[inline]

fn is_printable_bytes(action: Action, byte: u8) -> bool {

    // VT320 considered 0x7f to be `Print`able but we expect to be working in UTF-8 systems and not

    // ISO Latin-1, making it DEL and non-printable

    const DEL: u8 = 0x7f;

    // Continuations aren't included as they may also be control codes, requiring more context

    (action == Action::Print && byte != DEL)

        || action == Action::BeginUtf8

        || (action == Action::Execute && byte.is_ascii_whitespace())

}

#[cfg(test)]

mod test {

    use super::*;

    use proptest::prelude::*;

    /// Model based off full parser

    fn parser_strip(bytes: &[u8]) -> String {

        #[derive(Default)]

        struct Strip(String);

        impl Strip {

            fn with_capacity(capacity: usize) -> Self {

                Self(String::with_capacity(capacity))

            }

        }

        impl anstyle_parse::Perform for Strip {

            fn print(&mut self, c: char) {

                self.0.push(c);

            }

            fn execute(&mut self, byte: u8) {

                if byte.is_ascii_whitespace() {

                    self.0.push(byte as char);

                }

            }

        }

        let mut stripped = Strip::with_capacity(bytes.len());

        let mut parser = anstyle_parse::Parser::<anstyle_parse::DefaultCharAccumulator>::new();

        for byte in bytes {

            parser.advance(&mut stripped, *byte);

        }

        stripped.0

    }

    /// Model verifying incremental parsing

    fn strip_char(mut s: &str) -> String {

        let mut result = String::new();

        let mut state = StripStr::new();

        while !s.is_empty() {

            let mut indices = s.char_indices();

            indices.next(); // current

            let offset = indices.next().map(|(i, _)| i).unwrap_or_else(|| s.len());

            let (current, remainder) = s.split_at(offset);

            for printable in state.strip_next(current) {

                result.push_str(printable);

            }

            s = remainder;

        }

        result

    }

    /// Model verifying incremental parsing

    fn strip_byte(s: &[u8]) -> Vec<u8> {

        let mut result = Vec::new();

        let mut state = StripBytes::default();

        for start in 0..s.len() {

            let current = &s[start..=start];

            for printable in state.strip_next(current) {

                result.extend(printable);

            }

        }

        result

    }

    #[test]

    fn test_strip_bytes_multibyte() {

        let bytes = [240, 145, 141, 139];

        let expected = parser_strip(&bytes);

        let actual = String::from_utf8(strip_bytes(&bytes).into_vec()).unwrap();

        assert_eq!(expected, actual);

    }

    #[test]

    fn test_strip_byte_multibyte() {

        let bytes = [240, 145, 141, 139];

        let expected = parser_strip(&bytes);

        let actual = String::from_utf8(strip_byte(&bytes).clone()).unwrap();

        assert_eq!(expected, actual);

    }

    #[test]

    fn test_strip_str_del() {

        let input = std::str::from_utf8(&[0x7f]).unwrap();

        let expected = "";

        let actual = strip_str(input).to_string();

        assert_eq!(expected, actual);

    }

    #[test]

    fn test_strip_byte_del() {

        let bytes = [0x7f];

        let expected = "";

        let actual = String::from_utf8(strip_byte(&bytes).clone()).unwrap();

        assert_eq!(expected, actual);

    }

    #[test]

    fn test_strip_str_handles_broken_sequence() {

        // valid utf8: \xc3\xb6 then \x1b then \xf0\x9f\x98\x80

        let s = "ö\x1b😀hello😀goodbye";

        let mut it = strip_str(s);

        assert_eq!("ö", it.next().unwrap());

        assert_eq!("ello😀goodbye", it.next().unwrap());

    }

    proptest! {

        #[test]

        #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253

        fn strip_str_no_escapes(s in "\\PC*") {

            let expected = parser_strip(s.as_bytes());

            let actual = strip_str(&s).to_string();

            assert_eq!(expected, actual);

        }

        #[test]

        #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253

        fn strip_char_no_escapes(s in "\\PC*") {

            let expected = parser_strip(s.as_bytes());

            let actual = strip_char(&s);

            assert_eq!(expected, actual);

        }

        #[test]

        #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253

        fn strip_bytes_no_escapes(s in "\\PC*") {

            dbg!(&s);

            dbg!(s.as_bytes());

            let expected = parser_strip(s.as_bytes());

            let actual = String::from_utf8(strip_bytes(s.as_bytes()).into_vec()).unwrap();

            assert_eq!(expected, actual);

        }

        #[test]

        #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253

        fn strip_byte_no_escapes(s in "\\PC*") {

            dbg!(&s);

            dbg!(s.as_bytes());

            let expected = parser_strip(s.as_bytes());

            let actual = String::from_utf8(strip_byte(s.as_bytes()).clone()).unwrap();

            assert_eq!(expected, actual);

        }

    }

}