#include "TTFFont.hh"

#include "LocalFileReference.hh"
#include "MSXException.hh"

#include "StringOp.hh"
#include "stl.hh"
#include "zstring_view.hh"

#include <SDL_ttf.h>

#include <algorithm>
#include <cassert>
#include <vector>

namespace openmsx {

class SDLTTF
{
public:
	SDLTTF(const SDLTTF&) = delete;
	SDLTTF(SDLTTF&&) = delete;
	SDLTTF& operator=(const SDLTTF&) = delete;
	SDLTTF& operator=(SDLTTF&&) = delete;

	static SDLTTF& instance();

private:
	SDLTTF();
	~SDLTTF();
};

class TTFFontPool
{
public:
	TTFFontPool(const TTFFontPool&) = delete;
	TTFFontPool(TTFFontPool&&) = delete;
	TTFFontPool& operator=(const TTFFontPool&) = delete;
	TTFFontPool& operator=(TTFFontPool&&) = delete;

	static TTFFontPool& instance();
	TTF_Font* get(const std::string& filename, int ptSize, int faceIndex);
	void release(TTF_Font* font);

private:
	TTFFontPool() = default;
	~TTFFontPool();

	// We want to keep the LocalFileReference object alive for as long as
	// the SDL_ttf library uses the font. This solves a problem we had in
	// the past on windows that temporary files were not cleaned up. The
	// scenario went like this:
	//  1. new LocalFileReference object (possibly) creates a temp file
	//  2. SDL_ttf opens this file (and keeps it open)
	//  3. LocalFileReference object goes out of scope and deletes the
	//     temp file
	//  4. (much later) we're done using the font and SDL_ttf closes the
	//     file
	// Step 3 goes wrong in windows because it's not possible to delete a
	// still opened file (no problem in unix). Solved by swapping the order
	// of step 3 and 4. Though this has the disadvantage that if openMSX
	// crashes between step 3 and 4 the temp file is still left behind.
	struct FontInfo {
		LocalFileReference file;
		TTF_Font* font;
		std::string name;
		int size;
		int count;
		int faceIndex;
	};
	std::vector<FontInfo> pool;
};


// class SDLTTF

SDLTTF::SDLTTF()
{
	if (TTF_Init() < 0) {
		throw FatalError("Couldn't initialize SDL_ttf: ", TTF_GetError());
	}
}

SDLTTF::~SDLTTF()
{
	TTF_Quit();
}

SDLTTF& SDLTTF::instance()
{
	static SDLTTF oneInstance;
	return oneInstance;
}


// class TTFFontPool

TTFFontPool::~TTFFontPool()
{
	assert(pool.empty());
}

TTFFontPool& TTFFontPool::instance()
{
	static TTFFontPool oneInstance;
	return oneInstance;
}

TTF_Font* TTFFontPool::get(const std::string& filename, int ptSize, int faceIndex)
{
	if (auto it = std::ranges::find(pool, std::tuple(filename, ptSize, faceIndex),
	        [](auto& info) { return std::tuple(info.name, info.size, info.faceIndex); });
	    it != end(pool)) {
		++it->count;
		return it->font;
	}

	SDLTTF::instance(); // init library
	FontInfo info;
	info.file = LocalFileReference(filename);
	auto* result = TTF_OpenFontIndex(info.file.getFilename().c_str(), ptSize, faceIndex);
	if (!result) {
		throw MSXException(TTF_GetError());
	}
	info.font = result;
	info.name = filename;
	info.size = ptSize;
	info.count = 1;
	info.faceIndex = faceIndex;
	pool.push_back(std::move(info));
	return result;
}

void TTFFontPool::release(TTF_Font* font)
{
	auto it = rfind_unguarded(pool, font, &FontInfo::font);
	--it->count;
	if (it->count == 0) {
		TTF_CloseFont(it->font);
		move_pop_back(pool, it);
	}
}


// class TTFFont

TTFFont::TTFFont(const std::string& filename, int ptSize, int faceIndex)
	: font(TTFFontPool::instance().get(filename, ptSize, faceIndex))
{
}

TTFFont::~TTFFont()
{
	if (!font) return;
	TTFFontPool::instance().release(static_cast<TTF_Font*>(font));
}

SDLSurfacePtr TTFFont::render(std::string text, uint8_t r, uint8_t g, uint8_t b) const
{
	SDL_Color color = { r, g, b, 0 };

	// Optimization: remove trailing empty lines
	StringOp::trimRight(text, " \n");
	if (text.empty()) return SDLSurfacePtr(nullptr);

	// Split on newlines
	auto lines_view = StringOp::split_view(text, '\n');
	auto lines_it = lines_view.begin();
	auto lines_end = lines_view.end();
	assert(lines_it != lines_end);

	auto current_line = *lines_it;
	++lines_it;
	if (lines_it == lines_end) {
		// Special case for a single line: we can avoid the
		// copy to an extra SDL_Surface
		assert(!text.empty());
		SDLSurfacePtr surface(
			TTF_RenderUTF8_Blended(static_cast<TTF_Font*>(font),
			                       text.c_str(), color));
		if (!surface) {
			throw MSXException(TTF_GetError());
		}
		return surface;
	}

	// Determine maximum width and lineHeight
	int width = 0;
	int lineHeight = 0; // initialize to avoid warning
	int numLines = 1;
	while (true) {
		auto [w, h] = getSize(std::string(current_line));
		width = std::max(width, w);
		lineHeight = h;
		if (lines_it == lines_end) break;
		current_line = *lines_it;
		++lines_it;
		++numLines;
	}
	// There might be extra space between two successive lines
	// (so lineSkip might be bigger than lineHeight).
	int lineSkip = getHeight();
	// We assume that height is the same for all lines.
	// For the last line we don't include spacing between two lines.
	auto height = (numLines - 1) * lineSkip + lineHeight;

	// Create destination surface (initial surface is fully transparent)
	SDLSurfacePtr destination(SDL_CreateRGBSurface(SDL_SWSURFACE, width, height,
			32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000));
	if (!destination) {
		throw MSXException("Couldn't allocate surface for multiline text.");
	}

	// Actually render the text:
	// TODO use enumerate() in the future (c++20)
	int i = -1;
	for (auto line : lines_view) {
		++i;
		// Render single line
		if (line.empty()) {
			// SDL_TTF gives an error on empty lines, but we can
			// simply skip such lines
			continue;
		}
		SDLSurfacePtr surf(TTF_RenderUTF8_Blended(
			static_cast<TTF_Font*>(font),
			std::string(line).c_str(), color));
		if (!surf) {
			throw MSXException(TTF_GetError());
		}

		// Copy line to destination surface
		SDL_Rect rect;
		rect.x = 0;
		rect.y = Sint16(i * lineSkip);
		SDL_SetSurfaceBlendMode(surf.get(), SDL_BLENDMODE_NONE); // no blending during copy
		SDL_BlitSurface(surf.get(), nullptr, destination.get(), &rect);
	}
	return destination;
}

int TTFFont::getHeight() const
{
	return TTF_FontLineSkip(static_cast<TTF_Font*>(font));
}

bool TTFFont::isFixedWidth() const
{
	return TTF_FontFaceIsFixedWidth(static_cast<TTF_Font*>(font)) != 0;
}

int TTFFont::getWidth() const
{
	int advance;
	if (TTF_GlyphMetrics(static_cast<TTF_Font*>(font), Uint16('M'),
	                     nullptr /*minx*/, nullptr /*maxx*/,
	                     nullptr /*miny*/, nullptr /*maxy*/,
	                     &advance)) {
		// error?
		return 10; //fallback-width
	}
	return advance;
}

gl::ivec2 TTFFont::getSize(zstring_view text) const
{
	int width, height;
	if (TTF_SizeUTF8(static_cast<TTF_Font*>(font), text.c_str(),
	                 &width, &height)) {
		throw MSXException(TTF_GetError());
	}
	return {width, height};
}

} // namespace openmsx