//! Bit level parsers

//!

pub mod complete;

pub mod streaming;

use crate::error::{ErrorKind, ParseError};

use crate::internal::{Err, IResult, Needed, Parser};

use crate::traits::ErrorConvert;

use crate::Input;

/// Converts a byte-level input to a bit-level input, for consumption by a parser that uses bits.

///

/// Afterwards, the input is converted back to a byte-level parser, with any remaining bits thrown

/// away.

///

/// # Example

/// ```

/// use nom::bits::{bits, streaming::take};

/// use nom::error::Error;

/// use nom::IResult;

///

/// fn parse(input: &[u8]) -> IResult<&[u8], (u8, u8)> {

///     bits::<_, _, Error<(&[u8], usize)>, _, _>((take(4usize), take(8usize)))(input)

/// }

///

/// let input = &[0x12, 0x34, 0xff, 0xff];

///

/// let output = parse(input).expect("We take 1.5 bytes and the input is longer than 2 bytes");

///

/// // The first byte is consumed, the second byte is partially consumed and dropped.

/// let remaining = output.0;

/// assert_eq!(remaining, [0xff, 0xff]);

///

/// let parsed = output.1;

/// assert_eq!(parsed.0, 0x01);

/// assert_eq!(parsed.1, 0x23);

/// ```

pub fn bits<I, O, E1, E2, P>(mut parser: P) -> impl FnMut(I) -> IResult<I, O, E2>

where

  E1: ParseError<(I, usize)> + ErrorConvert<E2>,

  E2: ParseError<I>,

  I: Input,

  P: Parser<(I, usize), Output = O, Error = E1>,

{

  move |input: I| match parser.parse((input, 0)) {

    Ok(((rest, offset), result)) => {

      // If the next byte has been partially read, it will be sliced away as well.

      // The parser functions might already slice away all fully read bytes.

      // That's why `offset / 8` isn't necessarily needed at all times.

      let remaining_bytes_index = offset / 8 + if offset % 8 == 0 { 0 } else { 1 };

      Ok((rest.take_from(remaining_bytes_index), result))

    }

    Err(Err::Incomplete(n)) => Err(Err::Incomplete(n.map(|u| u.get() / 8 + 1))),

    Err(Err::Error(e)) => Err(Err::Error(e.convert())),

    Err(Err::Failure(e)) => Err(Err::Failure(e.convert())),

  }

}

/// Counterpart to `bits`, `bytes` transforms its bit stream input into a byte slice for the underlying

/// parser, allowing byte-slice parsers to work on bit streams.

///

/// A partial byte remaining in the input will be ignored and the given parser will start parsing

/// at the next full byte.

///

/// ```

/// use nom::bits::{bits, bytes, streaming::take};

/// use nom::combinator::rest;

/// use nom::error::Error;

/// use nom::IResult;

///

/// fn parse(input: &[u8]) -> IResult<&[u8], (u8, u8, &[u8])> {

///   bits::<_, _, Error<(&[u8], usize)>, _, _>((

///     take(4usize),

///     take(8usize),

///     bytes::<_, _, Error<&[u8]>, _, _>(rest)

///   ))(input)

/// }

///

/// let input = &[0x12, 0x34, 0xff, 0xff];

///

/// assert_eq!(parse( input ), Ok(( &[][..], (0x01, 0x23, &[0xff, 0xff][..]) )));

/// ```

pub fn bytes<I, O, E1, E2, P>(mut parser: P) -> impl FnMut((I, usize)) -> IResult<(I, usize), O, E2>

where

  E1: ParseError<I> + ErrorConvert<E2>,

  E2: ParseError<(I, usize)>,

  I: Input + Clone,

  P: Parser<I, Output = O, Error = E1>,

{

  move |(input, offset): (I, usize)| {

    let inner = if offset % 8 != 0 {

      input.take_from(1 + offset / 8)

    } else {

      input.take_from(offset / 8)

    };

    let i = (input, offset);

    match parser.parse(inner) {

      Ok((rest, res)) => Ok(((rest, 0), res)),

      Err(Err::Incomplete(Needed::Unknown)) => Err(Err::Incomplete(Needed::Unknown)),

      Err(Err::Incomplete(Needed::Size(sz))) => Err(match sz.get().checked_mul(8) {

        Some(v) => Err::Incomplete(Needed::new(v)),

        None => Err::Failure(E2::from_error_kind(i, ErrorKind::TooLarge)),

      }),

      Err(Err::Error(e)) => Err(Err::Error(e.convert())),

      Err(Err::Failure(e)) => Err(Err::Failure(e.convert())),

    }

  }

}

#[cfg(test)]

mod test {

  use super::*;

  use crate::bits::streaming::take;

  use crate::error::Error;

  #[test]

  /// Take the `bits` function and assert that remaining bytes are correctly returned, if the

  /// previous bytes are fully consumed

  fn test_complete_byte_consumption_bits() {

    let input = &[0x12, 0x34, 0x56, 0x78];

    // Take 3 bit slices with sizes [4, 8, 4].

    let result: IResult<&[u8], (u8, u8, u8)> =

      bits::<_, _, Error<(&[u8], usize)>, _, _>((take(4usize), take(8usize), take(4usize)))(input);

    let output = result.expect("We take 2 bytes and the input is longer than 2 bytes");

    let remaining = output.0;

    assert_eq!(remaining, [0x56, 0x78]);

    let parsed = output.1;

    assert_eq!(parsed.0, 0x01);

    assert_eq!(parsed.1, 0x23);

    assert_eq!(parsed.2, 0x04);

  }

  #[test]

  /// Take the `bits` function and assert that remaining bytes are correctly returned, if the

  /// previous bytes are NOT fully consumed. Partially consumed bytes are supposed to be dropped.

  /// I.e. if we consume 1.5 bytes of 4 bytes, 2 bytes will be returned, bits 13-16 will be

  /// dropped.

  fn test_partial_byte_consumption_bits() {

    let input = &[0x12, 0x34, 0x56, 0x78];

    // Take bit slices with sizes [4, 8].

    let result: IResult<&[u8], (u8, u8)> =

      bits::<_, _, Error<(&[u8], usize)>, _, _>((take(4usize), take(8usize)))(input);

    let output = result.expect("We take 1.5 bytes and the input is longer than 2 bytes");

    let remaining = output.0;

    assert_eq!(remaining, [0x56, 0x78]);

    let parsed = output.1;

    assert_eq!(parsed.0, 0x01);

    assert_eq!(parsed.1, 0x23);

  }

  #[test]

  #[cfg(feature = "std")]

  /// Ensure that in Incomplete error is thrown, if too few bytes are passed for a given parser.

  fn test_incomplete_bits() {

    let input = &[0x12];

    // Take bit slices with sizes [4, 8].

    let result: IResult<&[u8], (u8, u8)> =

      bits::<_, _, Error<(&[u8], usize)>, _, _>((take(4usize), take(8usize)))(input);

    assert!(result.is_err());

    let error = result.err().unwrap();

    assert_eq!("Parsing requires 2 bytes/chars", error.to_string());

  }

}