#include "GarbageCollection.h"
#include "SObjectManager.h"
#include "ThreadPool.h"
#include "SContainer.hpp"
#include "Logger.h"
#include "GCObject.h"

#include <queue>

namespace sh::core
{
	GarbageCollection::GarbageCollection() :
		objs(SObjectManager::GetInstance()->objs)
	{
	}

	GarbageCollection::~GarbageCollection()
	{
		Update();
	}

	SH_CORE_API void GarbageCollection::SetRootSet(SObject* obj)
	{
		std::lock_guard<std::mutex> lock{ mu };

		auto it = rootSetIdx.find(obj);
		if (it != rootSetIdx.end())
			return;

		const std::size_t idx = rootSets.size();
		rootSets.push_back(obj);
		rootSetIdx.insert_or_assign(obj, idx);
	}
	SH_CORE_API void GarbageCollection::RemoveRootSet(const SObject* obj)
	{
		std::lock_guard<std::mutex> lock{ mu };

		auto it = rootSetIdx.find(const_cast<SObject*>(obj));
		if (it == rootSetIdx.end())
			return;
		const std::size_t idx = it->second;
		const std::size_t last = rootSets.size() - 1;

		rootSetIdx.erase(it);

		if (idx != last)
		{
			SObject* moved = rootSets.back();
			rootSets[idx] = moved;
			rootSetIdx[moved] = idx;
		}
		rootSets.pop_back();
	}
	SH_CORE_API void GarbageCollection::SetUpdateTick(uint32_t tick)
	{
		updatePeriodTick = tick;
		this->tick = 0;
	}

