mod section {
    use crate::parse::{Comment, Event, Events, SectionRef, section};

    #[test]
    #[cfg(target_pointer_width = "64")]
    fn size_of_events() {
        assert_eq!(
            std::mem::size_of::<SectionRef>(),
            40,
            "this value should only ever decrease"
        );
        assert_eq!(std::mem::size_of::<Events>(), 512);
        assert_eq!(std::mem::size_of::<crate::parse::Span>(), 8);
        assert_eq!(std::mem::size_of::<Event>(), 56);
        assert_eq!(std::mem::size_of::<Comment>(), 12);
        assert_eq!(std::mem::size_of::<section::Name>(), 24);
        assert_eq!(std::mem::size_of::<section::ValueName>(), 24);
    }

    mod header {
        mod unvalidated {
            use crate::parse::section::unvalidated::KeyRef;

            #[test]
            fn section_name_only() {
                assert_eq!(
                    KeyRef::parse("core").unwrap(),
                    KeyRef {
                        section_name: "core",
                        subsection_name: None
                    }
                );
            }

            #[test]
            fn section_name_and_subsection() {
                assert_eq!(
                    KeyRef::parse("core.bare").unwrap(),
                    KeyRef {
                        section_name: "core",
                        subsection_name: Some("bare".into())
                    }
                );
            }

            #[test]
            fn section_name_and_subsection_with_separators() {
                assert_eq!(
                    KeyRef::parse("remote.https:///home/user.git").unwrap(),
                    KeyRef {
                        section_name: "remote",
                        subsection_name: Some("https:///home/user.git".into())
                    }
                );
            }
        }
    }
}

mod span {
    use crate::parse::Span;

    #[test]
    #[cfg(target_pointer_width = "64")]
    fn reports_range_and_rebase_overflow() {
        assert!(Span::range(u32::MAX as usize + 1, 0).is_err());
        assert!(Span::range(0, u32::MAX as usize + 1).is_err());

        let mut span = Span::range(u32::MAX as usize, 0).expect("the maximum offset is representable");
        assert_eq!(span.rebase(1), Err(crate::parse::span::Error));
    }
}

mod event {
    mod write_to {
        use crate::parse::{EventRef, Events};

        fn header(
            name: &'static str,
            subsection: impl Into<Option<(&'static str, &'static str)>>,
        ) -> EventRef<'static> {
            let (separator, subsection_name) =
                subsection.into().map_or((None, None), |(separator, subsection_name)| {
                    (Some(separator.into()), Some(subsection_name.into()))
                });
            EventRef::SectionHeader {
                name: name.into(),
                separator,
                subsection_name,
            }
        }

        fn write_event(event: EventRef<'_>) -> Vec<u8> {
            let mut out = Vec::new();
            event.write_to(&mut out).expect("writing to memory succeeds");
            out
        }

        fn write_events(input: &str) -> Vec<u8> {
            let events = Events::from_str(input).unwrap();
            let mut out = Vec::new();
            for event in events.iter() {
                event.write_to(&mut out).unwrap();
            }
            out
        }

