#include "font_system.h"

#include "emoji_detector.h"

void font_manager::destroy() {
	fonts_.clear();
	emoji_font_ids_.clear();
	atlas_manager_.clear();
	primary_font_id_ = -1;
	next_font_id_    = 0;
	destroy_font_system();
}

int font_manager::add_font(const std::filesystem::path& in_font_path, const std::string& in_font_type) {
	auto font = create_font_face(in_font_path);
	if (!font) {
		return -1;
	}

	int font_id     = next_font_id_++;
	fonts_[font_id] = font;

	// 如果支持彩色表情或明确指定为表情字体，添加到表情字体列表
	if (font->supports_color_emoji() || in_font_type == "emoji") {
		emoji_font_ids_.push_back(font_id);
	}

	// 如果是第一个添加的字体，自动设为主字体
	if (primary_font_id_ == -1) {
		primary_font_id_ = font_id;
	}

	return font_id;
}

std::shared_ptr<font_face_interface> font_manager::get_font_for_code_point(uint32_t in_code_point) {
	// 首先尝试主字体
	auto primary = get_primary_font();
	if (primary && primary->has_glyph(in_code_point)) {
		return primary;
	}

	// 对表情符号使用表情符号字体
	if (emoji_detector::is_emoji(in_code_point)) {
		for (int emoji_id : emoji_font_ids_) {
			auto emoji_font = fonts_[emoji_id];
			if (emoji_font && emoji_font->has_glyph(in_code_point)) {
				return emoji_font;
			}
		}
	}

	// 尝试所有其他字体
	for (const auto& [id, font] : fonts_) {
		if (id != primary_font_id_ && font->has_glyph(in_code_point)) {
			return font;
		}
	}

	// 回退到主字体
	return primary;
}

/**
 * @brief 布局文本，将Unicode文本转换为可渲染的字形布局
 */
text_layout_t font_manager::layout_text(
    const std::u32string& text,
    const std::shared_ptr<font_face_interface>& in_font,
    float font_size,
    float max_width,
    float line_spacing)
{
    text_layout_t layout;

    // 使用指定字体或主字体
    const auto& primary_font = in_font ? in_font : get_primary_font();
    assert(primary_font && "No valid font available");
	primary_font->set_font_size(font_size);

    // 初始化布局变量
    float cursor_x = 0.0f;
    float cursor_y = 0.0f;
	float line_max_width = 0.0f;

    const auto& v_metrics = primary_font->get_metrics();

    float font_ascent = v_metrics.ascent;
    float font_descent = std::abs(v_metrics.descent);

    int32_t last_index = 0;  // 上一个字形索引，用于字距调整
    float line_start_x = 0.0f;  // 当前行的起始x坐标

    // 当前行的基线位置
    float baseline = cursor_y + font_ascent;

    // 当前使用的字体，开始时使用主字体
    auto using_font = primary_font;

    // 完成当前行的布局
    auto finish_line = [&]() {
        // 根据当前行的最大上升值确定最终基线位置
        baseline = cursor_y + font_ascent;

    	line_max_width = std::max(line_max_width, cursor_x);
		const float line_height = v_metrics.line_height() + line_spacing;

        // 移到下一行
        cursor_y += line_height;
        cursor_x = 0.0f;
        line_start_x = 0.0f;

        // 重置为下一行的基线计算
        font_ascent = v_metrics.ascent;
        font_descent = std::abs(v_metrics.descent);
        baseline = cursor_y + font_ascent;
    };

	layout.ascent = font_ascent;

    // 处理每个字符
    for (const auto& c : text) {
        // 检查是否是换行符
        if (c == U'\n') {
            finish_line();
            continue;
        }

        // 检查是否是表情符号
        const bool is_emoji = emoji_detector::is_emoji(c);

        // 获取字形索引
        auto glyph_index = using_font->find_glyph_index(c);

        // 如果当前字体不支持该字符，尝试查找支持该字符的其他字体
        if (glyph_index == 0) {
            using_font = get_font_for_code_point(c);
            if (!using_font) {
                continue;  // 如果没有找到支持的字体，跳过该字符
            }

            // 使用新字体重新获取字形索引
            glyph_index = using_font->find_glyph_index(c);
        }
    	using_font->set_font_size(font_size);

        // 获取字形度量信息
        const auto& glyph_metrics = using_font->shape_glyph(glyph_index);

        // 获取或创建字形在图集中的区域
        const auto& region = get_or_create_glyph_by_index(glyph_metrics.glyph_index, using_font, font_size, is_emoji);
        if (!region) {
            continue;  // 如果无法在图集中获取或创建字形，跳过该字符
        }

        // 检查是否需要换行
        if (max_width > 0 && cursor_x + glyph_metrics.advance.x() > max_width && cursor_x > line_start_x) {  // 确保不是行首字符
            finish_line();
        }

        // 计算字形坐标
        float x = cursor_x + glyph_metrics.offset.x() + glyph_metrics.rect.left();
    	// float y = cursor_y + font_ascent + glyph_metrics->rect.top() + font_descent;
    	float y = baseline + glyph_metrics.rect.top();

        // 添加字形位置信息到布局
        auto& glyph_position       = layout.glyphs.emplace_back();
        glyph_position.is_emoji    = is_emoji;
        glyph_position.glyph_index = glyph_index;
        glyph_position.position    = { x, y };
        glyph_position.size        = glyph_metrics.rect.size();
        glyph_position.region      = *region;

        // 更新光标位置
        cursor_x += glyph_metrics.advance.x() + glyph_metrics.rect.left();

        // 应用字距调整
        if (last_index > 0) {
            const float kern_advance = using_font->get_kerning(last_index, glyph_index);
            cursor_x += kern_advance;
        }

        // 记录当前字形索引以便下次计算字距
        last_index = glyph_index;
    }

	finish_line();

    // 设置文本布局的总体尺寸
    layout.total_size = {
        line_max_width,
        cursor_y  // cursor_y已经包含了所有行的高度
    };

    return layout;
}


/**
 * @brief 获取或创建字形在图集中的区域
 */
std::optional<atlas_region_t> font_manager::get_or_create_glyph_by_index(
    int32_t in_glyph_id,
    const std::shared_ptr<font_face_interface>& in_font,
    float in_font_size,
    bool is_emoji)
{
    // 验证字体有效性
    if (!in_font) {
        return std::nullopt;
    }

	return atlas_manager_.get_or_create_glyph(in_glyph_id, in_font, in_font_size, is_emoji);
}

font_manager::font_manager() {
	// 初始化字体系统
	if (!init_font_system()) {
		throw std::runtime_error("无法初始化字体系统");
	}
}
