#pragma once

#include <memory_resource>
#include <rublon/stdlib.hpp>

namespace rublon {
namespace memory {
    namespace literals {
        constexpr std::uint64_t operator""_kB(unsigned long long kilobytes) {
            return kilobytes * 1024ULL;
        }
    } // namespace literals

    struct default_memory_resource {
        static inline std::pmr::memory_resource * _mr = std::pmr::get_default_resource();
    };

    inline void set_default_resource(std::pmr::memory_resource * memory_resource) {
        default_memory_resource{}._mr = memory_resource;
    }

    inline std::pmr::memory_resource * default_resource() {
        return default_memory_resource{}._mr;
    }

    class MonotonicResourceBase {
      public:
        std::pmr::memory_resource * _upstream{};
        std::size_t _size{};
        void * _buffer{nullptr};

        MonotonicResourceBase(std::size_t size) : _upstream{default_resource()}, _size{size}, _buffer{_upstream->allocate(size)} {}

        ~MonotonicResourceBase() {
            if(_buffer)
                _upstream->deallocate(_buffer, _size);
        }
    };

    template < std::size_t N >
    class MonotonicResource : MonotonicResourceBase, public std::pmr::monotonic_buffer_resource {
      public:
        MonotonicResource(std::pmr::memory_resource * mr = default_resource())
         : MonotonicResourceBase{N}, std::pmr::monotonic_buffer_resource{this->_buffer, this->_size, mr} {}
    };

    template < std::size_t N >
    class MonotonicStackResourceBase {
      public:
        char _buffer[N];
    };

    template < std::size_t N >
    class MonotonicStackResource : MonotonicStackResourceBase< N >, public std::pmr::monotonic_buffer_resource {
      public:
        MonotonicStackResource()
         : MonotonicStackResourceBase< N >{}, std::pmr::monotonic_buffer_resource{this->_buffer, N, default_resource()} {}
    };
    
    using MonotonicStack_1k_Resource = MonotonicStackResource< 1 * 1024 >;
    using MonotonicStack_2k_Resource = MonotonicStackResource< 2 * 1024 >;
    
    
    using Monotonic_1k_Resource = MonotonicResource< 1 * 1024 >;
    using Monotonic_2k_Resource = MonotonicResource< 2 * 1024 >;
    using Monotonic_4k_Resource = MonotonicResource< 4 * 1024 >;
    using Monotonic_8k_Resource = MonotonicResource< 8 * 1024 >;
} // namespace memory

// class RublonMemory {
//   public:
//     std::byte sharedMemory[32 * 1024] = {};
//     std::pmr::monotonic_buffer_resource mr{sharedMemory, std::size(sharedMemory)};
//     std::pmr::unsynchronized_pool_resource rublonPoolResource{&mr};

//     RublonMemory() {
//         std::pmr::set_default_resource(&rublonPoolResource);
//     }
// };
} // namespace rublon