#pragma once

#include <memory>
#include <td/render/Camera.h>
#include <td/render/loader/GLLoader.h>
#include <td/render/shader/CameraShaderProgram.h>
#include <td/misc/SlotGuard.h>

namespace td {
namespace render {

class BasicRenderer {
  public:
	virtual void Render(float a_Lerp) = 0;
	virtual ~BasicRenderer() {}

	void Render(const GL::VertexArray& a_Vao);
};

template <typename TShader>
class Renderer : public BasicRenderer, public utils::SlotGuard {
  protected:
	std::unique_ptr<TShader> m_Shader;
	Camera& m_Camera;

  public:
	Renderer(Camera& a_Camera);
	virtual ~Renderer() {}

	template <typename T>
	float Lerp(const T& a_Mob, float a_LerpFactor, const std::function<float(const T&)>& a_MemberGetter) {
		return static_cast<float>(maths::Lerp(a_MemberGetter(a_Mob), a_MemberGetter(*a_Mob.m_Next), a_LerpFactor));
	}
};

class RenderPipeline {
  private:
	std::vector<std::unique_ptr<BasicRenderer>> m_Renderers;

  public:
	RenderPipeline();
	virtual ~RenderPipeline() {}

	template <typename T, typename... Args>
	void AddRenderer(Args&&... args) {
		m_Renderers.push_back(std::make_unique<T>(args...));
	}

	void Clear() {
		m_Renderers.clear();
	}

	void Render(float a_Lerp) {
		for (auto& renderer : m_Renderers) {
			renderer->Render(a_Lerp);
		}
	}
};





template <typename TShader>
Renderer<TShader>::Renderer(Camera& a_Camera) : m_Shader(std::make_unique<TShader>()), m_Camera(a_Camera) {
	Connect(a_Camera.OnPerspectiveChange, [this](){
		m_Shader->Start();
		m_Shader->SetProjectionMatrix(m_Camera.GetProjectionMatrix());
	});

	Connect(a_Camera.OnViewChange, [this]() {
		m_Shader->Start();
		m_Shader->SetViewMatrix(m_Camera.GetViewMatrix());
	});
}

}  // namespace render
}  // namespace td