/*
 * This file is part of OpenTTD.
 * OpenTTD 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, version 2.
 * OpenTTD 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 OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

/** @file font_osx.cpp Functions related to font handling on MacOS. */

#include "../../stdafx.h"
#include "../../debug.h"
#include "font_osx.h"
#include "../../core/math_func.hpp"
#include "../../blitter/factory.hpp"
#include "../../error_func.h"
#include "../../fileio_func.h"
#include "../../string_func.h"
#include "../../strings_func.h"
#include "../../zoom_func.h"
#include "macos.h"

#include "../../table/control_codes.h"

#include "../../safeguards.h"

CoreTextFontCache::CoreTextFontCache(FontSize fs, CFAutoRelease<CTFontDescriptorRef> &&font, int pixels) : TrueTypeFontCache(fs, pixels), font_desc(std::move(font))
{
	this->SetFontSize(pixels);
}

/**
 * Reset cached glyphs.
 */
void CoreTextFontCache::ClearFontCache()
{
	/* GUI scaling might have changed, determine font size anew if it was automatically selected. */
	if (this->font) this->SetFontSize(this->req_size);

	this->TrueTypeFontCache::ClearFontCache();
}

void CoreTextFontCache::SetFontSize(int pixels)
{
	if (pixels == 0) {
		/* Try to determine a good height based on the height recommended by the font. */
		int scaled_height = ScaleGUITrad(FontCache::GetDefaultFontHeight(this->fs));
		pixels = scaled_height;

		CFAutoRelease<CTFontRef> font(CTFontCreateWithFontDescriptor(this->font_desc.get(), 0.0f, nullptr));
		if (font) {
			float min_size = 0.0f;

			/* The 'head' TrueType table contains information about the
			 * 'smallest readable size in pixels'. Try to read it, if
			 * that doesn't work, we use the default OS font size instead.
			 *
			 * Reference: https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6head.html */
			CFAutoRelease<CFDataRef> data(CTFontCopyTable(font.get(), kCTFontTableHead, kCTFontTableOptionNoOptions));
			if (data) {
				uint16_t lowestRecPPEM; // At offset 46 of the 'head' TrueType table.
				CFDataGetBytes(data.get(), CFRangeMake(46, sizeof(lowestRecPPEM)), (UInt8 *)&lowestRecPPEM);
				min_size = CFSwapInt16BigToHost(lowestRecPPEM); // TrueType data is always big-endian.
			} else {
				CFAutoRelease<CFNumberRef> size((CFNumberRef)CTFontCopyAttribute(font.get(), kCTFontSizeAttribute));
				CFNumberGetValue(size.get(), kCFNumberFloatType, &min_size);
			}

			/* Font height is minimum height plus the difference between the default
			 * height for this font size and the small size. */
			int diff = scaled_height - ScaleGUITrad(FontCache::GetDefaultFontHeight(FontSize::Small));
			/* Clamp() is not used as scaled_height could be greater than MAX_FONT_SIZE, which is not permitted in Clamp(). */
			pixels = std::min(std::max(std::min<int>(min_size, MAX_FONT_MIN_REC_SIZE) + diff, scaled_height), MAX_FONT_SIZE);
		}
	} else {
		pixels = ScaleGUITrad(pixels);
	}
	this->used_size = pixels;

	this->font.reset(CTFontCreateWithFontDescriptor(this->font_desc.get(), pixels, nullptr));

	/* Query the font metrics we needed. We generally round all values up to
	 * make sure we don't inadvertently cut off a row or column of pixels,
	 * except when determining glyph to glyph advances. */
	this->ascender = (int)std::ceil(CTFontGetAscent(this->font.get()));
	this->descender = -(int)std::ceil(CTFontGetDescent(this->font.get()));
	this->height = this->ascender - this->descender;

	/* Get real font name. */
	char name[128];
	CFAutoRelease<CFStringRef> font_name((CFStringRef)CTFontCopyAttribute(this->font.get(), kCTFontDisplayNameAttribute));
	CFStringGetCString(font_name.get(), name, lengthof(name), kCFStringEncodingUTF8);
	this->font_name = name;

	Debug(fontcache, 2, "Loaded font '{}' with size {}", this->font_name, pixels);
}

