/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Copyright 2021, Danny Robson <danny@nerdcruft.net>
 */

#include "chunked.hpp"

#include "../debug/warn.hpp"
#include "../log.hpp"
#include "../maths.hpp"
#include "../pointer.hpp"


using cruft::alloc::chunked;


///////////////////////////////////////////////////////////////////////////////
chunked::chunked (std::size_t initial_size)
    : chunked (initial_size, DEFAULT_CHUNK_SIZE)
{ ; }


//-----------------------------------------------------------------------------
chunked::chunked (std::size_t initial_size, std::size_t _chunk_size)
    : m_chunk (_chunk_size)
{
    m_chunk = cruft::max (m_chunk, sizeof (allocation_t));

    auto const initial_arenas = cruft::divup (initial_size, m_chunk);
    m_data.resize (initial_arenas);

    for (auto &i: m_data) {
        i.head = i.remain.data  = new std::byte[m_chunk];
        *i.remain.node = {
            .size = m_chunk,
            .next = nullptr
        };
    }
}


//-----------------------------------------------------------------------------
chunked::~chunked () noexcept
{
    for (auto &i: m_data)
        delete [] i.head;
}


///////////////////////////////////////////////////////////////////////////////
void*
chunked::do_allocate (std::size_t size, std::size_t alignment)
{
    // Find a chunk that can service this allocation.
    for (auto &i: m_data) {
        if (i.remain.node->size < size + alignment)
            continue;

        auto base = cruft::align::up (i.remain.data, alignment);
        std::byte* newbase = base + size;
        if (newbase > i.remain.data + i.remain.node->size)
            continue;

        std::size_t newsize = i.remain.data + i.remain.node->size - newbase;

        i.remain.data = newbase;
        i.remain.node->size = newsize;

        return base;
    }

    // No chunk was found. We need to allocate a new chunk of at least enough size.
    std::size_t allocation_size = cruft::max (size + alignment, m_chunk);
    std::unique_ptr<std::byte[]> ptr (new std::byte[allocation_size]);
    m_data.push_back (
        ::cruft::alloc::chunked::arena {
            .head   = ptr.get (),
            .remain = { .data = ptr.get (), },
        }
    );
    m_data.back ().remain.node->size = allocation_size;
    m_data.back ().remain.node->next = m_data.back ().remain.node;
    ptr.release ();
    return do_allocate (size, alignment);
}


//-----------------------------------------------------------------------------
void
chunked::do_deallocate (void *p, std::size_t bytes, std::size_t alignment)
{
    (void)p;
    (void)bytes;
    (void)alignment;

    LOG_WARNING ("chunked::do_deallocate is unimplemented");
}


//-----------------------------------------------------------------------------
bool
chunked::do_is_equal (memory_resource const &) const noexcept
{
    warn ("chunked::do_is_equal is unimplemented");
    return false;
}