mod streaming {
    use git_packetline::{
        decode::{self, streaming, Stream},
        immutable::Error,
        PacketLine,
    };

    use crate::assert_err_display;

    fn assert_complete(
        res: Result<Stream, decode::Error>,
        expected_consumed: usize,
        expected_value: PacketLine,
    ) -> crate::Result {
        match res? {
            Stream::Complete { line, bytes_consumed } => {
                assert_eq!(bytes_consumed, expected_consumed);
                assert_eq!(line.as_bstr(), expected_value.as_bstr());
            }
            Stream::Incomplete { .. } => panic!("expected parsing to be complete, not partial"),
        }
        Ok(())
    }

    mod round_trip {
        use bstr::ByteSlice;
        use git_packetline::{decode, decode::streaming, Channel, PacketLine};

        use crate::decode::streaming::assert_complete;

        #[maybe_async::test(feature = "blocking-io", async(feature = "async-io", async_std::test))]
        async fn trailing_line_feeds_are_removed_explicitly() -> crate::Result {
            let line = decode::all_at_once(b"0006a\n")?;
            assert_eq!(line.as_text().expect("text").0.as_bstr(), b"a".as_bstr());
            let mut out = Vec::new();
            line.as_text()
                .expect("text")
                .write_to(&mut out)
                .await
                .expect("write to memory works");
            assert_eq!(out, b"0006a\n", "it appends a newline in text mode");
            Ok(())
        }

        #[maybe_async::test(feature = "blocking-io", async(feature = "async-io", async_std::test))]
        async fn all_kinds_of_packetlines() -> crate::Result {
            for (line, bytes) in &[
                (PacketLine::ResponseEnd, 4),
                (PacketLine::Delimiter, 4),
                (PacketLine::Flush, 4),
                (PacketLine::Data(b"hello there"), 15),
            ] {
                let mut out = Vec::new();
                line.write_to(&mut out).await?;
                assert_complete(streaming(&out), *bytes, *line)?;
            }
            Ok(())
        }

        #[maybe_async::test(feature = "blocking-io", async(feature = "async-io", async_std::test))]
        async fn error_line() -> crate::Result {
            let mut out = Vec::new();
            PacketLine::Data(b"the error")
                .as_error()
                .expect("data line")
                .write_to(&mut out)
                .await?;
            let line = decode::all_at_once(&out)?;
            assert_eq!(line.check_error().expect("err").0, b"the error");
            Ok(())
        }

        #[maybe_async::test(feature = "blocking-io", async(feature = "async-io", async_std::test))]
        async fn side_bands() -> crate::Result {
            for channel in &[Channel::Data, Channel::Error, Channel::Progress] {
                let mut out = Vec::new();
                let band = PacketLine::Data(b"band data")
                    .as_band(*channel)
                    .expect("data is valid for band");
                band.write_to(&mut out).await?;
                let line = decode::all_at_once(&out)?;
                assert_eq!(line.decode_band().expect("valid band"), band);
            }
            Ok(())
        }
    }

    #[test]
    fn flush() -> crate::Result {
        assert_complete(streaming(b"0000someotherstuff"), 4, PacketLine::Flush)
    }

    #[test]
    fn trailing_line_feeds_are_not_removed_automatically() -> crate::Result {
        assert_complete(streaming(b"0006a\n"), 6, PacketLine::Data(b"a\n"))
    }

    #[test]
    fn ignore_extra_bytes() -> crate::Result {
        assert_complete(streaming(b"0006a\nhello"), 6, PacketLine::Data(b"a\n"))
    }

    #[test]
    fn error_on_oversized_line() {
        assert_err_display(
            streaming(b"ffff"),
            "The data received claims to be larger than than the maximum allowed size: got 65535, exceeds 65516",
        );
    }

    #[test]
    fn error_on_error_line() -> crate::Result {
        let line = PacketLine::Data(b"ERR the error");
        assert_complete(
            streaming(b"0011ERR the error-and just ignored because not part of the size"),
            17,
            line,
        )?;
        assert_eq!(
            line.check_error().expect("error to be parsed here"),
            Error(b"the error")
        );
        Ok(())
    }

    #[test]
    fn error_on_invalid_hex() {
        assert_err_display(
            streaming(b"fooo"),
            "Failed to decode the first four hex bytes indicating the line length: Invalid character 'o' at position 1",
        );
    }

    #[test]
    fn error_on_empty_line() {
        assert_err_display(streaming(b"0004"), "Received an invalid empty line");
    }

    mod incomplete {
        use git_packetline::decode::{self, streaming, Stream};

        fn assert_incomplete(res: Result<Stream, decode::Error>, expected_missing: usize) -> crate::Result {
            match res? {
                Stream::Complete { .. } => {
                    panic!("expected parsing to be partial, not complete");
                }
                Stream::Incomplete { bytes_needed } => {
                    assert_eq!(bytes_needed, expected_missing);
                }
            }
            Ok(())
        }

        #[test]
        fn missing_hex_bytes() -> crate::Result {
            assert_incomplete(streaming(b"0"), 3)?;
            assert_incomplete(streaming(b"00"), 2)?;
            Ok(())
        }

        #[test]
        fn missing_data_bytes() -> crate::Result {
            assert_incomplete(streaming(b"0005"), 1)?;
            assert_incomplete(streaming(b"0006a"), 1)?;
            Ok(())
        }
    }
}