        #[test]
        fn legacy_subsection_format_does_not_use_escapes() {
            assert_eq!(
                write_event(header("invalid", Some((".", r#"\ ""#)))),
                br#"[invalid.\ "]"#,
                "no escaping happens for legacy subsections"
            );
        }

        #[test]
        fn subsections_escape_two_characters_only() {
            assert_eq!(
                write_event(header("invalid", Some((" ", "\\ \"\npost newline")))),
                b"[invalid \"\\\\ \\\"\npost newline\"]",
                "newlines are invalid in validated subsections, but EventRef can represent them"
            );
        }

        #[test]
        fn empty_section_name_with_quoted_subsection() {
            assert_eq!(
                write_event(header("", Some((" ", "core")))),
                br#"[ "core"]"#,
                "Git accepts an empty section name with `core` as subsection"
            );
        }

        #[test]
        fn nul_byte_in_quoted_subsection() {
            assert_eq!(
                write_event(header("hello", Some((" ", "hello\0")))),
                b"[hello \"hello\0\"]",
                "Git accepts NUL bytes in quoted subsection names"
            );
        }

        #[test]
        fn key_value_before_first_section() {
            let input = "a = b\n";
            assert_eq!(
                write_events(input),
                input.as_bytes(),
                "Git accepts key/value pairs before the first section, and we preserve them"
            );
        }

        #[test]
        fn value_with_trailing_backslash_at_eof() {
            let input = "[core]\na=hello\\";
            assert_eq!(
                write_events(input),
                input.as_bytes(),
                "Git accepts EOF as a line continuation terminator, and we preserve the original trailing backslash"
            );
        }
    }
}

pub(crate) mod util {
    //! This module is only included for tests, and contains common unit test helper
    //! functions.
    //!
    //! Parsed events store spans into a separate backing buffer, so their fields cannot be inspected
    //! or compared meaningfully without the backing buffer. The `Owned*` types resolve those spans into
    //! owned byte strings, allowing tests to compare event contents independently of span coordinates
    //! and to retain expected or actual values after a temporary backing buffer is dropped.

    use bstr::BString;

    use crate::parse::{Event, section};

    #[derive(Clone, Debug, Eq, PartialEq)]
    pub(crate) struct OwnedHeader {
        pub(crate) name: BString,
        pub(crate) separator: Option<BString>,
        pub(crate) subsection_name: Option<BString>,
    }

    #[derive(Clone, Debug, Eq, PartialEq)]
    pub(crate) enum OwnedEvent {
        Comment(OwnedComment),
        SectionHeader(OwnedHeader),
        SectionValueName(BString),
        Value(BString),
        Newline(BString),
        ValueNotDone(BString),
        ValueDone(BString),
        Whitespace(BString),
        KeyValueSeparator,
    }

    #[derive(Clone, Debug, Eq, PartialEq)]
    pub(crate) struct OwnedComment {
        pub(crate) tag: u8,
        pub(crate) text: BString,
    }

    #[derive(Clone, Debug, Eq, PartialEq)]
    pub(crate) struct OwnedSection {
        pub(crate) header: OwnedHeader,
        pub(crate) events: Vec<OwnedEvent>,
    }

    pub(crate) fn own_event(event: &Event, backing: &[u8]) -> OwnedEvent {
        match event {
            Event::Comment(comment) => OwnedEvent::Comment(OwnedComment {
                tag: comment.tag,
                text: comment.text.to_bstring_in(backing),
            }),
            Event::SectionHeader(header) => OwnedEvent::SectionHeader(own_header(header, backing)),
            Event::SectionValueName(name) => OwnedEvent::SectionValueName(name.to_bstring_in(backing)),
            Event::Value(value) => OwnedEvent::Value(value.to_bstring_in(backing)),
            Event::Newline(value) => OwnedEvent::Newline(value.to_bstring_in(backing)),
            Event::ValueNotDone(value) => OwnedEvent::ValueNotDone(value.to_bstring_in(backing)),
            Event::ValueDone(value) => OwnedEvent::ValueDone(value.to_bstring_in(backing)),
            Event::Whitespace(value) => OwnedEvent::Whitespace(value.to_bstring_in(backing)),
            Event::KeyValueSeparator => OwnedEvent::KeyValueSeparator,
        }
    }

    pub(crate) fn own_header(header: &section::HeaderData, backing: &[u8]) -> OwnedHeader {
        OwnedHeader {
            name: header.name.to_bstring_in(backing),
            separator: header.separator.map(|separator| separator.to_bstring_in(backing)),
            subsection_name: header
                .subsection_name
                .as_ref()
                .map(|subsection_name| subsection_name.value_in(backing).to_owned()),
        }
    }

    pub fn section_header(name: &str, subsection: impl Into<Option<(&'static str, &'static str)>>) -> OwnedHeader {
        if let Some((separator, subsection_name)) = subsection.into() {
            OwnedHeader {
                name: name.into(),
                separator: Some(separator.into()),
                subsection_name: Some(subsection_name.into()),
            }
        } else {
            OwnedHeader {
                name: name.into(),
                separator: None,
                subsection_name: None,
            }
        }
    }

    pub(crate) fn name_event(name: &'static str) -> OwnedEvent {
        OwnedEvent::SectionValueName(name.into())
    }

    pub(crate) fn value_event(value: &'static str) -> OwnedEvent {
        OwnedEvent::Value(value.into())
    }

    pub(crate) fn value_not_done_event(value: &'static str) -> OwnedEvent {
        OwnedEvent::ValueNotDone(value.into())
    }

    pub(crate) fn value_done_event(value: &'static str) -> OwnedEvent {
        OwnedEvent::ValueDone(value.into())
    }

    pub(crate) fn newline_event() -> OwnedEvent {
        newline_custom_event("\n")
    }

    pub(crate) fn newline_custom_event(value: &'static str) -> OwnedEvent {
        OwnedEvent::Newline(value.into())
    }

    pub(crate) fn whitespace_event(value: &'static str) -> OwnedEvent {
        OwnedEvent::Whitespace(value.into())
    }

    pub(crate) fn comment_event(tag: char, msg: &'static str) -> OwnedEvent {
        OwnedEvent::Comment(comment(tag, msg))
    }

    pub(crate) fn comment(comment_tag: char, comment: &'static str) -> OwnedComment {
        OwnedComment {
            tag: comment_tag as u8,
            text: comment.into(),
        }
    }

    pub(crate) const fn fully_consumed<T>(t: T) -> (&'static [u8], T) {
        (&[], t)
    }
}