//
// Dis VM
// File: buffered_reader.h
// Author: arr
//

#ifndef _DISVM_SRC_INCLUDE_BUFFERED_READER_H_
#define _DISVM_SRC_INCLUDE_BUFFERED_READER_H_

#include <cstdint>
#include <cassert>
#include <vector>
#include <sstream>
#include <tuple>
#include <iosfwd>

namespace disvm
{
    namespace util
    {
        class buffered_reader_t
        {
        public:
            buffered_reader_t(std::istream &stream)
                : _buffer(64 * 1024) // 64k is an optimization for the Windows filesystem manager
                , _current_index{ 0 }
                , _current_size{ 0 }
                , _stream{ stream }
            {
                assert(!stream.fail());
            }

            buffered_reader_t(const buffered_reader_t&) = delete;
            buffered_reader_t& operator=(const buffered_reader_t&) = delete;

            // Get the next 'n' number of bytes.
            // Returns the number of bytes retrieved.
            uint32_t get_next_bytes(uint32_t bytes_requested, uint8_t *buffer)
            {
                if (bytes_requested == 0)
                    return 0;

                assert(buffer != nullptr);

                auto bytes_requested_acc = uint32_t{ 0 };

                for (;;)
                {
                    const auto amount_in_buffer = check_buffer_content();
                    if (amount_in_buffer == 0)
                        return 0;

                    // Buffer contains requested amount
                    if (bytes_requested <= amount_in_buffer)
                    {
                        std::memcpy(buffer, (_buffer.data() + _current_index), bytes_requested);
                        _current_index += bytes_requested;
                        bytes_requested_acc += bytes_requested;
                        return bytes_requested_acc;
                    }
                    else
                    {
                        // Buffer does not contain all the data requested
                        std::memcpy(buffer, (_buffer.data() + _current_index), amount_in_buffer);
                        _current_index += amount_in_buffer;

                        // Subtract the bytes consumed
                        bytes_requested -= amount_in_buffer;

                        bytes_requested_acc += amount_in_buffer;
                        buffer += amount_in_buffer;
                    }
                }
            }

            // Read from the stream as a string until the supplied delimiter is encountered.
            std::string get_as_string_until(const char delim)
            {
                std::stringstream ss;
                auto amount_in_buffer = check_buffer_content();
                while (amount_in_buffer != 0)
                {
                    while (_current_index < _current_size)
                    {
                        auto c = _buffer[_current_index++];
                        if (c == delim)
                            return ss.str();

                        ss << c;
                    }

                    amount_in_buffer = check_buffer_content();
                }

                return{};
            }

            // Read from the stream until the supplied value is encountered.
            bool get_bytes_until(const uint8_t delim, std::vector<uint8_t> &byte_buffer)
            {
                auto amount_in_buffer = check_buffer_content();
                while (amount_in_buffer != 0)
                {
                    while(_current_index < _current_size)
                    {
                        auto b = _buffer[_current_index++];
                        if (b == delim)
                            return true;

                        byte_buffer.push_back(b);
                    }

                    amount_in_buffer = check_buffer_content();
                }

                return false;
            }

            // Get the next byte in the buffer.
            // Returns success and the byte.
            std::tuple<bool, uint8_t> get_next_byte()
            {
                const auto amount_in_buffer = check_buffer_content();
                if (amount_in_buffer == 0)
                    return std::make_tuple(false, 0);

                return std::make_tuple(true, _buffer[_current_index++]);
            }

        private:
            std::size_t check_buffer_content()
            {
                if (_current_size <= _current_index)
                {
                    _current_index = 0;
                    _current_size = 0;

                    if (_stream.fail())
                        return 0;

                    _stream.read(_buffer.data(), _buffer.size());

                    // If the stream has failed, set the current size, otherwise the buffer size
                    _current_size = _stream.fail() ? static_cast<std::size_t>(_stream.gcount()) : _buffer.size();
                }

                return _current_size - _current_index;
            }

        private:
            std::istream &_stream;
            std::size_t _current_index;
            std::size_t _current_size;
            std::vector<char> _buffer;
        };
    }
}

#endif // _DISVM_SRC_INCLUDE_BUFFERED_READER_H_