/*
 * libfud
 * Copyright 2024 Dominick Allen
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef FUD_ALLOCATOR_HPP
#define FUD_ALLOCATOR_HPP

#include "fud_result.hpp"
#include "fud_status.hpp"

#include <cstddef>
#include <limits>

namespace fud {

/** \brief The default allocation function for globalFudAllocator. */
extern std::byte* fudAlloc(size_t size);

/** \brief The default deallocation function for globalFudAllocator. */
extern void fudFree(std::byte* ptr);

class alignas(std::max_align_t) Allocator {
  public:
    virtual ~Allocator() = default;

    virtual Result<std::byte*, FudStatus> allocate(size_t bytes, size_t alignment = alignof(std::max_align_t)) = 0;

    virtual void deallocate(std::byte* pointer, size_t bytes) = 0;

    virtual bool isEqual(const Allocator& rhs) const = 0;
};

constexpr bool operator==(const Allocator& lhs, const Allocator& rhs)
{
    return &lhs == &rhs;
}

class FudAllocator : public Allocator {
  public:
    virtual ~FudAllocator() override = default;

    virtual Result<std::byte*, FudStatus> allocate(size_t bytes, size_t alignment = alignof(std::max_align_t)) override;

    virtual void deallocate(std::byte* pointer, size_t bytes) override;

    virtual bool isEqual(const Allocator& rhs) const override;
};

extern FudAllocator globalFudAllocator;

class NullAllocator : public Allocator {
  public:
    virtual ~NullAllocator() override = default;

    virtual Result<std::byte*, FudStatus> allocate(size_t bytes, size_t alignment = alignof(std::max_align_t)) override;

    virtual void deallocate(std::byte* pointer, size_t bytes) override;

    virtual bool isEqual(const Allocator& rhs) const override;
};

extern NullAllocator globalNullAllocator;

template <size_t Size>
class SimpleStackAllocator final : public Allocator {
private:
    std::byte m_memory[Size]{};
    size_t m_allocated{0};

public:
    virtual ~SimpleStackAllocator() override final = default;

    virtual Result<std::byte*, FudStatus> allocate(size_t bytes, size_t alignment = alignof(std::max_align_t)) override final {
        using RetType = Result<std::byte*, FudStatus>;
        static_cast<void>(alignment);
        if (bytes > Size - m_allocated) {
            return RetType::error(FudStatus::AllocFailure);
        }

        auto* data = m_memory + m_allocated;
        m_allocated += bytes;

        return RetType::okay(data);
    }

    virtual void deallocate(std::byte* pointer, size_t bytes) override final
    {
        if (pointer + bytes != m_memory + m_allocated) {
            m_allocated = Size;
            return;
        }
        m_allocated -= bytes;
    }

    virtual bool isEqual(const Allocator& rhs) const override final {
        return &rhs == this;
    }
};

} // namespace fud

#endif