#pragma once

#include <concepts>

#include "pod.hpp"

class ArenaHeap {
 public:
  ArenaHeap(uint8_t* buf, uint64_t bufsize)
      : buf(buf), bufsize(bufsize), boundary(0) {}

 private:
  uint8_t* buf;
  uint64_t bufsize;
  uint64_t boundary;
};

class Arena {
 public:
  Arena(ArenaHeap* first, ArenaHeap* second)
      : _heaps{first, second}, _current(0) {}

 private:
  ArenaHeap* _heaps[2];
  int _current;
};

template <uint64_t size>
class StaticArenaHeap {
 public:
  StaticArenaHeap() : _heap(_buf, heapsize) {}

  ArenaHeap* get() { return &_heap; }

  template <class T>
  T* alloc(uint64_t extra = 0)
    requires std::derived_from<T, PodObject>
  {
    return 0;
  }

 private:
  static const uint64_t heapsize = size - sizeof(ArenaHeap);
  ArenaHeap _heap;
  uint8_t _buf[heapsize]{0};
};

template <uint64_t size>
class StaticArena {
 public:
  StaticArena() : _arena(_heaps[0].get(), _heaps[1].get()) {}

 private:
  StaticArenaHeap<(size - sizeof(Arena)) / 2> _heaps[2];
  Arena _arena;
};