#pragma once

#include <Nazara/Core/Components/DisabledComponent.hpp>
#include <Nazara/Core/State.hpp>
#include <Nazara/Graphics/RenderTarget.hpp>
#include <Nazara/Widgets/BaseWidget.hpp>
#include <client/states/StateData.h>
#include <functional>
#include <memory>
#include <vector>

namespace blitz {
namespace client {

class AbstractState : public Nz::State, public std::enable_shared_from_this<AbstractState> {
  public:
	AbstractState(std::shared_ptr<StateData> stateData);
	~AbstractState();

  protected:
	template <typename T, typename... Args>
	void ConnectSignal(T& signal, Args&&... args) {
		m_CleanupFunctions.emplace_back(
			[connection = signal.Connect(std::forward<Args>(args)...)]() mutable { connection.Disconnect(); });
	}

	template <typename T, typename... Args>
	T* CreateWidget(Args&&... args) {
		T* widget = m_StateData->m_Canvas->Add<T>(std::forward<Args>(args)...);

		auto& entry = m_Widgets.emplace_back();
		entry.m_Widget = widget;

		if (!m_IsVisible)
			entry.m_Widget->Hide();

		return widget;
	}

	void DestroyWidget(Nz::BaseWidget* widget);

	StateData& GetStateData() {
		return *m_StateData;
	}

	const StateData& GetStateData() const {
		return *m_StateData;
	}

	const std::shared_ptr<StateData>& GetStateDataPtr() {
		return m_StateData;
	}

	void Enter(Nz::StateMachine& fsm) override;
	void Leave(Nz::StateMachine& fsm) override;
	bool Update(Nz::StateMachine& fsm, Nz::Time elapsedTime) override;

	virtual void LayoutWidgets() {}

  private:
	NazaraSlot(Nz::RenderTarget, OnRenderTargetSizeChange, m_OnTargetChangeSizeSlot);

	struct WidgetEntry {
		Nz::BaseWidget* m_Widget;
		bool m_WasVisible = true;
	};

	std::shared_ptr<StateData> m_StateData;
	std::vector<std::function<void()>> m_CleanupFunctions;
	std::vector<WidgetEntry> m_Widgets;
	bool m_IsVisible;
};

}  // namespace client
}  // namespace blitz