#pragma once
#ifndef Convention_Runtime_String_Hpp
#define Convention_Runtime_String_Hpp

#include "Config.hpp"

namespace Convention
{
	/**
	 * @brief 限制字符串长度，如果超过最大长度则截取头尾部分并在中间添加省略号
	 * @tparam StringType 字符串类型 (std::string, std::wstring等)
	 * @param data 输入数据
	 * @param max_length 最大长度（默认50）
	 * @return 处理后的字符串
	 */
	template<typename StringType = std::string, typename DataType>
	StringType LimitStringLength(const DataType& data, size_t max_length = 50)
	{
		StringType s;
		if constexpr (std::is_convertible_v<DataType, StringType>)
		{
			s = static_cast<StringType>(data);
		}
		else
		{
			if constexpr (std::is_same_v<StringType, std::string>)
				s = std::to_string(data);
			else if constexpr (std::is_same_v<StringType, std::wstring>)
				s = std::to_wstring(data);
			else
				s = StringType(data);
		}

		if (s.length() <= max_length)
		{
			return s;
		}
		else
		{
			StringType inside_str;
			if constexpr (std::is_same_v<StringType, std::wstring>)
				inside_str = L"\n...\n...\n";
			else
				inside_str = "\n...\n...\n";

			// 计算头尾部分的长度
			size_t head_length = max_length / 2;
			size_t tail_length = max_length - head_length - inside_str.length();

			// 截取头尾部分并连接
			return s.substr(0, head_length) + inside_str + s.substr(s.length() - tail_length);
		}
	}

	/**
	 * @brief 字符串填充对齐
	 * @tparam StringType 字符串类型
	 * @param data 输入数据
	 * @param max_length 目标长度（默认50）
	 * @param fill_char 填充字符（默认空格）
	 * @param side 对齐方式: "left"(左对齐)、"right"(右对齐)、"center"(居中，默认right）
	 * @return 填充后的字符串
	 */
	template<typename StringType = std::string, typename DataType>
	StringType FillString(
		const DataType& data,
		size_t max_length = 50,
		typename StringType::value_type fill_char = ' ',
		const char* side = "right")
	{
		StringType s;
		if constexpr (std::is_convertible_v<DataType, StringType>)
		{
			s = static_cast<StringType>(data);
		}
		else
		{
			if constexpr (std::is_same_v<StringType, std::string>)
				s = std::to_string(data);
			else if constexpr (std::is_same_v<StringType, std::wstring>)
				s = std::to_wstring(data);
			else
				s = StringType(data);
		}

		if (s.length() >= max_length)
		{
			return s;
		}
		else
		{
			size_t fill_count = max_length - s.length();

			if (strcmp(side, "left") == 0)
			{
				return s + StringType(fill_count, fill_char);
			}
			else if (strcmp(side, "right") == 0)
			{
				return StringType(fill_count, fill_char) + s;
			}
			else if (strcmp(side, "center") == 0)
			{
				size_t left = fill_count / 2;
				size_t right = fill_count - left;
				return StringType(left, fill_char) + s + StringType(right, fill_char);
			}
			else
			{
				throw std::invalid_argument("Unsupported side: must be 'left', 'right', or 'center'");
			}
		}
	}

	/**
	 * @brief 将字节数组转换为字符串数组
	 * @param lines 字节数组列表
	 * @return 字符串数组
	 */
	inline std::vector<std::string> Bytes2Strings(const std::vector<std::vector<uint8_t>>& lines)
	{
		std::vector<std::string> result;
		result.reserve(lines.size());

		for (const auto& line : lines)
		{
			result.emplace_back(line.begin(), line.end());
		}

		return result;
	}

	/**
	 * @brief 将字节数组转换为字符串数组（使用char*指针和长度）
	 * @param lines 字节数组列表
	 * @return 字符串数组
	 */
	inline std::vector<std::string> Bytes2Strings(const std::vector<std::pair<const char*, size_t>>& lines)
	{
		std::vector<std::string> result;
		result.reserve(lines.size());

		for (const auto& [ptr, len] : lines)
		{
			result.emplace_back(ptr, len);
		}

		return result;
	}

