#include "Scene.h"
#include "GameObject.h"
#include <iostream>

namespace dae
{
	unsigned int Scene::m_Count{ 0 };

	Scene::Scene(const std::string& name)
		: m_Name(name)
	{
		m_Id = m_Count++;

		auto pRootGameObject = new GameObject();
		Add(pRootGameObject);
	}
	
	GameObject* Scene::FindChild(const std::string& name)
	{
		for (const auto& pGo : m_pGameObjects)
		{
			GameObject* result = FindChildRecursive(pGo, name);
			if (result != nullptr)
			{
				return result;
			}
		}
		return nullptr;
	}

	GameObject* Scene::FindChildRecursive(const std::shared_ptr<GameObject>& gameObject, const std::string& name)
	{
		if (gameObject->GetName() == name)
		{
			return gameObject.get();
		}

		for (const auto& child : gameObject->GetChildren())
		{
			GameObject* result = FindChildRecursive(child, name);
			if (result != nullptr)
			{
				return result;
			}
		}
		return nullptr;
	}

	std::vector<GameObject*> Scene::FindChildren(const std::string& name)
	{
		std::vector<GameObject*> pChildren{};
		for (const auto& pGo : m_pGameObjects)
		{
			FindChildrenRecursive(pGo, name, pChildren);
		}
		return pChildren;
	}

	void Scene::FindChildrenRecursive(const std::shared_ptr<GameObject>& gameObject, const std::string& name, std::vector<GameObject*>& outChildren)
	{
		if (gameObject->GetName() == name)
		{
			outChildren.emplace_back(gameObject.get());
		}

		for (const auto& child : gameObject->GetChildren())
		{
			FindChildrenRecursive(child, name, outChildren);
		}
	}

	Scene::~Scene() = default;

	void Scene::Add(GameObject* pGameObject)
	{
		if (pGameObject->GetParent() != nullptr)
			return;

		auto pRootGameObject = GetRootGameObject();
		if (pRootGameObject)
		{
			pGameObject->SetParent(pRootGameObject);
		}
		else
		{
			std::shared_ptr<GameObject> pSharedGo(pGameObject);
			m_pGameObjects.emplace_back(pSharedGo);
		}

	}

	void Scene::Remove(std::shared_ptr<GameObject> object)
	{
		m_pGameObjects.erase(std::remove(m_pGameObjects.begin(), m_pGameObjects.end(), object), m_pGameObjects.end());
	}

	void Scene::RemoveAll()
	{
		m_pGameObjects.clear();
	}

	void Scene::Update(float deltaTime)
	{
		for(auto& pGameObject : m_pGameObjects)
		{
			pGameObject->Update(deltaTime);
		}
	}

	void Scene::FixedUpdate(float deltaTime)
	{
		for (auto& pGameObject : m_pGameObjects)
		{
			pGameObject->FixedUpdate(deltaTime);
		}
	}

	void Scene::LateUpdate(float deltaTime)
	{
		for (auto& pGameObject : m_pGameObjects)
		{
			pGameObject->LateUpdate(deltaTime);
		}
	}

	void Scene::Render() const
	{
		for (const auto& pGameObject : m_pGameObjects)
		{
			pGameObject->Render();
		}
	}

	void Scene::HandleChangeParents()
	{
		for (auto& pGameObject : m_pGameObjects)
		{
			pGameObject->HandleChangeParent();
		}
	}

	void Scene::DeleteMarkedGameObjects()
	{
		for (auto& gameObject : m_pGameObjects)
		{
			DeleteMarkedGameObjectsRecursive(gameObject);
		}

		m_pGameObjects.erase(
			std::remove_if(m_pGameObjects.begin(), m_pGameObjects.end(),
				[](const std::shared_ptr<GameObject>& gameObject)
				{
					return gameObject->IsMarkedForDeletion();
				}),
			m_pGameObjects.end());
	}

	void Scene::DeleteMarkedGameObjectsRecursive(std::shared_ptr<GameObject> gameObject)
	{
		auto& children = gameObject->GetChildren();
		for (auto& child : children)
		{
			DeleteMarkedGameObjectsRecursive(child);
		}

		children.erase(
			std::remove_if(children.begin(), children.end(),
				[](const std::shared_ptr<GameObject>& childGameObject)
				{
					return childGameObject->IsMarkedForDeletion();
				}),
			children.end());
	}
}