//! Varint is an alternative way of storing integer numbers.
//! 
//! Varints allow for the storage of larger integer types in a smaller amount of
//! space. It does this by storing an integer using the `7` lower bits and a flag
//! in the most-significant bit. This flag is set to `1` when more bytes should
//! be read. The groups of `7` bits are then added from the least-significant
//! group first.
//! 
//! ## Example
//! ```
//! // to allow the use of the `VarintWriter::write_*_varint` functions
//! use varint_rs::VarintWriter;
//! // to allow the use of the `VarintReader::read_*_varint` functions
//! use varint_rs::VarintReader;
//! 
//! // an example to use for the buffer
//! use std::io::Cursor;
//! 
//! // create an i32 set to `300`
//! let number: i32 = 300;
//! // create a buffer for the varint to be writen to
//! // an i32 can be `4` bytes maximum, so we pre-allocate the capacity
//! let mut buffer: Cursor<Vec<u8>> = Cursor::new(Vec::with_capacity(4));
//! 
//! // now we can write the varint into the buffer
//! // `300` should only use `2` bytes instead of all `4`
//! // the `write_*_varint` functions may return an `std::io::Error`
//! buffer.write_i32_varint(number).unwrap();
//! 
//! // we reset the cursor pos back to `0`, this isn't varint stuff
//! buffer.set_position(0);
//! 
//! // now we can read the varint from the buffer
//! // we should read `300` which was the number we stored
//! // the `read_*_varint` functions may return an `std::io::Error`
//! let number: i32 = buffer.read_i32_varint().unwrap();
//! ```

pub mod zigzag;
pub use zigzag::Zigzag;

use std::io;

/// The `VarintReader` trait enables reading of varints.
/// 
/// This is pre-implemented on structures which implement `std::io::Read`. It also
/// extends the `std::io::Read` trait to allow for reading from valid *readers*.
pub trait VarintReader: io::Read {
  /// Reads an i8 from a signed 8-bit varint.
  fn read_i8_varint(&mut self) -> Result<i8, io::Error> {
    match self.read_u8_varint() {
      Ok(value) => Ok(value.zigzag()),
      Err(error) => Err(error)
    }
  }

  /// Reads a u8 from an unsigned 8-bit varint.
  fn read_u8_varint(&mut self) -> Result<u8, io::Error> {
    let mut shift: u8 = 0;
    let mut decoded: u8 = 0;
    let mut buf: [u8; 1] = [0];
    let mut next: u8 = 0;

    loop {
      match self.read(&mut buf) {
        Ok(count) => {
          if count == 1 {
            next = buf[0];
          } else {
            Err(io::Error::new(io::ErrorKind::UnexpectedEof, "could not read byte"))?
          }
        },
        Err(error) => Err(error)?
      }

      decoded |= ((next & 0b01111111) as u8) << shift;

      if next & 0b10000000 == 0b10000000 {
        shift += 7;
      } else {
        return Ok(decoded)
      }
    }
  }

  /// Reads an i16 from a signed 16-bit varint.
  fn read_i16_varint(&mut self) -> Result<i16, io::Error> {
    match self.read_u16_varint() {
      Ok(value) => Ok(value.zigzag()),
      Err(error) => Err(error)
    }
  }

  /// Reads a u16 from an unsigned 16-bit varint.
  fn read_u16_varint(&mut self) -> Result<u16, io::Error> {
    let mut shift: u16 = 0;
    let mut decoded: u16 = 0;
    let mut buf: [u8; 1] = [0];
    let mut next: u8 = 0;

    loop {
      match self.read(&mut buf) {
        Ok(count) => {
          if count == 1 {
            next = buf[0];
          } else {
            Err(io::Error::new(io::ErrorKind::UnexpectedEof, "could not read byte"))?
          }
        },
        Err(error) => Err(error)?
      }

      decoded |= ((next & 0b01111111) as u16) << shift;

      if next & 0b10000000 == 0b10000000 {
        shift += 7;
      } else {
        return Ok(decoded)
      }
    }
  }

  /// Reads an i32 from a signed 32-bit varint.
  fn read_i32_varint(&mut self) -> Result<i32, io::Error> {
    match self.read_u32_varint() {
      Ok(value) => Ok(value.zigzag()),
      Err(error) => Err(error)
    }
  }

