use crate::{immutable::object, BStr};

/// Represents a git tag, commonly indicating a software release.
#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
pub struct Tag<'a> {
    /// The hash in hexadecimal being the object this tag points to. Use [`target()`][Tag::target()] to obtain a byte representation.
    #[cfg_attr(feature = "serde1", serde(borrow))]
    pub target: &'a BStr,
    /// The kind of object that `target` points to.
    pub target_kind: crate::Kind,
    /// The name of the tag, e.g. "v1.0".
    pub name: &'a BStr,
    /// The author of the tag.
    pub tagger: Option<git_actor::immutable::Signature<'a>>,
    /// The message describing this release.
    pub message: &'a BStr,
    /// A cryptographic signature over the entire content of the serialized tag object thus far.
    pub pgp_signature: Option<&'a BStr>,
}

impl<'a> Tag<'a> {
    /// Deserialize a tag from `data`.
    pub fn from_bytes(data: &'a [u8]) -> Result<Tag<'a>, object::decode::Error> {
        decode::git_tag(data)
            .map(|(_, t)| t)
            .map_err(object::decode::Error::from)
    }
    /// The object this tag points to as `Id`.
    pub fn target(&self) -> git_hash::ObjectId {
        git_hash::ObjectId::from_hex(self.target).expect("prior validation")
    }
}

mod decode {
    use nom::{
        branch::alt,
        bytes::complete::{tag, take_until, take_while, take_while1},
        character::is_alphabetic,
        combinator::{all_consuming, opt, recognize},
        error::{context, ContextError, ParseError},
        sequence::{preceded, tuple},
        IResult,
    };

    use crate::{
        immutable::{parse, parse::NL, Tag},
        BStr, ByteSlice,
    };

    pub fn git_tag<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(i: &'a [u8]) -> IResult<&[u8], Tag<'a>, E> {
        let (i, target) = context("object <40 lowercase hex char>", |i| {
            parse::header_field(i, b"object", parse::hex_hash)
        })(i)?;

        let (i, kind) = context("type <object kind>", |i| {
            parse::header_field(i, b"type", take_while1(is_alphabetic))
        })(i)?;
        let kind = crate::Kind::from_bytes(kind)
            .map_err(|_| nom::Err::Error(E::from_error_kind(i, nom::error::ErrorKind::MapRes)))?;

        let (i, tag_version) = context("tag <version>", |i| {
            parse::header_field(i, b"tag", take_while1(|b| b != NL[0]))
        })(i)?;

        let (i, signature) = context(
            "tagger <signature>",
            opt(|i| parse::header_field(i, b"tagger", parse::signature)),
        )(i)?;
        let (i, (message, pgp_signature)) = all_consuming(message)(i)?;
        Ok((
            i,
            Tag {
                target,
                name: tag_version.as_bstr(),
                target_kind: kind,
                message,
                tagger: signature,
                pgp_signature,
            },
        ))
    }

    pub fn message<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], (&'a BStr, Option<&'a BStr>), E> {
        const PGP_SIGNATURE_BEGIN: &[u8] = b"\n-----BEGIN PGP SIGNATURE-----";
        const PGP_SIGNATURE_END: &[u8] = b"-----END PGP SIGNATURE-----";

        if i.is_empty() {
            return Ok((i, (i.as_bstr(), None)));
        }
        let (i, _) = tag(NL)(i)?;
        fn all_to_end<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], (&'a [u8], &'a [u8]), E> {
            if i.is_empty() {
                return Err(nom::Err::Error(E::from_error_kind(i, nom::error::ErrorKind::Eof)));
            }
            // an empty signature message signals that there is none - the function signature is needed
            // to work with 'alt(…)'. PGP signatures are never empty
            Ok((&[], (i, &[])))
        }
        let (i, (message, signature)) = alt((
            tuple((
                take_until(PGP_SIGNATURE_BEGIN),
                preceded(
                    tag(NL),
                    recognize(tuple((
                        tag(&PGP_SIGNATURE_BEGIN[1..]),
                        take_until(PGP_SIGNATURE_END),
                        tag(PGP_SIGNATURE_END),
                        take_while(|_| true),
                    ))),
                ),
            )),
            all_to_end,
        ))(i)?;
        let (i, _) = opt(tag(NL))(i)?;
        Ok((
            i,
            (
                message.as_bstr(),
                if signature.is_empty() {
                    None
                } else {
                    Some(signature.as_bstr())
                },
            ),
        ))
    }
}

///
pub mod iter {
    use bstr::BStr;
    use git_hash::{oid, ObjectId};
    use nom::{
        bytes::complete::take_while1,
        character::is_alphabetic,
        combinator::{all_consuming, opt},
        error::{context, ParseError},
    };