GlyphID CoreTextFontCache::MapCharToGlyph(char32_t key, bool allow_fallback)
{
	assert(IsPrintable(key));

	/* Convert characters outside of the Basic Multilingual Plane into surrogate pairs. */
	UniChar chars[2];
	if (key >= 0x010000U) {
		chars[0] = (UniChar)(((key - 0x010000U) >> 10) + 0xD800);
		chars[1] = (UniChar)(((key - 0x010000U) & 0x3FF) + 0xDC00);
	} else {
		chars[0] = (UniChar)(key & 0xFFFF);
	}

	CGGlyph glyph[2] = {0, 0};
	if (CTFontGetGlyphsForCharacters(this->font.get(), chars, glyph, key >= 0x010000U ? 2 : 1)) {
		return glyph[0];
	}

	if (allow_fallback && key >= SCC_SPRITE_START && key <= SCC_SPRITE_END) {
		return this->parent->MapCharToGlyph(key);
	}

	return 0;
}

const Sprite *CoreTextFontCache::InternalGetGlyph(GlyphID key, bool use_aa)
{
	/* Get glyph size. */
	CGGlyph glyph = (CGGlyph)key;
	CGRect bounds = CTFontGetOpticalBoundsForGlyphs(this->font.get(), &glyph, nullptr, 1, 0);
	if (CGRectIsNull(bounds)) UserError("Unable to render font glyph");

	uint bb_width = (uint)std::ceil(bounds.size.width) + 1; // Sometimes the glyph bounds are too tight and cut of the last pixel after rounding.
	uint bb_height = (uint)std::ceil(bounds.size.height);

	/* Add 1 scaled pixel for the shadow on the medium font. Our sprite must be at least 1x1 pixel. */
	uint shadow = (this->fs == FontSize::Normal) ? ScaleGUITrad(1) : 0;
	uint width = std::max(1U, bb_width + shadow);
	uint height = std::max(1U, bb_height + shadow);

	/* Limit glyph size to prevent overflows later on. */
	if (width > MAX_GLYPH_DIM || height > MAX_GLYPH_DIM) UserError("Font glyph is too large");

	SpriteLoader::SpriteCollection spritecollection;
	SpriteLoader::Sprite &sprite = spritecollection[ZoomLevel::Min];
	sprite.AllocateData(ZoomLevel::Min, width * height);
	sprite.colours = SpriteComponent::Palette;
	if (use_aa) sprite.colours.Set(SpriteComponent::Alpha);
	sprite.width = width;
	sprite.height = height;
	sprite.x_offs = (int16_t)std::round(CGRectGetMinX(bounds));
	sprite.y_offs = this->ascender - (int16_t)std::ceil(CGRectGetMaxY(bounds));

	if (bounds.size.width > 0) {
		/* Glyph is not a white-space glyph. Render it to a bitmap context. */

		/* We only need the alpha channel, as we apply our own colour constants to the sprite. */
		int pitch = Align(bb_width, 16);
		CFAutoRelease<CGContextRef> context(CGBitmapContextCreate(nullptr, bb_width, bb_height, 8, pitch, nullptr, kCGImageAlphaOnly));
		const uint8_t *bmp = static_cast<uint8_t *>(CGBitmapContextGetData(context.get()));
		/* Set antialias according to requirements. */
		CGContextSetAllowsAntialiasing(context.get(), use_aa);
		CGContextSetAllowsFontSubpixelPositioning(context.get(), use_aa);
		CGContextSetAllowsFontSubpixelQuantization(context.get(), !use_aa);
		CGContextSetShouldSmoothFonts(context.get(), false);

		CGPoint pos{-bounds.origin.x, -bounds.origin.y};
		CTFontDrawGlyphs(this->font.get(), &glyph, &pos, 1, context.get());

		/* Draw shadow for medium size. */
		if (this->fs == FontSize::Normal && !use_aa) {
			for (uint y = 0; y < bb_height; y++) {
				for (uint x = 0; x < bb_width; x++) {
					if (bmp[y * pitch + x] > 0) {
						sprite.data[shadow + x + (shadow + y) * sprite.width].m = SHADOW_COLOUR;
						sprite.data[shadow + x + (shadow + y) * sprite.width].a = use_aa ? bmp[x + y * pitch] : 0xFF;
					}
				}
			}
		}

		/* Extract pixel data. */
		for (uint y = 0; y < bb_height; y++) {
			for (uint x = 0; x < bb_width; x++) {
				if (bmp[y * pitch + x] > 0) {
					sprite.data[x + y * sprite.width].m = FACE_COLOUR;
					sprite.data[x + y * sprite.width].a = use_aa ? bmp[x + y * pitch] : 0xFF;
				}
			}
		}
	}

	UniquePtrSpriteAllocator allocator;
	BlitterFactory::GetCurrentBlitter()->Encode(SpriteType::Font, spritecollection, allocator);

	GlyphEntry new_glyph;
	new_glyph.data = std::move(allocator.data);
	new_glyph.width = (uint8_t)std::round(CTFontGetAdvancesForGlyphs(this->font.get(), kCTFontOrientationDefault, &glyph, nullptr, 1));

	return this->SetGlyphPtr(key, std::move(new_glyph)).GetSprite();
}