	/**
	 * @brief 将字节数组转换为单个字符串
	 * @param lines 字节数组列表
	 * @return 连接后的字符串
	 */
	inline std::string Bytes2String(const std::vector<std::vector<uint8_t>>& lines)
	{
		auto strings = Bytes2Strings(lines);
		std::string result;

		// 预先计算总长度
		size_t total_length = 0;
		for (const auto& str : strings)
		{
			total_length += str.length();
		}
		result.reserve(total_length);

		// 连接所有字符串
		for (const auto& str : strings)
		{
			result += str;
		}

		return result;
	}

	/**
	 * @brief 将字节数组转换为单个字符串（使用char*指针和长度）
	 * @param lines 字节数组列表
	 * @return 连接后的字符串
	 */
	inline std::string Bytes2String(const std::vector<std::pair<const char*, size_t>>& lines)
	{
		auto strings = Bytes2Strings(lines);
		std::string result;

		// 预先计算总长度
		size_t total_length = 0;
		for (const auto& str : strings)
		{
			total_length += str.length();
		}
		result.reserve(total_length);

		// 连接所有字符串
		for (const auto& str : strings)
		{
			result += str;
		}

		return result;
	}

	/**
	 * @brief 字符串操作类型枚举
	 */
	enum class StringOpType
	{
		Add,    // 添加操作
		Delete  // 删除操作
	};

	/**
	 * @brief 字符串操作结构
	 * 包含: (操作类型, 开始位置, 结束位置, 内容)
	 */
	struct StringOperation
	{
		StringOpType type;     // 操作类型
		size_t start;          // 开始位置
		size_t end;            // 结束位置
		std::string content;   // 操作内容

		StringOperation(StringOpType t, size_t s, size_t e, std::string c)
			: type(t), start(s), end(e), content(std::move(c)) {
		}
	};

	/**
	 * @brief 计算两个字符串的编辑距离和操作序列
	 * 使用LCS算法来找到最长公共子序列，然后基于LCS生成操作序列
	 * @param s1 源字符串
	 * @param s2 目标字符串
	 * @return (编辑距离, 操作序列)
	 */
	inline std::pair<int, std::vector<StringOperation>> GetEditorDistanceAndOperations(
		const std::string& s1,
		const std::string& s2)
	{
		size_t m = s1.length();
		size_t n = s2.length();

		// 使用LCS算法构建动态规划表
		std::vector<std::vector<int>> lcs(m + 1, std::vector<int>(n + 1, 0));

		// 构建LCS表
		for (size_t i = 1; i <= m; ++i)
		{
			for (size_t j = 1; j <= n; ++j)
			{
				if (s1[i - 1] == s2[j - 1])
				{
					lcs[i][j] = lcs[i - 1][j - 1] + 1;
				}
				else
				{
					lcs[i][j] = std::max(lcs[i - 1][j], lcs[i][j - 1]);
				}
			}
		}

		// 基于LCS生成操作序列
		std::vector<StringOperation> operations;
		size_t i = m, j = n;

		while (i > 0 || j > 0)
		{
			if (i > 0 && j > 0 && s1[i - 1] == s2[j - 1])
			{
				// 字符匹配，不需要操作
				--i;
				--j;
			}
			else if (j > 0 && (i == 0 || lcs[i][j - 1] >= lcs[i - 1][j]))
			{
				// 需要插入s2[j-1]
				size_t insert_pos = i;
				operations.insert(operations.begin(),
					StringOperation(StringOpType::Add, insert_pos, insert_pos, std::string(1, s2[j - 1])));
				--j;
			}
			else
			{
				// 需要删除s1[i-1]
				operations.insert(operations.begin(),
					StringOperation(StringOpType::Delete, i - 1, i, std::string(1, s1[i - 1])));
				--i;
			}
		}

		// 合并连续的操作
		std::vector<StringOperation> merged_operations;
		for (const auto& op : operations)
		{
			if (!merged_operations.empty() && merged_operations.back().type == op.type)
			{
				auto& last_op = merged_operations.back();
				if (op.type == StringOpType::Add && last_op.end == op.start)
				{
					// 合并连续的添加操作
					last_op.end = op.end;
					last_op.content += op.content;
				}
				else if (op.type == StringOpType::Delete && last_op.end == op.start)
				{
					// 合并连续的删除操作
					last_op.end = op.end;
					last_op.content += op.content;
				}
				else
				{
					merged_operations.push_back(op);
				}
			}
			else
			{
				merged_operations.push_back(op);
			}
		}

		// 计算编辑距离
		int edit_distance = static_cast<int>(m + n - 2 * lcs[m][n]);
		return { edit_distance, merged_operations };
	}

