class Actor final
{
public:
	Actor();
	~Actor();

	void Initialize();
	void Update();
	void Destroy();

	/*
	* Property
	*/
	const std::string& GetName() const { return name; }
	void SetName(const std::string& name) { this->name = name; }

	bool IsActive() const { return is_active; }
	void SetActive(const bool& is_active) { this->is_active = is_active; }

	const std::shared_ptr<class Transform>& GetTransform() const { return transform; } 
	class Transform* GetTransform_Row() { return transform.get(); }

	/*
	* Component
	*/
	const std::shared_ptr<IComponent> AddComponent(const ComponentType& type);

	template <typename T>
	const std::shared_ptr<T> AddComponent();

	template <typename T>
	const std::shared_ptr<T> GetComponent();

	template <typename T>
	T* GetComponent_Row();

	template <typename T>
	const std::vector<std::shared_ptr<T>> GetComponents();

	const std::vector<std::shared_ptr<IComponent>>& GetAllComponents() const { return components; }

	bool HasComponent(const ComponentType& type);

	template <typename T>
	bool HasComponent();

	template <typename T>
	void RemoveComponent();

private:
	std::string name;
	bool is_active = true;

	std::shared_ptr<class Transform> transform;
	std::vector<std::shared_ptr<IComponent>> components;
};

void Actor::Initialize()
{
	for (const auto& component : components)
	{
		component->Initialize();
	}
}

void Actor::Update()
{
	if (!IsActive())
	{
		return;
	}

	for (const auto& component : components)
	{
		if (component->IsEnabled())
		{
			component->Update();
		}
	}
}

void Actor::Destroy()
{
	for (const auto& component : components)
	{
		component->Destroy();
	}
}

template<typename T>
inline const std::shared_ptr<T> Actor::AddComponent()
{
	static_assert(std::is_base_of<IComponent, T>::value, "Provider type dose not implement IComponent");

	ComponentType type = IComponent::DeduceComponenetType<T>();

	if (HasComponent(type))
	{
		return GetComponent<T>();
	}

	components.emplace_back(std::make_shared<T>(this, transform.get()));

	T new_component = std::static_pointer_cast<T>(components.back());

	if constexpr(std::is_same<T, class Transform>::value)
	{
		transform = new_component;
	}

	return new_component;
}

template<typename T>
inline const std::shared_ptr<T> Actor::GetComponent()
{
	static_assert(std::is_base_of<IComponent, T>::value, "Provider type dose not implement IComponent");

	ComponentType type = IComponent::DeduceComponenetType<T>();

	for (const auto& component : components)
	{
		if (component->GetComponentType() == type)
		{
			return std::static_pointer_cast<T>(component);
		}
	}

	return nullptr;
}

template<typename T>
inline void Actor::RemoveComponent()
{
	static_assert(std::is_base_of<IComponent, T>::value, "Provider type dose not implement IComponent");

	ComponentType type = IComponent::DeduceComponenetType<T>();

	for (auto iter = components.begin(); iter != components.end();)
	{
		auto component = *iter;
		if (component->GetComponentType() == type)
		{
			component->Destroy();
			component.reset();
			iter = components.erase(iter);
		}

		else
		{
			iter++;
		}
	}
}