module;

#include <new>

export module Core.Utility;

export import Core.Types;

import Core.Meta;
import Core.Std;
import Core.New;

#define SOURCE const std::source_location& l = std::source_location::current()

export namespace std {
    using std::source_location;
}

#ifdef CHECK_MEMORY
export void* operator new(size_t count, const std::source_location& l) noexcept;
export void* operator new[](
    size_t count, const std::source_location& l) noexcept;
#endif

export namespace Core {
    template<typename T, typename C = int>
    C popCount(const T& t) noexcept {
        static constexpr C map[16] = {0, 1, 1, 2, 1, 2, 2, 3,
                                      1, 2, 2, 3, 2, 3, 3, 4};
        C sum = 0;
        for(size_t i = 0; i < sizeof(T) * 8; i += 4) {
            sum += map[(t >> i) & 0xF];
        }
        return sum;
    }

    using ExitHandler = void (*)(int, void*);
    [[noreturn]] void exitWithHandler(int value, SOURCE) noexcept;
    void setExitHandler(ExitHandler h, void* data) noexcept;

    using OutOfMemoryHandler = void (*)(void*);
    void setOutOfMemoryHandler(OutOfMemoryHandler h, void* data) noexcept;

#ifdef CHECK_MEMORY
    void* allocateRaw(size_t n, SOURCE) noexcept;
    void* zeroAllocateRaw(size_t n, SOURCE) noexcept;
    void* reallocateRaw(void* p, size_t n, SOURCE) noexcept;
    void deallocateRaw(void* p, SOURCE) noexcept;

    template<typename T, typename... Args>
    T* newWithSource(Args&&... args) noexcept {
        static_assert(noexcept(new(std::source_location::current())
                                   T(Core::forward<Args>(args)...)));
        return new(std::source_location::current())
            T(Core::forward<Args>(args)...);
    }

    template<typename T>
    T* newWithSourceN(size_t n) noexcept {
        static_assert(noexcept(new(std::source_location::current()) T[n]));
        return new(std::source_location::current()) T[n];
    }
#else
    void* allocateRaw(size_t n) noexcept;
    void* zeroAllocateRaw(size_t n) noexcept;
    void* reallocateRaw(void* p, size_t n) noexcept;
    void deallocateRaw(void* p) noexcept;

    template<typename T, typename... Args>
    T* newWithSource(Args&&... args) noexcept {
        static_assert(
            noexcept(new(std::nothrow) T(Core::forward<Args>(args)...)));
        return new(std::nothrow) T(Core::forward<Args>(args)...);
    }

    template<typename T>
    T* newWithSourceN(size_t n) noexcept {
        static_assert(noexcept(new(std::nothrow) T[n]));
        return new(std::nothrow) T[n];
    }
#endif
    void printMemoryReport() noexcept;

    template<typename T>
    void deleteWithSource(T* p) noexcept {
        delete p;
    }

    template<typename T>
    void deleteWithSourceN(T* p) noexcept {
        delete[] p;
    }

    template<typename T>
    void bubbleSort(T* data, size_t n) noexcept {
        bool swapped = true;
        while(swapped && n > 0) {
            swapped = false;
            n--;
            for(size_t i = 0; i < n; i++) {
                if(data[i] > data[i + 1]) {
                    swap(data[i], data[i + 1]);
                    swapped = true;
                }
            }
        }
    }
}