	/**
	 * @brief 构建行级LCS动态规划表
	 * @param lines1 源字符串行数组
	 * @param lines2 目标字符串行数组
	 * @return LCS动态规划表
	 */
	inline std::vector<std::vector<int>> _build_line_lcs(
		const std::vector<std::string>& lines1,
		const std::vector<std::string>& lines2)
	{
		size_t m = lines1.size();
		size_t n = lines2.size();
		std::vector<std::vector<int>> lcs(m + 1, std::vector<int>(n + 1, 0));

		// 使用哈希加速行比较
		std::vector<size_t> hash1, hash2;
		hash1.reserve(m);
		hash2.reserve(n);

		std::hash<std::string> hasher;
		for (const auto& line : lines1)
			hash1.push_back(hasher(line));
		for (const auto& line : lines2)
			hash2.push_back(hasher(line));

		for (size_t i = 1; i <= m; ++i)
		{
			for (size_t j = 1; j <= n; ++j)
			{
				if (hash1[i - 1] == hash2[j - 1] && lines1[i - 1] == lines2[j - 1])
				{
					lcs[i][j] = lcs[i - 1][j - 1] + 1;
				}
				else
				{
					lcs[i][j] = std::max(lcs[i - 1][j], lcs[i][j - 1]);
				}
			}
		}

		return lcs;
	}

	/**
	 * @brief 行级操作结构
	 */
	struct LineOperation
	{
		StringOpType type;              // 操作类型
		size_t start_line;              // 起始行号
		size_t end_line;                // 结束行号
		std::vector<std::string> lines; // 行内容列表

		LineOperation(StringOpType t, size_t s, size_t e, std::vector<std::string> l)
			: type(t), start_line(s), end_line(e), lines(std::move(l)) {
		}
	};

	/**
	 * @brief 从LCS表提取行级操作序列
	 * @param lines1 源字符串行数组
	 * @param lines2 目标字符串行数组
	 * @param lcs LCS动态规划表
	 * @return 行级操作序列
	 */
	inline std::vector<LineOperation> _extract_line_operations(
		const std::vector<std::string>& lines1,
		const std::vector<std::string>& lines2,
		const std::vector<std::vector<int>>& lcs)
	{
		std::vector<LineOperation> operations;
		size_t m = lines1.size();
		size_t n = lines2.size();
		size_t i = m, j = n;

		while (i > 0 || j > 0)
		{
			if (i > 0 && j > 0 && lines1[i - 1] == lines2[j - 1])
			{
				--i;
				--j;
			}
			else if (j > 0 && (i == 0 || lcs[i][j - 1] >= lcs[i - 1][j]))
			{
				std::vector<std::string> temp_lines = { lines2[j - 1] };
				operations.insert(operations.begin(),
					LineOperation(StringOpType::Add, i, i, std::move(temp_lines)));
				--j;
			}
			else
			{
				std::vector<std::string> temp_lines = { lines1[i - 1] };
				operations.insert(operations.begin(),
					LineOperation(StringOpType::Delete, i - 1, i, std::move(temp_lines)));
				--i;
			}
		}

		// 合并连续的同类行操作
		std::vector<LineOperation> merged;
		for (auto& op : operations)
		{
			if (!merged.empty() && merged.back().type == op.type && merged.back().end_line == op.start_line)
			{
				merged.back().end_line = op.end_line;
				merged.back().lines.insert(merged.back().lines.end(),
					op.lines.begin(), op.lines.end());
			}
			else
			{
				merged.push_back(std::move(op));
			}
		}

		return merged;
	}