    use crate::{
        bstr::ByteSlice,
        immutable::{object, parse, parse::NL, tag::decode},
        Kind,
    };

    enum State {
        Target,
        TargetKind,
        Name,
        Tagger,
        Message,
    }

    impl Default for State {
        fn default() -> Self {
            State::Target
        }
    }

    /// Like [`immutable::Tag`][super::Tag], but as `Iterator` to support entirely allocation free parsing.
    /// It's particularly useful to dereference only the target chain.
    pub struct Iter<'a> {
        data: &'a [u8],
        state: State,
    }

    impl<'a> Iter<'a> {
        /// Create a tag iterator from data.
        pub fn from_bytes(data: &'a [u8]) -> Iter<'a> {
            Iter {
                data,
                state: State::default(),
            }
        }

        /// Returns the target id of this tag if it is the first function called and if there is no error in decoding
        /// the data.
        ///
        /// Note that this method must only be called once or else will always return None while consuming a single token.
        /// Errors are coerced into options, hiding whether there was an error or not. The caller should assume an error if they
        /// call the method as intended. Such a squelched error cannot be recovered unless the objects data is retrieved and parsed again.
        /// `next()`.
        pub fn target_id(&mut self) -> Option<ObjectId> {
            self.next().and_then(Result::ok).and_then(Token::into_id)
        }
    }

    impl<'a> Iter<'a> {
        fn next_inner(i: &'a [u8], state: &mut State) -> Result<(&'a [u8], Token<'a>), object::decode::Error> {
            use State::*;
            Ok(match state {
                Target => {
                    let (i, target) = context("object <40 lowercase hex char>", |i| {
                        parse::header_field(i, b"object", parse::hex_hash)
                    })(i)?;
                    *state = State::TargetKind;
                    (
                        i,
                        Token::Target {
                            id: ObjectId::from_hex(target).expect("parsing validation"),
                        },
                    )
                }
                TargetKind => {
                    let (i, kind) = context("type <object kind>", |i| {
                        parse::header_field(i, b"type", take_while1(is_alphabetic))
                    })(i)?;
                    let kind = crate::Kind::from_bytes(kind).map_err(|_| {
                        let err = object::decode::ParseError::from_error_kind(i, nom::error::ErrorKind::MapRes);
                        nom::Err::Error(err)
                    })?;
                    *state = State::Name;
                    (i, Token::TargetKind(kind))
                }
                Name => {
                    let (i, tag_version) = context("tag <version>", |i| {
                        parse::header_field(i, b"tag", take_while1(|b| b != NL[0]))
                    })(i)?;
                    *state = State::Tagger;
                    (i, Token::Name(tag_version.as_bstr()))
                }
                Tagger => {
                    let (i, signature) = context(
                        "tagger <signature>",
                        opt(|i| parse::header_field(i, b"tagger", parse::signature)),
                    )(i)?;
                    *state = State::Message;
                    (i, Token::Tagger(signature))
                }
                Message => {
                    let (i, (message, pgp_signature)) = all_consuming(decode::message)(i)?;
                    debug_assert!(
                        i.is_empty(),
                        "we should have consumed all data - otherwise iter may go forever"
                    );
                    return Ok((i, Token::Body { message, pgp_signature }));
                }
            })
        }
    }

    impl<'a> Iterator for Iter<'a> {
        type Item = Result<Token<'a>, object::decode::Error>;

        fn next(&mut self) -> Option<Self::Item> {
            if self.data.is_empty() {
                return None;
            }
            match Self::next_inner(self.data, &mut self.state) {
                Ok((data, token)) => {
                    self.data = data;
                    Some(Ok(token))
                }
                Err(err) => {
                    self.data = &[];
                    Some(Err(err))
                }
            }
        }
    }

    /// A token returned by the [commit iterator][Iter].
    #[allow(missing_docs)]
    #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
    pub enum Token<'a> {
        Target {
            id: ObjectId,
        },
        TargetKind(Kind),
        Name(&'a BStr),
        Tagger(Option<git_actor::immutable::Signature<'a>>),
        Body {
            message: &'a BStr,
            pgp_signature: Option<&'a BStr>,
        },
    }

    impl<'a> Token<'a> {
        /// Return the object id of this token if its a [Target][Token::Target].
        pub fn id(&self) -> Option<&oid> {
            match self {
                Token::Target { id } => Some(id.as_ref()),
                _ => None,
            }
        }

        /// Return the owned object id of this token if its a [Target][Token::Target].
        pub fn into_id(self) -> Option<ObjectId> {
            match self {
                Token::Target { id } => Some(id),
                _ => None,
            }
        }
    }
}