use std::{borrow::Cow, ops::Deref};

use crate::{
    bstr::{BStr, BString, ByteSlice, ByteVec},
    commit::MessageRef,
};

///
pub mod body {
    use nom::{
        bytes::complete::{tag, take_until1},
        combinator::all_consuming,
        error::ParseError,
        sequence::terminated,
        IResult,
    };

    use crate::{
        bstr::{BStr, ByteSlice},
        commit::message::BodyRef,
    };
    use nom::error::ErrorKind;

    /// An iterator over trailers as parsed from a commit message body.
    ///
    /// lines with parsing failures will be skipped
    pub struct Trailers<'a> {
        pub(crate) cursor: &'a [u8],
    }

    /// A trailer as parsed from the commit message body.
    #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
    #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
    pub struct TrailerRef<'a> {
        /// The name of the trailer, like "Signed-off-by", up to the separator ": "
        #[cfg_attr(feature = "serde1", serde(borrow))]
        pub token: &'a BStr,
        /// The value right after the separator ": ", with leading and trailing whitespace trimmed.
        /// Note that multi-line values aren't currently supported.
        pub value: &'a BStr,
    }

    fn parse_single_line_trailer<'a, E: ParseError<&'a [u8]>>(
        i: &'a [u8],
    ) -> IResult<&'a [u8], (&'a BStr, &'a BStr), E> {
        let (value, token) = terminated(take_until1(b":".as_ref()), tag(b": "))(i.trim_end())?;
        if token.trim_end().len() != token.len() {
            Err(nom::Err::Failure(E::from_error_kind(i, ErrorKind::Fail)))
        } else {
            Ok((&[], (token.as_bstr(), value.as_bstr())))
        }
    }

    #[cfg(test)]
    mod test_parse_trailer {
        use super::*;

        fn parse(input: &str) -> (&BStr, &BStr) {
            parse_single_line_trailer::<()>(input.as_bytes()).unwrap().1
        }

        #[test]
        fn simple_newline() {
            assert_eq!(parse("foo: bar\n"), ("foo".into(), "bar".into()));
        }

        #[test]
        fn simple_non_ascii_no_newline() {
            assert_eq!(parse("🤗: 🎉"), ("🤗".into(), "🎉".into()));
        }

        #[test]
        fn with_lots_of_whitespace_newline() {
            assert_eq!(
                parse("hello foo: bar there   \n"),
                ("hello foo".into(), "bar there".into())
            );
        }

        #[test]
        fn whitespace_before_token_is_error() {
            assert!(parse_single_line_trailer::<()>(b"foo : bar").is_err())
        }

        #[test]
        fn simple_newline_windows() {
            assert_eq!(parse("foo: bar\r\n"), ("foo".into(), "bar".into()));
        }
    }

    impl<'a> Iterator for Trailers<'a> {
        type Item = TrailerRef<'a>;

        fn next(&mut self) -> Option<Self::Item> {
            if self.cursor.is_empty() {
                return None;
            }
            for line in self.cursor.lines_with_terminator() {
                self.cursor = &self.cursor[line.len()..];
                if let Some(trailer) =
                    all_consuming(parse_single_line_trailer::<()>)(line)
                        .ok()
                        .map(|(_, (token, value))| TrailerRef {
                            token: token.trim().as_bstr(),
                            value: value.trim().as_bstr(),
                        })
                {
                    return Some(trailer);
                }
            }
            None
        }
    }

    impl<'a> BodyRef<'a> {
        /// Parse `body` bytes into the trailer and the actual body.
        pub fn from_bytes(body: &'a [u8]) -> Self {
            body.rfind(b"\n\n")
                .map(|pos| (2, pos))
                .or_else(|| body.rfind(b"\r\n\r\n").map(|pos| (4, pos)))
                .and_then(|(sep_len, pos)| {
                    let trailer = &body[pos + sep_len..];
                    let body = &body[..pos];
                    Trailers { cursor: trailer }.next().map(|_| BodyRef {
                        body_without_trailer: body.as_bstr(),
                        start_of_trailer: trailer,
                    })
                })
                .unwrap_or_else(|| BodyRef {
                    body_without_trailer: body.as_bstr(),
                    start_of_trailer: &[],
                })
        }
    }
}
mod decode {
    use nom::{
        branch::alt,
        bytes::complete::{tag, take_till1},
        combinator::all_consuming,
        error::ParseError,
        sequence::pair,
        IResult,
    };

    use crate::bstr::{BStr, ByteSlice};

