/*
 *  <Short Description>
 *  Copyright (C) 2023  Brett Terpstra
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef BLT_WITH_GRAPHICS_BATCH_2D_RENDERER_H
#define BLT_WITH_GRAPHICS_BATCH_2D_RENDERER_H

#include "blt/gfx/model.h"
#include "blt/gfx/shader.h"
#include "blt/gfx/framebuffer.h"
#include "blt/gfx/renderer/resource_manager.h"
#include "blt/gfx/renderer/postprocess.h"
#include <blt/std/hashmap.h>
#include <blt/std/memory_util.h>
#include <blt/math/vectors.h>
#include <string_view>
#include <vector>

namespace blt::gfx
{
	enum class anchor_t
	{
		TOP_LEFT,
		TOP_RIGHT,
		BOTTOM_LEFT,
		BOTTOM_RIGHT,
		CENTER, };

	struct rectangle2d_t
	{
		vec2f pos, size;
		f32 rotation = 0;

		rectangle2d_t(const anchor_t anchor, const f32 x, const f32 y, const f32 width, const f32 height): pos(x, y), size(width, height)
		{
			update_based_on_anchor(anchor);
		}

		rectangle2d_t(const anchor_t anchor, const vec2f pos, const vec2f size): pos(pos), size(size)
		{
			update_based_on_anchor(anchor);
		}

		rectangle2d_t(const f32 x, const f32 y, const f32 width, const f32 height, const f32 rotation): pos(x, y), size(width, height),
																										rotation(rotation)
		{}

		rectangle2d_t(const f32 x, const f32 y, const f32 width, const f32 height): pos(x, y), size(width, height)
		{}

		rectangle2d_t(const vec2f pos, const vec2f size, const f32 rotation): pos(pos), size(size), rotation(rotation)
		{}

		rectangle2d_t(const vec2f pos, const vec2f size): pos(pos), size(size)
		{}

		void update_based_on_anchor(const anchor_t anchor)
		{
			switch (anchor)
			{
				case anchor_t::TOP_LEFT:
					pos += vec2f(size.x() / 2.0f, -size.y() / 2.0f);
					break;
				case anchor_t::TOP_RIGHT:
					pos += vec2f(-size.x() / 2.0f, -size.y() / 2.0f);
					break;
				case anchor_t::BOTTOM_LEFT:
					// size = vec2f(size.x() / 2.0f, size.y() / 2.0f);
					pos += vec2f(size.x() / 2.0f, size.y() / 2.0f);

					break;
				case anchor_t::BOTTOM_RIGHT:
					pos += vec2f(-size.x() / 2.0f, size.y() / 2.0f);
					break;
				case anchor_t::CENTER:
					break;
			}
		}
	};

	struct line2d_t
	{
		vec2f p1;
		vec2f p2;
		f32 thickness = 1;

		line2d_t(const f32 px1, const f32 py1, const f32 px2, const f32 py2): p1(px1, py1), p2(px2, py2)
		{}

		line2d_t(const vec2f p1, const vec2f p2): p1(p1), p2(p2)
		{}

		line2d_t(const f32 px1, const f32 py1, const f32 px2, const f32 py2, const f32 thickness): p1(px1, py1), p2(px2, py2), thickness(thickness)
		{}

		line2d_t(const vec2f p1, const vec2f p2, const f32 thickness): p1(p1), p2(p2), thickness(thickness)
		{}
	};

	struct curve2d_mesh_data_t
	{
		struct line_vertex_t
		{
			vec3 pos;
			vec2 uv;
		};

		struct draw_t
		{
			std::unique_ptr<vertex_array_t> vao;
			i32 count;
		};

		[[nodiscard]] draw_t to_vertex_array() const;
		size_t populate_vertex_array(vertex_array_t& va) const;

		[[nodiscard]] std::vector<line_vertex_t> calculate_vertices() const;

		curve2d_mesh_data_t& with(const curve2d_mesh_data_t& mesh)
		{
			lines.insert(lines.end(), mesh.lines.begin(), mesh.lines.end());
			return *this;
		}

		curve2d_mesh_data_t& set_thickness(const f32 thickness)
		{
			for (auto& line : lines)
				line.thickness = thickness;
			return *this;
		}

		[[nodiscard]] f32 length() const;

		std::vector<line2d_t> lines;
	};

	struct curve2d_t
	{
		curve2d_t(vec2 p0, vec2 p1);
		curve2d_t(vec2 p0, vec2 p1, vec2 p2);
		curve2d_t(vec2 p0, vec2 p1, vec2 p2, vec2 p3);

		[[nodiscard]] vec2 get_point(f32 t) const;

		[[nodiscard]] std::vector<line2d_t> to_lines(i32 segments, f32 thickness = 1.0) const;

		[[nodiscard]] curve2d_mesh_data_t to_mesh(i32 segments, f32 thickness = 1.0) const;

		[[nodiscard]] f32 length(i32 segments) const;

		[[nodiscard]] f32 length_fast() const;

		vec2 m_p0, m_p1, m_p2;
		std::optional<vec2> m_p3;
	};

	struct point2d_t
	{
		vec2f pos;
		f32 scale = 1;

		point2d_t(const f32 x, const f32 y, const f32 scale): pos(x, y), scale(scale)
		{}

		point2d_t(const f32 x, const f32 y): pos(x, y)
		{}

		point2d_t(const vec2f pos, const f32 scale): pos(pos), scale(scale)
		{}

		explicit point2d_t(const vec2f pos): pos(pos)
		{}

		[[nodiscard]] point2d_t apply_scale(const f32 s) const
		{
			return {pos, scale * s};
		}
	};

	struct render_info_t
	{
	private:
		constexpr static color4 disabled = color4(0, 0, 0, 0);
		constexpr static vec4 empty{0, 0, 0, 1};
		constexpr static vec4 full{1, 1, 1, 1};

		render_info_t(const std::string_view texture, color4 color, color4 blend): texture_name(texture), color(color), blend(blend)
		{}

	public:
		// texture to use
		std::string texture_name;
		// color to use
		color4 color;
		// how much to blend the texture into the color? note blending is always additive!
		color4 blend;

		render_info_t() = default;

		static render_info_t make_info(const std::string_view texture)
		{
			render_info_t info{texture, empty, full};
			return info;
		}

		static render_info_t make_info(const color4 color)
		{
			render_info_t info{"", color, empty};
			return info;
		}

		static render_info_t make_info(const std::string_view texture, const color4 color, const color4 blend)
		{
			render_info_t info{texture, color, blend};
			return info;
		}
	};

	class batch_renderer_2d
	{
	private:
		std::unique_ptr<pp_engine_t> engine;

		template <typename T>
		struct render_object_t
		{
			f32 z_index;
			T obj;

			render_object_t(const f32 z_index, const T obj): z_index(z_index), obj(obj)
			{}
		};

		using rectangle2d_obj_t = render_object_t<rectangle2d_t>;
		using point2d_obj_t = render_object_t<point2d_t>;
		using line2d_obj_t = render_object_t<line2d_t>;
		using curve2d_obj_t = render_object_t<curve2d_mesh_data_t>;

		template <typename T>
		using object_container = hashmap_t<std::string, std::vector<std::pair<render_info_t, T>>>;

	private:
		std::unique_ptr<vertex_array_t> square_vao;
		std::unique_ptr<vertex_array_t> line_vao;
		std::unique_ptr<vertex_array_t> curve_vao;
		std::unique_ptr<shader_t> square_shader;
		std::unique_ptr<shader_t> point_shader;
		resource_manager& resources;
		matrix_state_manager& state;

		// texture name -> draw info
		struct
		{
			object_container<rectangle2d_obj_t> complex_rectangles;
			object_container<point2d_obj_t> complex_points;
			object_container<line2d_obj_t> complex_lines;
			object_container<curve2d_obj_t> complex_curves;
			size_t draw_count = 0;
			f32 z_min = std::numeric_limits<f32>::max();
			f32 z_max = std::numeric_limits<f32>::min();
		} draw;

		template <typename E>
		static void insert_obj(object_container<E>& map, const render_info_t& info, const E& obj)
		{
			map[info.texture_name].emplace_back(info, obj);
		}

		// called at the end of the render function
		void render_reset();

		// called before invocation of draw_objects
		void pre_reset();

		// called after draw_objects()
		void post_reset();

		void draw_points(f32 denominator);

		void draw_lines(f32 denominator);

		void draw_rectangles(f32 denominator);

		void draw_curves(f32 denominator);

		void draw_objects();

		void update_z_index(const f32 z_index)
		{
			draw.z_min = std::min(draw.z_min, -z_index);
			draw.z_max = std::max(draw.z_max, -z_index);
		}

	public:
		explicit batch_renderer_2d(resource_manager& resources, matrix_state_manager& state): resources(resources), state(state)
		{
			engine = pp_engine_t::make_multi_pp(std::make_unique<pp_render_target_t>());
		}

		explicit batch_renderer_2d(resource_manager& resources, matrix_state_manager& state, std::unique_ptr<pp_engine_t> ppEngine):
			engine(std::move(ppEngine)), resources(resources), state(state)
		{}

		void create();

		void drawRectangle(const rectangle2d_t& rectangle, std::string_view texture, f32 z_index = 0);

		void drawRectangle(const rectangle2d_t& rectangle, const vec4& color, f32 z_index = 0);

		void drawRectangle(const rectangle2d_t& rectangle, const render_info_t& draw_info, f32 z_index = 0);

		void drawLine(const line2d_t& line, std::string_view texture, f32 z_index = 0);

		void drawLine(const line2d_t& line, const vec4& color, f32 z_index = 0);

		void drawLine(const line2d_t& line, const render_info_t& draw_info, f32 z_index = 0);

		void drawPoint(const point2d_t& point, std::string_view texture, f32 z_index = 0);

		void drawPoint(const point2d_t& point, const vec4& color, f32 z_index = 0);

		void drawPoint(const point2d_t& point, const render_info_t& draw_info, f32 z_index = 0);

		void drawCurve(const curve2d_mesh_data_t& curve, std::string_view texture, f32 z_index = 0);

		void drawCurve(const curve2d_mesh_data_t& curve, const vec4& color, f32 z_index = 0);

		void drawCurve(const curve2d_mesh_data_t& curve, const render_info_t& draw_info, f32 z_index = 0);

		void render(i32 width, i32 height, bool transparency = true, bool postprocessing = false);

		void cleanup();

		[[nodiscard]] shader_t& get_square_shader() const
		{
			return *square_shader;
		}

		[[nodiscard]] size_t draw_count() const
		{
			return draw.draw_count;
		}
	};
}

#endif //BLT_WITH_GRAPHICS_BATCH_2D_RENDERER_H