	/**
	 * @brief 对小范围区域进行字符级LCS比较
	 * @param s1 源字符串
	 * @param s2 目标字符串
	 * @return 操作序列（相对于输入字符串的位置）
	 */
	inline std::vector<StringOperation> _char_diff_in_region(
		const std::string& s1,
		const std::string& s2)
	{
		size_t m = s1.length();
		size_t n = s2.length();

		// 快速路径
		if (m == 0 && n == 0)
			return {};
		if (m == 0)
			return { StringOperation(StringOpType::Add, 0, 0, s2) };
		if (n == 0)
			return { StringOperation(StringOpType::Delete, 0, m, s1) };
		if (s1 == s2)
			return {};

		// 字符级LCS
		std::vector<std::vector<int>> lcs(m + 1, std::vector<int>(n + 1, 0));

		for (size_t i = 1; i <= m; ++i)
		{
			for (size_t j = 1; j <= n; ++j)
			{
				if (s1[i - 1] == s2[j - 1])
				{
					lcs[i][j] = lcs[i - 1][j - 1] + 1;
				}
				else
				{
					lcs[i][j] = std::max(lcs[i - 1][j], lcs[i][j - 1]);
				}
			}
		}

		// 回溯生成操作
		std::vector<StringOperation> operations;
		size_t i = m, j = n;

		while (i > 0 || j > 0)
		{
			if (i > 0 && j > 0 && s1[i - 1] == s2[j - 1])
			{
				--i;
				--j;
			}
			else if (j > 0 && (i == 0 || lcs[i][j - 1] >= lcs[i - 1][j]))
			{
				operations.insert(operations.begin(),
					StringOperation(StringOpType::Add, i, i, std::string(1, s2[j - 1])));
				--j;
			}
			else
			{
				operations.insert(operations.begin(),
					StringOperation(StringOpType::Delete, i - 1, i, std::string(1, s1[i - 1])));
				--i;
			}
		}

		// 合并连续操作
		std::vector<StringOperation> merged;
		for (const auto& op : operations)
		{
			if (!merged.empty() && merged.back().type == op.type)
			{
				auto& last_op = merged.back();
				if (op.type == StringOpType::Add && last_op.end == op.start)
				{
					last_op.end = op.end;
					last_op.content += op.content;
				}
				else if (op.type == StringOpType::Delete && last_op.end == op.start)
				{
					last_op.end = op.end;
					last_op.content += op.content;
				}
				else
				{
					merged.push_back(op);
				}
			}
			else
			{
				merged.push_back(op);
			}
		}

		return merged;
	}

	/**
	 * @brief 分割字符串为行数组
	 * @param s 输入字符串
	 * @return 行数组
	 */
	inline std::vector<std::string> _split_lines(const std::string& s)
	{
		std::vector<std::string> lines;
		size_t start = 0;
		size_t pos = 0;

		while ((pos = s.find('\n', start)) != std::string::npos)
		{
			lines.push_back(s.substr(start, pos - start));
			start = pos + 1;
		}

		// 添加最后一行（即使为空）
		lines.push_back(s.substr(start));

		return lines;
	}

	/**
	 * @brief 连接字符串数组为单个字符串
	 * @param lines 字符串数组
	 * @param separator 分隔符（默认换行符）
	 * @return 连接后的字符串
	 */
	inline std::string _join_lines(const std::vector<std::string>& lines, const std::string& separator = "\n")
	{
		if (lines.empty())
			return "";

		std::string result = lines[0];
		for (size_t i = 1; i < lines.size(); ++i)
		{
			result += separator + lines[i];
		}
		return result;
	}