    pub(crate) fn newline<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], &'a [u8], E> {
        alt((tag(b"\r\n"), tag(b"\n")))(i)
    }

    fn subject_and_body<'a, E: ParseError<&'a [u8]>>(
        i: &'a [u8],
    ) -> IResult<&'a [u8], (&'a BStr, Option<&'a BStr>), E> {
        let mut c = i;
        let mut consumed_bytes = 0;
        while !c.is_empty() {
            c = match take_till1::<_, _, E>(|c| c == b'\n' || c == b'\r')(c) {
                Ok((i1, segment)) => {
                    consumed_bytes += segment.len();
                    match pair::<_, _, _, E, _, _>(newline, newline)(i1) {
                        Ok((body, _)) => {
                            return Ok((
                                &[],
                                (
                                    i[0usize..consumed_bytes].as_bstr(),
                                    (!body.is_empty()).then(|| body.as_bstr()),
                                ),
                            ));
                        }
                        Err(_) => match i1.get(1..) {
                            Some(next) => {
                                consumed_bytes += 1;
                                next
                            }
                            None => break,
                        },
                    }
                }
                Err(_) => match c.get(1..) {
                    Some(next) => {
                        consumed_bytes += 1;
                        next
                    }
                    None => break,
                },
            };
        }
        Ok((&[], (i.as_bstr(), None)))
    }

    /// Returns title and body, without separator
    pub fn message(input: &[u8]) -> (&BStr, Option<&BStr>) {
        all_consuming(subject_and_body::<()>)(input).expect("cannot fail").1
    }
}

impl<'a> MessageRef<'a> {
    /// Parse the given `input` as message.
    ///
    /// Note that this cannot fail as everything will be interpreted as title if there is no body separator.
    pub fn from_bytes(input: &'a [u8]) -> Self {
        let (title, body) = decode::message(input);
        MessageRef { title, body }
    }

    /// Produce a short commit summary for the message title.
    ///
    /// This means the following
    ///
    /// * Take the subject line which is delimited by two newlines (\n\n)
    /// * transform intermediate consecutive whitespace including \r into one space
    ///
    /// The resulting summary will have folded whitespace before a newline into spaces and stopped that process
    /// once two consecutive newlines are encountered.
    pub fn summary(&self) -> Cow<'a, BStr> {
        summary(self.title)
    }

    /// Further parse the body into into non-trailer and trailers, which can be iterated from the returned [`BodyRef`].
    pub fn body(&self) -> Option<BodyRef<'a>> {
        self.body.map(|b| BodyRef::from_bytes(b))
    }
}

pub(crate) fn summary(message: &BStr) -> Cow<'_, BStr> {
    let message = message.trim();
    match message.find_byte(b'\n') {
        Some(mut pos) => {
            let mut out = BString::default();
            let mut previous_pos = None;
            loop {
                if let Some(previous_pos) = previous_pos {
                    if previous_pos + 1 == pos {
                        let len_after_trim = out.trim_end().len();
                        out.resize(len_after_trim, 0);
                        break out.into();
                    }
                }
                let message_to_newline = &message[previous_pos.map(|p| p + 1).unwrap_or(0)..pos];

                if let Some(pos_before_whitespace) = message_to_newline.rfind_not_byteset(b"\t\n\x0C\r ") {
                    out.extend_from_slice(&message_to_newline[..pos_before_whitespace + 1]);
                }
                out.push_byte(b' ');
                previous_pos = Some(pos);
                match message.get(pos + 1..).and_then(|i| i.find_byte(b'\n')) {
                    Some(next_nl_pos) => pos += next_nl_pos + 1,
                    None => {
                        if let Some(slice) = message.get((pos + 1)..) {
                            out.extend_from_slice(slice);
                        }
                        break out.into();
                    }
                }
            }
        }
        None => message.as_bstr().into(),
    }
}

/// A reference to a message body, further parsed to only contain the non-trailer parts.
///
/// See [git-interpret-trailers](https://git-scm.com/docs/git-interpret-trailers) for more information
/// on what constitutes trailers and not that this implementation is only good for typical sign-off footer or key-value parsing.
///
/// Note that we only parse trailers from the bottom of the body.
#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
pub struct BodyRef<'a> {
    body_without_trailer: &'a BStr,
    start_of_trailer: &'a [u8],
}

impl<'a> BodyRef<'a> {
    /// Return an iterator over the trailers parsed from the last paragraph of the body. May be empty.
    pub fn trailers(&self) -> body::Trailers<'a> {
        body::Trailers {
            cursor: self.start_of_trailer,
        }
    }
}

impl<'a> AsRef<BStr> for BodyRef<'a> {
    fn as_ref(&self) -> &BStr {
        self.body_without_trailer
    }
}

impl<'a> Deref for BodyRef<'a> {
    type Target = BStr;

    fn deref(&self) -> &Self::Target {
        self.body_without_trailer
    }
}