#include "ehs/GC.h"

namespace ehs
{
	UInt_32 GarbageCollectionThread(void* params)
	{
		while (GC::IsRunning())
		{
			GC::Poll();
			Thread::SleepFor(50);
		}

		GC::Dump();

		return 0;
	}

	Array<GcLogic> GC::logic;
	Vector<BaseObj*> GC::garbage(0, 1000);
	UInt_64 GC::max = 10;
	Thread GC::thread;
    Mutex GC::mutex;
	bool GC::running = false;

	bool GC::Has(const BaseObj* obj)
	{
		for (UInt_64 i = 0; i < garbage.Size(); ++i)
			if (garbage[i] == obj)
				return true;

		return false;
	}

	void GC::Start()
	{
		if (running)
			return;

		mutex.Initialize();

		thread.Start(GarbageCollectionThread, nullptr);

		running = true;
	}

	void GC::Stop()
	{
		if (!running)
			return;

		running = false;

		thread.Join();
	}

	bool GC::HasLogic(GcLogic logicCb)
	{
		for (UInt_64 i = 0; i < logic.Size(); ++i)
			if (logic[i] == logicCb)
				return true;

		return false;
	}

	bool GC::AddLogic(GcLogic logicCb)
	{
		if (HasLogic(logicCb))
			return false;

		if (running)
			mutex.Lock();

		logic.Push(logicCb);

		if (running)
			mutex.Unlock();

		return true;
	}

	void GC::Add(BaseObj* obj)
	{
		if (!obj)
			return;

		#ifdef EHS_DEBUG
			if (Has(obj))
			{
				EHS_LOG_INT(LogType::ERR, 1, Str_8(obj->GetTypeId(), obj->GetTypeIdSize()) +
					" object with address of, \"" + Str_8::FromNum((ehs::Size)obj) + "\" is already in garbage.");
				return;
			}
		#endif

		garbage.Push(obj);
	}

	void GC::SetMax(const UInt_64 newMax)
	{
		max = newMax;
	}

	UInt_64 GC::GetMax()
	{
		return max;
	}

	void GC::SetStride(const UInt_64 newStride)
	{
		Dump();

		garbage = Vector<BaseObj*>(0, newStride);
	}

	UInt_64 GC::GetStride()
	{
		return garbage.Stride();
	}

	UInt_64 GC::Size()
	{
		return garbage.Size();
	}

	void GC::Poll()
	{
		if (running)
			mutex.Lock();

		UInt_64 i = 0;
		UInt_64 o = 0;

		while (garbage.Size() && i < max && o < garbage.Size())
		{
			if (!ShouldDelete(garbage[o]))
			{
				o++;
				continue;
			}

			if (o != garbage.Size() - 1)
				garbage.Swap(o, garbage.End());

			delete garbage.Pop();

			i++;
		}

		if (running)
			mutex.Unlock();
	}

	void GC::Dump()
	{
		if (running)
			mutex.Lock();

		for (UInt_64 i = 0; i < garbage.Size(); ++i)
			delete garbage[i];

		garbage.Clear();

		if (running)
			mutex.Unlock();
	}

	bool GC::IsRunning()
	{
		return running;
	}

	bool GC::ShouldDelete(BaseObj *obj)
	{
		for (UInt_64 l = 0; l < logic.Size(); ++l)
			if (!logic[l](obj))
				return false;

		return true;
	}
}