#pragma once
#include <cstddef>
#include <cstdint>
#include <memory>

namespace lzokay {

enum class EResult {
  LookbehindOverrun = -4,
  OutputOverrun = -3,
  InputOverrun = -2,
  Error = -1,
  Success = 0,
  InputNotConsumed = 1,
};

class DictBase {
protected:
  static constexpr uint32_t HashSize = 0x4000;
  static constexpr uint32_t MaxDist = 0xbfff;
  static constexpr uint32_t MaxMatchLen = 0x800;
  static constexpr uint32_t BufSize = MaxDist + MaxMatchLen;

  /* List encoding of previous 3-byte data matches */
  struct Match3 {
    uint16_t head[HashSize]; /* key -> chain-head-pos */
    uint16_t chain_sz[HashSize]; /* key -> chain-size */
    uint16_t chain[BufSize]; /* chain-pos -> next-chain-pos */
    uint16_t best_len[BufSize]; /* chain-pos -> best-match-length */
  };
  /* Encoding of 2-byte data matches */
  struct Match2 {
    uint16_t head[1 << 16]; /* 2-byte-data -> head-pos */
  };

  struct Data {
    Match3 match3;
    Match2 match2;

    /* Circular buffer caching enough data to access the maximum lookback
     * distance of 48K + maximum match length of 2K. An additional 2K is
     * allocated so the start of the buffer may be replicated at the end,
     * therefore providing efficient circular access.
     */
    uint8_t buffer[BufSize + MaxMatchLen];
  };
  using storage_type = Data;
  storage_type* _storage;
  DictBase() = default;
  friend struct State;
  friend EResult compress(const uint8_t* src, std::size_t src_size,
                          uint8_t* dst, std::size_t& dst_size, DictBase& dict);
};
template <template<typename> class _Alloc = std::allocator>
class Dict : public DictBase {
  _Alloc<DictBase::storage_type> _allocator;
public:
  Dict() { _storage = _allocator.allocate(1); }
  ~Dict() { _allocator.deallocate(_storage, 1); }
};

EResult decompress(const uint8_t* src, std::size_t src_size,
                   uint8_t* dst, std::size_t dst_size,
                   std::size_t& out_size);
EResult compress(const uint8_t* src, std::size_t src_size,
                 uint8_t* dst, std::size_t dst_size,
                 std::size_t& out_size, DictBase& dict);
inline EResult compress(const uint8_t* src, std::size_t src_size,
                        uint8_t* dst, std::size_t dst_size,
                        std::size_t& out_size) {
  Dict<> dict;
  return compress(src, src_size, dst, dst_size, out_size, dict);
}

constexpr std::size_t compress_worst_size(std::size_t s) {
  return s + s / 16 + 64 + 3;
}

}