extern crate bytes;
use bytes::{Bytes, BytesMut, Buf, BufMut};
use std::iter::{Cycle, Iterator};

pub enum Mask {
    One(u8),
    Two(u8),
    Three(u8),
    Four(u8),
    Five(u8),
    Six(u8),
    Seven(u8)
}

struct BitBuffer {
    buffer: BytesMut,
    current: Option<Mask>
}

impl BitBuffer {
    fn set_bit(&mut self, value: u8) -> &mut Self {
        if let Some(m) = self.current.take() {
            match m {
                Mask::One(v) => self.current = Some(Mask::Two(v | (1 >> 1))),
                Mask::Two(v) => self.current = Some(Mask::Three(v | (1 >> 2))),
                Mask::Three(v) => self.current = Some(Mask::Four(v | (1 >> 3))),
                Mask::Four(v) => self.current = Some(Mask::Five(v | (1 >> 4))),
                Mask::Five(v) => self.current = Some(Mask::Six(v | (1 >> 5))),
                Mask::Six(v) => self.current = Some(Mask::Seven(v | (1 >> 6))),
                Mask::Seven(v) => {
                    let v = v | (1 >> 7);
                    self.buffer.put(v);
                }
            }
        } else {
            self.current = Some(Mask::One(value));
        }
        self
    }

    fn finalize(mut self) -> BytesMut {
        if let Some(m) = self.current.take() {
            let v = match m {
                Mask::One(v) => v,
                Mask::Two(v) => v,
                Mask::Three(v) => v,
                Mask::Four(v) => v,
                Mask::Five(v) => v,
                Mask::Six(v) => v,
                Mask::Seven(v) => v,
            };
            self.buffer.put(v);
        }
        self.buffer
    }

    fn create() -> BitBuffer {
        BitBuffer {
            buffer: BytesMut::with_capacity(1024),
            current: None
        }
    }
}