  /// Reads a u32 from an unsigned 32-bit varint.
  fn read_u32_varint(&mut self) -> Result<u32, io::Error> {
    let mut shift: u32 = 0;
    let mut decoded: u32 = 0;
    let mut buf: [u8; 1] = [0];
    let mut next: u8 = 0;

    loop {
      match self.read(&mut buf) {
        Ok(count) => {
          if count == 1 {
            next = buf[0];
          } else {
            Err(io::Error::new(io::ErrorKind::UnexpectedEof, "could not read byte"))?
          }
        },
        Err(error) => Err(error)?
      }

      decoded |= ((next & 0b01111111) as u32) << shift;

      if next & 0b10000000 == 0b10000000 {
        shift += 7;
      } else {
        return Ok(decoded)
      }
    }
  }

  /// Reads an i64 from a signed 64-bit varint.
  fn read_i64_varint(&mut self) -> Result<i64, io::Error> {
    match self.read_u64_varint() {
      Ok(value) => Ok(value.zigzag()),
      Err(error) => Err(error)
    }
  }

  /// Reads a u64 from an unsigned 64-bit varint.
  fn read_u64_varint(&mut self) -> Result<u64, io::Error> {
    let mut shift: u64 = 0;
    let mut decoded: u64 = 0;
    let mut buf: [u8; 1] = [0];
    let mut next: u8 = 0;

    loop {
      match self.read(&mut buf) {
        Ok(count) => {
          if count == 1 {
            next = buf[0];
          } else {
            Err(io::Error::new(io::ErrorKind::UnexpectedEof, "could not read byte"))?
          }
        },
        Err(error) => Err(error)?
      }

      decoded |= ((next & 0b01111111) as u64) << shift;

      if next & 0b10000000 == 0b10000000 {
        shift += 7;
      } else {
        return Ok(decoded)
      }
    }
  }

  /// Reads an i128 from a signed 128-bit varint.
  fn read_i128_varint(&mut self) -> Result<i128, io::Error> {
    match self.read_u128_varint() {
      Ok(value) => Ok(value.zigzag()),
      Err(error) => Err(error)
    }
  }

  /// Reads a u128 from an unsigned 128-bit varint.
  fn read_u128_varint(&mut self) -> Result<u128, io::Error> {
    let mut shift: u128 = 0;
    let mut decoded: u128 = 0;
    let mut buf: [u8; 1] = [0];
    let mut next: u8 = 0;

    loop {
      match self.read(&mut buf) {
        Ok(count) => {
          if count == 1 {
            next = buf[0];
          } else {
            Err(io::Error::new(io::ErrorKind::UnexpectedEof, "could not read byte"))?
          }
        },
        Err(error) => Err(error)?
      }

      decoded |= ((next & 0b01111111) as u128) << shift;

      if next & 0b10000000 == 0b10000000 {
        shift += 7;
      } else {
        return Ok(decoded)
      }
    }
  }

  /// Reads an isize from a signed size-bit varint.
  fn read_isize_varint(&mut self) -> Result<isize, io::Error> {
    match self.read_usize_varint() {
      Ok(value) => Ok(value.zigzag()),
      Err(error) => Err(error)
    }
  }

  /// Reads a usize from an unsigned size-bit varint.
  fn read_usize_varint(&mut self) -> Result<usize, io::Error> {
    let mut shift: usize = 0;
    let mut decoded: usize = 0;
    let mut buf: [u8; 1] = [0];
    let mut next: u8 = 0;

    loop {
      match self.read(&mut buf) {
        Ok(count) => {
          if count == 1 {
            next = buf[0];
          } else {
            Err(io::Error::new(io::ErrorKind::UnexpectedEof, "could not read byte"))?
          }
        },
        Err(error) => Err(error)?
      }

      decoded |= ((next & 0b01111111) as usize) << shift;

      if next & 0b10000000 == 0b10000000 {
        shift += 7;
      } else {
        return Ok(decoded)
      }
    }
  }
}

impl<R: io::Read> VarintReader for R {}

/// The `VarintWriter` trait enable writing of varints.
/// 
/// This is pre-implemented on structures which implement `std::io::Write`. It also
/// extends the `std::io::Write` trait to allow for writing to valid *writes"*.
pub trait VarintWriter: io::Write {
  /// Writes an i8 to a signed 8-bit varint.
  fn write_i8_varint(&mut self, value: i8) -> Result<(), io::Error> {
    self.write_u8_varint(value.zigzag())
  }