class CoreTextFontCacheFactory : public FontCacheFactory {
public:
	CoreTextFontCacheFactory() : FontCacheFactory("coretext", "CoreText font loader") {}

	std::unique_ptr<FontCache> LoadFont(FontSize fs, FontType fonttype, bool search, const std::string &font_name, const std::any &) const override
	{
		if (fonttype != FontType::TrueType) return nullptr;

		/* Might be a font file name, try load it. */
		CFAutoRelease<CTFontDescriptorRef> font_ref(LoadFontFromFile(font_name));
		if (!font_ref) ShowInfo("Unable to load file '{}' for {} font, using default OS font selection instead", font_name, FontSizeToName(fs));

		if (!font_ref && search) {
			CFAutoRelease<CFStringRef> name(CFStringCreateWithCString(kCFAllocatorDefault, font_name.c_str(), kCFStringEncodingUTF8));

			/* Simply creating the font using CTFontCreateWithNameAndSize will *always* return
			* something, no matter the name. As such, we can't use it to check for existence.
			* We instead query the list of all font descriptors that match the given name which
			* does not do this stupid name fallback. */
			CFAutoRelease<CTFontDescriptorRef> name_desc(CTFontDescriptorCreateWithNameAndSize(name.get(), 0.0));
			CFAutoRelease<CFSetRef> mandatory_attribs(CFSetCreate(kCFAllocatorDefault, const_cast<const void **>(reinterpret_cast<const void * const *>(&kCTFontNameAttribute)), 1, &kCFTypeSetCallBacks));
			CFAutoRelease<CFArrayRef> descs(CTFontDescriptorCreateMatchingFontDescriptors(name_desc.get(), mandatory_attribs.get()));

			/* Assume the first result is the one we want. */
			if (descs && CFArrayGetCount(descs.get()) > 0) {
				font_ref.reset((CTFontDescriptorRef)CFArrayGetValueAtIndex(descs.get(), 0));
				CFRetain(font_ref.get());
			}
		}

		if (!font_ref) {
			ShowInfo("Unable to use '{}' for {} font, using sprite font instead", font_name, FontSizeToName(fs));
			return nullptr;
		}

		return std::make_unique<CoreTextFontCache>(fs, std::move(font_ref), GetFontCacheFontSize(fs));
	}

