#ifndef BITOPS_H
#define BITOPS_H

#define RBITS( c, n )		( c & ( 0xFF >> (8 - n) ) )
#define LBITS( c, n )		( c >> (8 - n) )
#define MBITS( c, l, r )	( RBITS( c,l ) >> r )
#define BITN( c, n )		( (c >> n) & 0x1 )
#define BITLEN( l, v )		for ( l = 0; ( v >> l ) > 0; l++ )
#define FDIV2( v, p )		( ( v < 0 ) ? -( (-v) >> p ) : ( v >> p ) )

#include <cstdint>
#include <memory>
#include <string>
#include <vector>

	
/* -----------------------------------------------
	class to read arrays bitwise
	----------------------------------------------- */
class BitReader {
public:
	BitReader( unsigned char* array, int size );
	~BitReader();	
	unsigned int read( int nbits );
	unsigned char read_bit();
	unsigned char unpad( unsigned char fillbit );
	int getpos();
	int getbitp();
	void setpos( int pbyte, int pbit );
	void rewind_bits( int nbits );
	bool eof();
	int peof();
	
private:
    void update_curr_byte();

	unsigned char* data = nullptr;
	int lbyte = 0;
	int cbyte = 0;
	int cbit = 8;
	int peof_ = 0;
	bool eof_ = false;
};


class BitWriter {
public:
	BitWriter(std::uint8_t padbit);
	~BitWriter();
	/*
	* Writes the first (lowest) n bits from val (n is assumed to be less than or equal to 16).
	*/
	void write_u16(std::uint16_t val, std::size_t num_bits);

	/*
	* Writes the bit (assumed to be 0 or 1).
	*/
	void write_bit(std::uint8_t bit);
	/**
	* Fills in the remainder of the current byte using the padbit.
	*/
	void pad();
    /**
    * Returns a copy of the bytes written to the writer, padding the current byte if necessary.
    */
	std::vector<std::uint8_t> get_bytes();
    /**
    * Allocates and returns a copy of the bytes written to the writer, padding the current byte if necessary.
    */
    unsigned char* get_c_bytes();
	/*
	* Returns the number of bytes written. If a byte has not been fully written (e.g., only 5 bits have been written),
	* then it is not counted in the number of bytes written.
	*/
	std::size_t num_bytes_written() const;
private:
	void write_curr_byte();

	std::vector<std::uint8_t> bytes_;
	const std::uint8_t padbit_; // A bit, either 0 or 1, to fill the unwritten bits of the current byte with.
	std::uint8_t curr_byte_ = 0; // The current byte being written.
	std::size_t curr_bit_ = 8; // The position of the next bit in the current byte.
};

class Reader {
public:
	Reader() {}

	virtual ~Reader() {}

	/*
	* Reads the minimum of n and the number of unread bytes to the pointer.
	*/
	virtual std::size_t read(std::uint8_t* to, std::size_t n) = 0;

	/*
	* Reads the minimum of n and the number of unread bytes to the vector, starting at the given offset in the
	* vector. If the destination vector is too small, it is resized. Returns the number of bytes read.
	*/
	virtual std::size_t read(std::vector<std::uint8_t>& into, std::size_t n, std::size_t offset = 0) = 0;

	/*
	* Returns one byte from the reader, throwing a std::runtime_error exception if there are none left to read.
	*/
	virtual std::uint8_t read_byte() = 0;

	/*
	* Reads one byte to the pointer, returning whether there was a byte available to writer.
	*/
	virtual bool read_byte(std::uint8_t* to) = 0;

	/*
	 * Skips the minimum of the n and the number of unread bytes left in the reader.
	 */
	virtual void skip(std::size_t n) = 0;

	/*
	 * Moves the reader back by the minimum of n and the number of bytes already read in the reader.
	 */
	virtual void rewind_bytes(std::size_t n) = 0;

	/*
	* Resets the number of bytes read to zero.
	*/
	virtual void rewind() = 0;

	/*
	* Returns the number of bytes read.
	*/
	virtual std::size_t num_bytes_read() = 0;

	/*
	* Returns the number of bytes in the reader.
	*/
	virtual std::size_t get_size() = 0;

	/*
	* Returns a copy of the data backing the reader.
	*/
	virtual std::vector<std::uint8_t> get_data() = 0;

    unsigned char* get_c_data();

	virtual bool error() = 0;
	/*
	* Returns whether all bytes in the reader have been read.
	*/
	virtual bool end_of_reader() = 0;
};

class MemoryReader : public Reader {
public:
	MemoryReader(const std::vector<std::uint8_t>& bytes);
    MemoryReader(const std::uint8_t* bytes, std::size_t size);

	~MemoryReader() {}

