// Copyright Epic Games, Inc. All Rights Reserved.

#include <string.h>
#include <zencore/memory/fmalloc.h>
#include <zencore/memory/memory.h>

namespace zen {

//////////////////////////////////////////////////////////////////////////

class FInitialMalloc : public FMalloc
{
	virtual void* Malloc(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT) override
	{
		Memory::Initialize();
		return GMalloc->Malloc(Count, Alignment);
	}
	virtual void* TryMalloc(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT) override
	{
		Memory::Initialize();
		return GMalloc->TryMalloc(Count, Alignment);
	}
	virtual void* Realloc(void* Original, size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT) override
	{
		Memory::Initialize();
		return GMalloc->Realloc(Original, Count, Alignment);
	}
	virtual void* TryRealloc(void* Original, size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT) override
	{
		Memory::Initialize();
		return GMalloc->TryRealloc(Original, Count, Alignment);
	}
	virtual void Free(void* Original) override
	{
		Memory::Initialize();
		return GMalloc->Free(Original);
	}
	virtual void* MallocZeroed(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT) override
	{
		Memory::Initialize();
		return GMalloc->MallocZeroed(Count, Alignment);
	}

	virtual void* TryMallocZeroed(size_t Count, uint32_t Alignment = DEFAULT_ALIGNMENT) override
	{
		Memory::Initialize();
		return GMalloc->TryMallocZeroed(Count, Alignment);
	}
	virtual size_t QuantizeSize(size_t Count, uint32_t Alignment) override
	{
		Memory::Initialize();
		return GMalloc->QuantizeSize(Count, Alignment);
	}
	virtual bool GetAllocationSize(void* Original, size_t& SizeOut) override
	{
		Memory::Initialize();
		return GMalloc->GetAllocationSize(Original, SizeOut);
	}
	virtual void OnMallocInitialized() override {}
	virtual void Trim(bool bTrimThreadCaches) override { ZEN_UNUSED(bTrimThreadCaches); }
} GInitialMalloc;

FMalloc* GMalloc = &GInitialMalloc; /* Memory allocator */

//////////////////////////////////////////////////////////////////////////

void*
FUseSystemMallocForNew::operator new(size_t Size)
{
	return Memory::SystemMalloc(Size);
}

void
FUseSystemMallocForNew::operator delete(void* Ptr)
{
	Memory::SystemFree(Ptr);
}

void*
FUseSystemMallocForNew::operator new[](size_t Size)
{
	return Memory::SystemMalloc(Size);
}

void
FUseSystemMallocForNew::operator delete[](void* Ptr)
{
	Memory::SystemFree(Ptr);
}

//////////////////////////////////////////////////////////////////////////

void*
FMalloc::TryRealloc(void* Original, size_t Count, uint32_t Alignment)
{
	return Realloc(Original, Count, Alignment);
}

void*
FMalloc::TryMalloc(size_t Count, uint32_t Alignment)
{
	return Malloc(Count, Alignment);
}

void*
FMalloc::TryMallocZeroed(size_t Count, uint32_t Alignment)
{
	return MallocZeroed(Count, Alignment);
}

void*
FMalloc::MallocZeroed(size_t Count, uint32_t Alignment)
{
	void* const Memory = Malloc(Count, Alignment);

	if (Memory)
	{
		::memset(Memory, 0, Count);
	}

	return Memory;
}

void
FMalloc::OutOfMemory(size_t Size, uint32_t Alignment)
{
	ZEN_UNUSED(Size, Alignment);
	// no-op by default
}

void
FMalloc::Trim(bool bTrimThreadCaches)
{
	ZEN_UNUSED(bTrimThreadCaches);
}

void
FMalloc::OnMallocInitialized()
{
}

bool
FMalloc::GetAllocationSize(void* Original, size_t& SizeOut)
{
	ZEN_UNUSED(Original, SizeOut);
	return false;  // Generic implementation has no way of determining this
}

size_t
FMalloc::QuantizeSize(size_t Count, uint32_t Alignment)
{
	ZEN_UNUSED(Alignment);
	return Count;  // Generic implementation has no way of determining this
}

}  // namespace zen