/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#include "TextDrawable.hpp"
#include "Scene/Geometry.hpp"
#include "Shader/Shader.hpp"
#include "Text/IFontAtlasGenerator.hpp"
#include "Base/Logger.hpp"
#include "DataFormat.hpp"
#include <utf8.h>

namespace OpenVulkano::Scene
{
	namespace
	{
		constexpr uint32_t MISSING_GLYPH_SYMBOL = '?';

		Shader DEFAULT_SHADER_BITMAP = TextDrawable::MakeDefaultShader(FontAtlasType::BITMAP);
		Shader DEFAULT_SHADER_BITMAP_SUBPIXEL = TextDrawable::MakeDefaultShader(FontAtlasType::BITMAP_SUBPIXEL);
		Shader DEFAULT_SHADER_SDF = TextDrawable::MakeDefaultShader(FontAtlasType::SDF);
		Shader DEFAULT_SHADER_MSDF = TextDrawable::MakeDefaultShader(FontAtlasType::MSDF);

		void HandleSpecialCharacter(const std::map<uint32_t, GlyphInfo>& symbols, uint32_t c,
									const float heightBetweenLines, const float initialPosX,
									float& cursorX, float& cursorY, float& prevGlyphXBound)
		{
			if (c == '\n')
			{
				cursorY -= heightBetweenLines;
				prevGlyphXBound = -INFINITY;
				cursorX = initialPosX;
			}
			else if (c == '\t')
			{
				if (!symbols.contains(' '))
				{
					Logger::RENDER->warn("Tab special character can't be handled since no space glyph is available", c);
					return;
				}
				const GlyphInfo& info = symbols.at(' ');
				cursorX += info.advance * 4;
				prevGlyphXBound = cursorX;
			}
			else if (c == '\v')
			{
				cursorY -= heightBetweenLines;
			}

		}
	}

	Shader TextDrawable::MakeDefaultShader(const FontAtlasType type)
	{
		Shader shader;
		shader.AddShaderProgram(ShaderProgramType::VERTEX, "Shader/text");
		shader.AddShaderProgram(ShaderProgramType::FRAGMENT, std::string(type.GetDefaultFragmentShader()));
		VertexInputDescription inputDesc(0, sizeof(TextGlyphVertex));
		inputDesc.AddInputParameter(DataFormat::R32G32_SFLOAT, offsetof(TextGlyphVertex, position));
		inputDesc.AddInputParameter(DataFormat::R32G32_SFLOAT, offsetof(TextGlyphVertex, position)+8);
		inputDesc.AddInputParameter(DataFormat::R32G32_SFLOAT, offsetof(TextGlyphVertex, position)+16);
		inputDesc.AddInputParameter(DataFormat::R32G32_SFLOAT, offsetof(TextGlyphVertex, position)+24);
		inputDesc.AddInputParameter(DataFormat::R32G32_SFLOAT, offsetof(TextGlyphVertex, uv));
		inputDesc.AddInputParameter(DataFormat::R32G32_SFLOAT, offsetof(TextGlyphVertex, uv)+8);
		inputDesc.AddInputParameter(DataFormat::R32G32_SFLOAT, offsetof(TextGlyphVertex, uv)+16);
		inputDesc.AddInputParameter(DataFormat::R32G32_SFLOAT, offsetof(TextGlyphVertex, uv)+24);
		inputDesc.AddInputParameter(DataFormat::R8G8B8A8_UNORM, offsetof(TextGlyphVertex, color));
		inputDesc.AddInputParameter(DataFormat::R8G8B8A8_UNORM, offsetof(TextGlyphVertex, background));
		inputDesc.stepMode = VertexStepMode::INSTANCE;
		shader.AddVertexInputDescription(inputDesc);
		shader.AddDescriptorSetLayoutBinding(Texture::DESCRIPTOR_SET_LAYOUT_BINDING);
		shader.alphaBlend = true;
		shader.cullMode = CullMode::NONE;
		shader.topology = Topology::TRIANGLE_STRIP;
		return shader;
	}