	std::size_t read(std::uint8_t* to, std::size_t num_to_read) override;
	std::size_t read(std::vector<std::uint8_t>& into, std::size_t num_to_read, std::size_t offset = 0) override;
	std::uint8_t read_byte() override;
	bool read_byte(std::uint8_t* to) override;

	void skip(std::size_t n) override;
	void rewind_bytes(std::size_t n) override;
	void rewind() override;

	std::size_t num_bytes_read() override;
	std::size_t get_size() override;
	std::vector<std::uint8_t> get_data() override;
	bool error() override;
	bool end_of_reader() override;

private:
	const std::vector<std::uint8_t> data_;
	std::vector<std::uint8_t>::const_iterator cbyte_; // The position in the data of the byte being read.
};

class FileReader : public Reader {
public:
	FileReader(const std::string& file_path);
	~FileReader();

	std::size_t read(std::uint8_t* to, std::size_t num_to_read) override;
	std::size_t read(std::vector<std::uint8_t>& into, std::size_t num_to_read, std::size_t offset = 0) override;
	std::uint8_t read_byte() override;
	bool read_byte(std::uint8_t* to) override;

	void skip(std::size_t n) override;
	void rewind_bytes(std::size_t n) override;
	void rewind() override;

	std::size_t num_bytes_read() override;
	std::size_t get_size() override;
	std::vector<std::uint8_t> get_data() override;
	bool error() override;
	bool end_of_reader() override;

private:
	std::unique_ptr<MemoryReader> reader_;
};

class StreamReader : public Reader {
public:
	StreamReader();

	~StreamReader() {}

	std::size_t read(std::uint8_t* to, std::size_t num_to_read) override;
	std::size_t read(std::vector<std::uint8_t>& into, std::size_t num_to_read, std::size_t offset = 0) override;
	std::uint8_t read_byte() override;
	bool read_byte(std::uint8_t* to) override;

	void skip(std::size_t n) override;
	void rewind_bytes(std::size_t n) override;
	void rewind() override;

	std::size_t num_bytes_read() override;
	std::size_t get_size() override;
	std::vector<std::uint8_t> get_data() override;
	bool error() override;
	bool end_of_reader() override;

private:
	std::unique_ptr<MemoryReader> reader_;
};

class Writer {
public:
	Writer() {}

	virtual ~Writer() {}

	virtual std::size_t write(const std::uint8_t* from, std::size_t n) = 0;
	virtual std::size_t write(const std::vector<std::uint8_t>& bytes) = 0;
	virtual std::size_t write(const std::array<std::uint8_t, 2>& bytes) = 0;

	virtual bool write_byte(std::uint8_t byte) = 0;

	virtual std::vector<std::uint8_t> get_data() = 0;
    unsigned char* get_c_data();

	virtual void reset() = 0;
	virtual std::size_t num_bytes_written() = 0;
	virtual bool error() = 0;
};

class MemoryWriter : public Writer {
public:
	MemoryWriter();

	~MemoryWriter() {}

	std::size_t write(const std::uint8_t* from, std::size_t n) override;
	std::size_t write(const std::vector<std::uint8_t>& bytes) override;
	std::size_t write(const std::array<std::uint8_t, 2>& bytes) override;
	bool write_byte(std::uint8_t byte) override;

	std::vector<std::uint8_t> get_data() override;

	void reset() override;
	std::size_t num_bytes_written() override;
	bool error() override;

private:
	std::vector<std::uint8_t> data_;
};

class FileWriter : public Writer {
public:
	FileWriter(const std::string& file_path);
	~FileWriter();

	std::size_t write(const std::uint8_t* from, std::size_t n) override;
	std::size_t write(const std::vector<std::uint8_t>& bytes) override;
	std::size_t write(const std::array<std::uint8_t, 2>& bytes) override;
	bool write_byte(std::uint8_t byte) override;

	std::vector<std::uint8_t> get_data() override;

	void reset() override;
	std::size_t num_bytes_written() override;
	bool error() override;

private:
	FILE* fptr_ = nullptr;
	std::vector<char> file_buffer_; // Used to replace the default file buffer for reads/writes to improve performance.
	const std::string file_path_;
};

class StreamWriter : public Writer {
public:
	StreamWriter();
	~StreamWriter();

	std::size_t write(const std::uint8_t* from, std::size_t n) override;
	std::size_t write(const std::vector<std::uint8_t>& bytes) override;
	std::size_t write(const std::array<std::uint8_t, 2>& bytes) override;
	bool write_byte(std::uint8_t byte) override;

	std::vector<std::uint8_t> get_data() override;

	void reset() override;
	std::size_t num_bytes_written() override;
	bool error() override;

private:
	std::unique_ptr<MemoryWriter> writer_;
};

#endif