	bool FindFallbackFont(const std::string &language_isocode, MissingGlyphSearcher *callback) const override
	{
		/* Determine fallback font using CoreText. This uses the language isocode
		 * to find a suitable font. CoreText is available from 10.5 onwards. */
		std::string lang;
		if (language_isocode == "zh_TW") {
			/* Traditional Chinese */
			lang = "zh-Hant";
		} else if (language_isocode == "zh_CN") {
			/* Simplified Chinese */
			lang = "zh-Hans";
		} else {
			/* Just copy the first part of the isocode. */
			lang = language_isocode.substr(0, language_isocode.find('_'));
		}

		/* Create a font descriptor matching the wanted language and latin (english) glyphs.
		 * Can't use CFAutoRelease here for everything due to the way the dictionary has to be created. */
		CFStringRef lang_codes[2];
		lang_codes[0] = CFStringCreateWithCString(kCFAllocatorDefault, lang.c_str(), kCFStringEncodingUTF8);
		lang_codes[1] = CFSTR("en");
		CFArrayRef lang_arr = CFArrayCreate(kCFAllocatorDefault, (const void **)lang_codes, lengthof(lang_codes), &kCFTypeArrayCallBacks);
		CFAutoRelease<CFDictionaryRef> lang_attribs(CFDictionaryCreate(kCFAllocatorDefault, const_cast<const void **>(reinterpret_cast<const void *const *>(&kCTFontLanguagesAttribute)), (const void **)&lang_arr, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
		CFAutoRelease<CTFontDescriptorRef> lang_desc(CTFontDescriptorCreateWithAttributes(lang_attribs.get()));
		CFRelease(lang_arr);
		CFRelease(lang_codes[0]);

		/* Get array of all font descriptors for the wanted language. */
		CFAutoRelease<CFSetRef> mandatory_attribs(CFSetCreate(kCFAllocatorDefault, const_cast<const void **>(reinterpret_cast<const void *const *>(&kCTFontLanguagesAttribute)), 1, &kCFTypeSetCallBacks));
		CFAutoRelease<CFArrayRef> descs(CTFontDescriptorCreateMatchingFontDescriptors(lang_desc.get(), mandatory_attribs.get()));

		bool result = false;
		for (int tries = 0; tries < 2; tries++) {
			for (CFIndex i = 0; descs.get() != nullptr && i < CFArrayGetCount(descs.get()); i++) {
				CTFontDescriptorRef font = (CTFontDescriptorRef)CFArrayGetValueAtIndex(descs.get(), i);

				/* Get font traits. */
				CFAutoRelease<CFDictionaryRef> traits((CFDictionaryRef)CTFontDescriptorCopyAttribute(font, kCTFontTraitsAttribute));
				CTFontSymbolicTraits symbolic_traits;
				CFNumberGetValue((CFNumberRef)CFDictionaryGetValue(traits.get(), kCTFontSymbolicTrait), kCFNumberIntType, &symbolic_traits);

				/* Skip symbol fonts and vertical fonts. */
				if ((symbolic_traits & kCTFontClassMaskTrait) == (CTFontStylisticClass)kCTFontSymbolicClass || (symbolic_traits & kCTFontVerticalTrait)) continue;
				/* Skip bold fonts (especially Arial Bold, which looks worse than regular Arial). */
				if (symbolic_traits & kCTFontBoldTrait) continue;
				/* Select monospaced fonts if asked for. */
				if (((symbolic_traits & kCTFontMonoSpaceTrait) == kCTFontMonoSpaceTrait) != callback->missing_fontsizes.Test(FontSize::Monospace)) continue;

				/* Get font name. */
				char buffer[128];
				CFAutoRelease<CFStringRef> font_name((CFStringRef)CTFontDescriptorCopyAttribute(font, kCTFontDisplayNameAttribute));
				CFStringGetCString(font_name.get(), buffer, std::size(buffer), kCFStringEncodingUTF8);

				/* Serif fonts usually look worse on-screen with only small
				 * font sizes. As such, we try for a sans-serif font first.
				 * If we can't find one in the first try, try all fonts. */
				if (tries == 0 && (symbolic_traits & kCTFontClassMaskTrait) != (CTFontStylisticClass)kCTFontSansSerifClass) continue;

				/* There are some special fonts starting with an '.' and the last
				 * resort font that aren't usable. Skip them. */
				std::string_view name{buffer};
				if (name.starts_with(".") || name.starts_with("LastResort")) continue;

				/* Save result. */
				result = FontCache::TryFallback(callback->missing_fontsizes, callback->missing_glyphs, std::string{name});
				if (result) {
					FontCache::AddFallback(callback->missing_fontsizes, name);
					Debug(fontcache, 2, "CT-Font for {}: {}", language_isocode, name);
					break;
				}
			}
		}

		if (!result) {
			/* For some OS versions, the font 'Arial Unicode MS' does not report all languages it
			 * supports. If we didn't find any other font, just try it, maybe we get lucky. */
			result = FontCache::TryFallback(callback->missing_fontsizes, callback->missing_glyphs, "Arial Unicode MS");
			if (result) {
				FontCache::AddFallback(callback->missing_fontsizes, "Arial Unicode MS");
			}
		}

		return result;
	}

private:
	static CTFontDescriptorRef LoadFontFromFile(const std::string &font_name)
	{
		/* Might be a font file name, try load it. Direct font loading is
		 * only supported starting on OSX 10.6. */
		CFAutoRelease<CFStringRef> path;

		/* See if this is an absolute path. */
		if (FileExists(font_name)) {
			path.reset(CFStringCreateWithCString(kCFAllocatorDefault, font_name.c_str(), kCFStringEncodingUTF8));
		} else {
			/* Scan the search-paths to see if it can be found. */
			std::string full_font = FioFindFullPath(Subdirectory::Base, font_name);
			if (!full_font.empty()) {
				path.reset(CFStringCreateWithCString(kCFAllocatorDefault, full_font.c_str(), kCFStringEncodingUTF8));
			}
		}

		if (path) {
			/* Try getting a font descriptor to see if the system can use it. */
			CFAutoRelease<CFURLRef> url(CFURLCreateWithFileSystemPath(kCFAllocatorDefault, path.get(), kCFURLPOSIXPathStyle, false));
			CFAutoRelease<CFArrayRef> descs(CTFontManagerCreateFontDescriptorsFromURL(url.get()));

			if (descs && CFArrayGetCount(descs.get()) > 0) {
				CTFontDescriptorRef font_ref = (CTFontDescriptorRef)CFArrayGetValueAtIndex(descs.get(), 0);
				CFRetain(font_ref);
				return font_ref;
			}
		}

		return nullptr;
	}

private:
	static CoreTextFontCacheFactory instance;
};

/* static */ CoreTextFontCacheFactory CoreTextFontCacheFactory::instance;