	TextDrawable::TextDrawable(const TextConfig& config)
			: Drawable(DrawEncoder::GetDrawEncoder<TextDrawable>()), m_cfg(config)
	{}

	TextDrawable::TextDrawable(const std::shared_ptr<FontAtlas>& atlasData, const TextConfig& config)
		: Drawable(DrawEncoder::GetDrawEncoder<TextDrawable>()), m_atlasData(atlasData), m_cfg(config)
	{
		if (!atlasData || !*atlasData) throw std::runtime_error("Cannot initialize text drawable with empty atlas data");
	}

	uint32_t TextDrawable::GetFallbackGlyph() const
	{ //TODO move into FontAtlas
		if (m_atlasData->GetGlyphs().contains(MISSING_GLYPH_SYMBOL))
		{
			return MISSING_GLYPH_SYMBOL;
		}
		Logger::RENDER->warn("Could not find glyph for character ? to use as fallback. Using first glyph instead");
		return m_atlasData->GetGlyphs().begin()->first;
	}

	float TextDrawable::GetHeightBetweenLines(const std::string& text) const
	{
		if (!m_cfg.minimalSpacingBetweenMultipleLines)
		{
			return m_atlasData->GetLineHeight();
		}
		const std::map<uint32_t, GlyphInfo>& symbols = m_atlasData->GetGlyphs();
		const uint32_t fallbackGlyph = GetFallbackGlyph();
		std::vector<float> heightBetweenLines;
		float currentLineHeightAboveBaseline = 0;
		float currentLineHeightBelowBaseline = 0;
		float prevLineHeightBelowBaseline = -INFINITY;
		float extraOffset = m_atlasData->GetAtlasType().IsBitmap() ? 0.1 : 0.05;
		bool isMultiline = false;

		for (auto begin = text.begin(), end = text.end(); begin != end;)
		{
			uint32_t c = utf8::next(begin, end);
			if (c == '\n' || c == '\v')
			{
				isMultiline = true;
				if (prevLineHeightBelowBaseline != -INFINITY)
				{
					heightBetweenLines.push_back(std::abs(prevLineHeightBelowBaseline)
					                             + std::abs(currentLineHeightAboveBaseline) + extraOffset);
					prevLineHeightBelowBaseline = currentLineHeightBelowBaseline;
				}
				prevLineHeightBelowBaseline = currentLineHeightBelowBaseline;
				currentLineHeightAboveBaseline = currentLineHeightBelowBaseline = 0;
				continue;
			}

			if (!symbols.contains(c))
			{
				c = fallbackGlyph;
			}
			const GlyphInfo& info = symbols.at(c);
			currentLineHeightAboveBaseline = std::max(currentLineHeightAboveBaseline, info.pos[2].y);
			currentLineHeightBelowBaseline = std::min(currentLineHeightBelowBaseline, -info.pos[0].y);
		}

		if (isMultiline && text.back() != '\n')
		{
			heightBetweenLines.push_back(std::abs(prevLineHeightBelowBaseline)
			                             + std::abs(currentLineHeightAboveBaseline) + extraOffset);
		}

		if (heightBetweenLines.empty())
		{
			return 0;
		}

		float maxH = *std::max_element(heightBetweenLines.begin(), heightBetweenLines.end());
		return std::min<float>(m_atlasData->GetLineHeight(), maxH);
	}

	bool TextDrawable::IsSpecialCharacter(uint32_t c) const
	{
		return c == '\t' || c == '\n' || c == '\v';
	}