	SH_CORE_API void GarbageCollection::Update()
	{
		++tick;
		if (updatePeriodTick > 1)
		{
			if (tick == updatePeriodTick - 1)
			{
				Collect();
				return;
			}
			if (tick == updatePeriodTick)
			{
				tick = 0;
				DestroyPendingKillObjs();
				return;
			}
		}
		else
		{
			Collect();
			DestroyPendingKillObjs();
		}
	}
	SH_CORE_API void sh::core::GarbageCollection::Collect()
	{
		auto start = std::chrono::high_resolution_clock::now();
		for (auto& objPtr : objs)
			objPtr->bMark.clear(std::memory_order::memory_order_relaxed); // memory_order_relaxed - 어차피 다른 스레드들은 모두 자고 있음

		const bool bThreadPoolInit = ThreadPool::GetInstance()->IsInit();

		CollectReferenceObjs();

		if (refObjs.size() > 128 && bThreadPoolInit)
			MarkWithMultiThread();
		else
			Mark(0, refObjs.size());

		// 모든 SObject를 순회하며 마킹이 안 됐으면 보류 목록에 추가
		// TODO: 나중에 멀티 스레드로 바꿀 때 메모리 오더 바꾸기
		for (SObject* objPtr : objs)
		{
			if (!objPtr->bMark.test_and_set(std::memory_order::memory_order_relaxed))
			{
				if (!objPtr->bPendingKill)
				{
					// AddToPendingKillList함수도 OnDestroy()에서 실행됨
					objPtr->OnDestroy();
				}
			}
		}

		CheckPtrs();
		bPendingKill = true;

		auto end = std::chrono::high_resolution_clock::now();

		//static std::deque<uint64_t> times;
		//if (times.size() < 100)
		//	times.push_back(std::chrono::duration_cast<std::chrono::microseconds>(end - start).count());
		//else
		//	times.pop_front();

		//static double mean = 0.0f;
		//for (auto t : times)
		//	mean += t;
		//mean /= 100;

		//SH_INFO_FORMAT("GC Mean: {}", mean);

		elapseTime = static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());
	}

	SH_CORE_API auto GarbageCollection::GetObjectCount() const -> std::size_t
	{
		return objs.size();
	}

	SH_CORE_API void GarbageCollection::ForceDelete(SObject* obj)
	{
		if (obj == nullptr)
			return;

		for (auto& pendingObj : pendingKillObjs)
		{
			if (pendingObj == obj)
				pendingObj = nullptr;
		}
		RemoveRootSet(obj);
		SObjectManager::GetInstance()->UnRegisterSObject(obj);
		delete obj;
	}

	SH_CORE_API void GarbageCollection::AddToPendingKillList(SObject* obj)
	{
		pendingKillObjs.push_back(obj);
		obj->bPendingKill = true;
	}

	SH_CORE_API void GarbageCollection::DestroyPendingKillObjs()
	{
		if (!bPendingKill)
			Collect();

		for (int i = 0; i < pendingKillObjs.size(); ++i)
		{
			SObject* objPtr = pendingKillObjs[i];
			assert(rootSetIdx.find(objPtr) == rootSetIdx.end());
			if (objPtr == nullptr)
				continue;
			if (!objPtr->bPlacementNew)
				delete objPtr; // 여기서 pendingKillObjs에 요소가 추가 될 가능성이 있음
			else
				std::destroy_at(objPtr);
			objPtr = nullptr;
		}
		pendingKillObjs.clear();
		bPendingKill = false;

		SH_INFO("Destroy pending objects");
	}
	SH_CORE_API void GarbageCollection::MarkBFS(std::queue<SObject*>& bfs)
	{
		while (!bfs.empty())
		{
			SObject* const obj = bfs.front();
			bfs.pop();

			if (!obj)
				continue;
			if (obj->bMark.test_and_set(std::memory_order::memory_order_relaxed))
				continue;

			MarkProperties(obj, bfs);
		}
	}
	SH_CORE_API void GarbageCollection::AddGCObject(GCObject& obj)
	{
		if (gcObjIdx.find(&obj) != gcObjIdx.end())
			return;

		gcObjIdx.insert({ &obj, gcObjs.size() });
		gcObjs.push_back(obj);
	}
	SH_CORE_API void GarbageCollection::RemoveGCObject(GCObject& obj)
	{
		if (auto it = gcObjIdx.find(&obj); it != gcObjIdx.end())
		{
			std::size_t idx = it->second;
			gcObjIdx.erase(it);

			if (idx != gcObjs.size() - 1)
			{
				gcObjs[idx] = gcObjs.back();
				gcObjIdx[&gcObjs.back().get()] = idx;
			}
			gcObjs.pop_back();
		}
	}

	void GarbageCollection::CollectReferenceObjs()
	{
		refObjs.clear();
		refObjs.reserve(rootSets.size() + gcObjs.size() * 2);

		for (SObject* objPtr : rootSets)
		{
			if (!core::IsValid(objPtr))
				continue;
			refObjs.push_back(*objPtr);
		}

		for (GCObject& gcObj : gcObjs)
			gcObj.PushReferenceObjects(*this);
	}
	void GarbageCollection::Mark(std::size_t start, std::size_t end)
	{
		std::queue<SObject*> bfs{};
		for (std::size_t i = start; i < end; ++i)
		{
			bfs.push(&refObjs[i].get());

			MarkBFS(bfs);
		}
	}
	void GarbageCollection::MarkProperties(SObject* obj, std::queue<SObject*>& bfs)
	{
		const reflection::STypeInfo* type = &obj->GetType();
		while (type != nullptr)
		{
			auto& ptrProps = type->GetSObjectPtrProperties();
			for (auto ptrProp : ptrProps)
			{
				SObject** propertyPtr = ptrProp->Get<SObject*>(*obj);
				SObject* ptr = *propertyPtr;
				if (ptr == nullptr)
					continue;

				// Destory함수로 인해 제거 될 객체면 가르키고 있던 포인터를 nullptr로 바꾸고, 마킹하지 않는다.
				if (ptr->bPendingKill)
				{
					*propertyPtr = nullptr;
					continue;
				}
				bfs.push(ptr);
			}

			auto& ptrContainerProps = type->GetSObjectPtrContainerProperties();
			for (auto ptrProp : ptrContainerProps)
			{
				int nested = ptrProp->GetContainerNestedLevel();
				for (auto it = ptrProp->Begin(*obj); it != ptrProp->End(*obj);)
				{
					if (nested == 1)
					{
						SObject* const* propertyPtr = nullptr;
						if (it.IsPair())
							propertyPtr = it.GetPairSecond<SObject*>();
						else
							propertyPtr = it.Get<SObject*>();

						SObject* ptr = *propertyPtr;
						if (ptr == nullptr)
						{
							++it;
							continue;
						}

						if (ptr->bPendingKill)
							it.Erase(); // iterator 자동 갱신
						else
						{
							bfs.push(ptr);
							++it;
						}
					}
					else
					{
						ContainerMark(bfs, obj, 1, nested, it);
					}
				}
			}
			type = type->super; // 부모 클래스의 프로퍼티들도 검사
		}
	}
	void GarbageCollection::MarkWithMultiThread()
	{
		const auto threadPool = core::ThreadPool::GetInstance();
		const int threadNum = threadPool->GetThreadNum();
		const std::size_t perThreadTaskCount = (refObjs.size() + threadNum - 1) / threadNum;

		std::array<std::future<void>, ThreadPool::MAX_THREAD> taskFutures;
		std::size_t p = 0;
		int futureIdx = 0;
		while (p < refObjs.size())
		{
			const size_t start = p;
			const size_t end = std::min(p + perThreadTaskCount, refObjs.size());
			taskFutures[futureIdx++] = (threadPool->AddTask(
				[&, start, end]
				{
					Mark(start, end);
				}
			));
			p = end;
		}
		for (int i = 0; i < futureIdx; ++i)
			taskFutures[i].wait();
	}
	void GarbageCollection::ContainerMark(std::queue<SObject*>& bfs, SObject* parent, int depth, int maxDepth, sh::core::reflection::PropertyIterator<false>& it)
	{
		if (depth == maxDepth)
		{
			SObject* const* propertyPtr = nullptr;
			if (it.IsPair())
				propertyPtr = it.GetPairSecond<SObject*>();
			else
				propertyPtr = it.Get<SObject*>();

			SObject* ptr = *propertyPtr;
			if (ptr == nullptr)
			{
				++it;
				return;
			}

			if (ptr->bPendingKill)
				it.Erase(); // iterator 자동 갱신
			else
			{
				bfs.push(ptr);
				++it;
			}
			return;
		}
		for (auto itSide = it.GetNestedBegin(); itSide != it.GetNestedEnd();)
		{
			ContainerMark(bfs, parent, depth + 1, maxDepth, itSide);
		}
		++it;
	}
	void GarbageCollection::CheckPtrs()
	{
		for (void* ptr : trackingWeakPtrs)
		{
			SObjWeakPtr<SObject>& weakPtr = *reinterpret_cast<SObjWeakPtr<SObject>*>(ptr);
			if (weakPtr == nullptr)
				continue;
			if (weakPtr->bPendingKill)
				weakPtr.Reset();
		}
	}
}//namespace