  /// Writes a u8 to an unsigned 8-bit varint.
  fn write_u8_varint(&mut self, value: u8) -> Result<(), io::Error> {
    let mut value: u8 = value;

    if value == 0 {
      self.write_all(&[0])
    } else {
      while value >= 0b10000000 {
        let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
        value >>= 7;

        match self.write_all(&[next]) {
          Err(error) => Err(error)?,
          Ok(_) => ()
        }
      }

      self.write_all(&[(value & 0b01111111) as u8])
    }
  }

  /// Writes an i16 to a signed 16-bit varint.
  fn write_i16_varint(&mut self, value: i16) -> Result<(), io::Error> {
    self.write_u16_varint(value.zigzag())
  }

  /// Writes a u16 to an unsigned 16-bit varint.
  fn write_u16_varint(&mut self, value: u16) -> Result<(), io::Error> {
    let mut value: u16 = value;

    if value == 0 {
      self.write_all(&[0])
    } else {
      while value >= 0b10000000 {
        let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
        value >>= 7;

        match self.write_all(&[next]) {
          Err(error) => Err(error)?,
          Ok(_) => ()
        }
      }

      self.write_all(&[(value & 0b01111111) as u8])
    }
  }

  /// Writes an i32 to a signed 32-bit varint.
  fn write_i32_varint(&mut self, value: i32) -> Result<(), io::Error> {
    self.write_u32_varint(value.zigzag())
  }

  /// Writes a u32 to an unsigned 32-bit varint.
  fn write_u32_varint(&mut self, value: u32) -> Result<(), io::Error> {
    let mut value: u32 = value;

    if value == 0 {
      self.write_all(&[0])
    } else {
      while value >= 0b10000000 {
        let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
        value >>= 7;

        match self.write_all(&[next]) {
          Err(error) => Err(error)?,
          Ok(_) => ()
        }
      }

      self.write_all(&[(value & 0b01111111) as u8])
    }
  }

  /// Writes an i64 to a signed 64-bit varint.
  fn write_i64_varint(&mut self, value: i64) -> Result<(), io::Error> {
    self.write_u64_varint(value.zigzag())
  }

  /// Writes a u64 to an unsigned 64-bit varint.
  fn write_u64_varint(&mut self, value: u64) -> Result<(), io::Error> {
    let mut value: u64 = value;

    if value == 0 {
      self.write_all(&[0])
    } else {
      while value >= 0b10000000 {
        let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
        value >>= 7;

        match self.write_all(&[next]) {
          Err(error) => Err(error)?,
          Ok(_) => ()
        }
      }

      self.write_all(&[(value & 0b01111111) as u8])
    }
  }

  /// Writes an i128 to a signed 128-bit varint.
  fn write_i128_varint(&mut self, value: i128) -> Result<(), io::Error> {
    self.write_u128_varint(value.zigzag())
  }

  /// Writes a u128 to an unsigned 128-bit varint.
  fn write_u128_varint(&mut self, value: u128) -> Result<(), io::Error> {
    let mut value: u128 = value;

    if value == 0 {
      self.write_all(&[0])
    } else {
      while value >= 0b10000000 {
        let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
        value >>= 7;

        match self.write_all(&[next]) {
          Err(error) => Err(error)?,
          Ok(_) => ()
        }
      }

      self.write_all(&[(value & 0b01111111) as u8])
    }
  }

  /// Writes an isize to a signed size-bit varint.
  fn write_isize_varint(&mut self, value: isize) -> Result<(), io::Error> {
    self.write_usize_varint(value.zigzag())
  }

  /// Writes a usize to an unsigned size-bit varint.
  fn write_usize_varint(&mut self, value: usize) -> Result<(), io::Error> {
    let mut value: usize = value;

    if value == 0 {
      self.write_all(&[0])
    } else {
      while value >= 0b10000000 {
        let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
        value >>= 7;

        match self.write_all(&[next]) {
          Err(error) => Err(error)?,
          Ok(_) => ()
        }
      }

      self.write_all(&[(value & 0b01111111) as u8])
    }
  }
}

impl<W: io::Write> VarintWriter for W {}