	/**
	 * @brief 计算两个字符串的差异操作序列（混合行级+字符级算法）
	 * 操作格式: (操作类型, 开始位置, 结束位置, 内容)
	 * 位置基于源字符串s1的字符偏移
	 * @param s1 源字符串
	 * @param s2 目标字符串
	 * @return 差异操作序列
	 */
	inline std::vector<StringOperation> GetDiffOperations(
		const std::string& s1,
		const std::string& s2)
	{
		// 快速路径
		if (s1 == s2)
			return {};
		if (s1.empty())
			return { StringOperation(StringOpType::Add, 0, 0, s2) };
		if (s2.empty())
			return { StringOperation(StringOpType::Delete, 0, s1.length(), s1) };

		// 阶段1: 分行并建立位置映射
		std::vector<std::string> lines1 = _split_lines(s1);
		std::vector<std::string> lines2 = _split_lines(s2);

		// 构建行号到字符位置的映射
		std::vector<size_t> line_offsets_s1 = { 0 };
		for (size_t i = 0; i < lines1.size() - 1; ++i)
		{
			line_offsets_s1.push_back(line_offsets_s1.back() + lines1[i].length() + 1); // +1 for '\n'
		}

		std::vector<size_t> line_offsets_s2 = { 0 };
		for (size_t i = 0; i < lines2.size() - 1; ++i)
		{
			line_offsets_s2.push_back(line_offsets_s2.back() + lines2[i].length() + 1);
		}

		// 阶段2: 行级LCS分析
		auto lcs = _build_line_lcs(lines1, lines2);
		auto line_operations = _extract_line_operations(lines1, lines2, lcs);

		// 阶段3: 转换为字符级操作
		std::vector<StringOperation> final_operations;

		for (const auto& line_op : line_operations)
		{
			if (line_op.type == StringOpType::Add)
			{
				// 添加操作: 在s1的start_line位置插入
				size_t char_pos = (line_op.start_line < line_offsets_s1.size())
					? line_offsets_s1[line_op.start_line]
					: s1.length();
				std::string content = _join_lines(line_op.lines);

				final_operations.emplace_back(StringOpType::Add, char_pos, char_pos, content);
			}
			else if (line_op.type == StringOpType::Delete)
			{
				// 删除操作: 删除s1的[start_line, end_line)行
				size_t char_start = line_offsets_s1[line_op.start_line];
				size_t char_end = (line_op.end_line < lines1.size())
					? line_offsets_s1[line_op.end_line]
					: s1.length();

				std::string content = _join_lines(line_op.lines);
				final_operations.emplace_back(StringOpType::Delete, char_start, char_end, content);
			}
		}

		// 阶段4: 对于连续的删除+添加，尝试字符级精细比较
		std::vector<StringOperation> optimized_operations;
		size_t i = 0;

		while (i < final_operations.size())
		{
			if (i + 1 < final_operations.size() &&
				final_operations[i].type == StringOpType::Delete &&
				final_operations[i + 1].type == StringOpType::Add &&
				final_operations[i].end == final_operations[i + 1].start)
			{
				// 这是一个修改操作，进行字符级细化
				const auto& del_op = final_operations[i];
				const auto& add_op = final_operations[i + 1];

				const std::string& old_text = del_op.content;
				const std::string& new_text = add_op.content;
				size_t base_pos = del_op.start;

				// 字符级比较
				auto char_ops = _char_diff_in_region(old_text, new_text);

				// 调整位置到全局坐标
				for (const auto& op : char_ops)
				{
					optimized_operations.emplace_back(
						op.type,
						base_pos + op.start,
						base_pos + op.end,
						op.content
					);
				}

				i += 2;
			}
			else
			{
				optimized_operations.push_back(final_operations[i]);
				++i;
			}
		}

		return optimized_operations;
	}
}

#endif // !Convention_Runtime_String_Hpp