	void TextDrawable::GenerateText(const std::string& text, const Math::Vector2f& pos, float scale)
	{
		if (text.empty()) return;
		if (m_vertexBuffer.data) throw std::runtime_error("Text has already been initialized");
		const uint32_t fallbackGlyph = GetFallbackGlyph();

		m_text = text;
		m_symbolCount = 0;
		const size_t len = utf8::distance(text.begin(), text.end());
		m_vertexBuffer.Close();
		TextGlyphVertex* vertices = m_vertexBuffer.Init<TextGlyphVertex>(len);
		const std::map<uint32_t, GlyphInfo>& symbols = m_atlasData->GetGlyphs();

		Math::Vector2f cursor = pos / scale;
		Math::Vector2f bmin(pos), bmax(pos);
		float prevGlyphXBound = -INFINITY;
		const float heightBetweenLines = GetHeightBetweenLines(text);

		for (auto begin = text.begin(), end = text.end(); begin != end;)
		{
			uint32_t c = utf8::next(begin, end);
			if (IsSpecialCharacter(c))
			{
				HandleSpecialCharacter(symbols, c, heightBetweenLines, pos.x, cursor.x, cursor.y, prevGlyphXBound);
				continue;
			}
			
			if (!symbols.contains(c))
			{
				Logger::RENDER->warn("Could not find glyph for character {}, using fallback", c);
				c = fallbackGlyph;
			}

			const GlyphInfo& info = symbols.at(c);

			float offset = 0;
			const bool isZeroLenGlyph = info.pos[1].x == 0;
			const bool isBitmap = m_atlasData->GetAtlasType().IsBitmap();
			if (prevGlyphXBound != -INFINITY && !isZeroLenGlyph && !isBitmap)
			{
				offset = prevGlyphXBound - (info.pos[0].x + cursor.x);
			}
			
			for (int i = 0; i < 4; i++)
			{
				vertices->position[i].x = info.pos[i].x + cursor.x + offset;
				vertices->uv[i] = info.uv[i];
				if (i < 2)
				{
					vertices->position[i].y = cursor.y - info.pos[i].y;
				}
				else
				{
					vertices->position[i].y = cursor.y + info.pos[i].y;
				}
				vertices->color = m_cfg.textColor;
				vertices->background = m_cfg.backgroundColor;
				vertices->position[i] *= scale;
			}

			// somehow it's possible that cursorX can be less than prevGlyphXBound for sdf atlases
			// e.g. string `A, _` where space is not noticeable in the resulting output
			cursor.x = std::max(cursor.x, prevGlyphXBound);
			// slight offset for bitmap atlas since it's tightly packed without any extra padding, while sdf has additional padding
			cursor.x += info.advance + (isBitmap ? 0.05 : 0);
			prevGlyphXBound = isZeroLenGlyph ? cursor.x : vertices->position[2].x / scale;

			if (!m_symbolCount) bmin.x = vertices->position[0].x;
			bmax.x = std::max(bmax.x, vertices->position[1].x);
			bmax.y = std::max(bmax.y, vertices->position[3].y);
			bmin.y = std::min(bmin.y, vertices->position[1].y);
			std::swap(vertices->position[2], vertices->position[3]);
			std::swap(vertices->uv[2], vertices->uv[3]);
			vertices++;
			m_symbolCount++;
		}
		m_bbox.Init(bmin, bmax);

		if (!GetShader()) SetShader(GetDefaultShader(m_atlasData->GetAtlasType()));
	}

	void TextDrawable::SetAtlasData(const std::shared_ptr<FontAtlas>& atlasData)
	{
		if (!atlasData || !*atlasData) throw std::runtime_error("Cannot initialize text drawable with empty atlas data");
		m_atlasData = atlasData;
	}

	Shader* TextDrawable::GetDefaultShader(const FontAtlasType type)
	{
		switch (type)
		{
			case FontAtlasType::SDF: return &DEFAULT_SHADER_SDF;
			case FontAtlasType::MSDF: return &DEFAULT_SHADER_MSDF;
			default: Logger::RENDER->warn("No default shader for atlas type: {}", type.GetName());
			case FontAtlasType::BITMAP: return &DEFAULT_SHADER_BITMAP;
			case FontAtlasType::BITMAP_SUBPIXEL: return &DEFAULT_SHADER_BITMAP_SUBPIXEL;
		}
	}
}