Just-DataInspector/Utilities/Src/CsvTable.cpp

#include "CsvTable.hpp"

#include "Utf8Util.hpp"

#include <windows.h>

#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>

namespace jdi
{

	namespace
	{
		/** @brief 单个字段在原始缓冲中的位置区间。 */
		struct FieldSpan
		{
			const char* begin = nullptr;	/**< 字段起始指针。 */
			const char* end = nullptr;		/**< 字段结束指针（不包含）。 */
		};

		const double kMissingValue = std::numeric_limits<double>::quiet_NaN();	/**< 缺失值占位。 */
		const std::size_t kReadChunkBytes = 4u * 1024u * 1024u;	/**< 流式读取块大小。 */

		/**
		 * @brief 按比例预留的初始行容量。
		 *
		 * 先按文件体积估算一个行数，既能避免边解析边扩容（百万行时复制代价可观），
		 * 又不会因为估得过大而浪费内存（超估时 vector 只是容量偏大，数据本身不变）。
		 */
		std::size_t EstimateRowCapacity(unsigned long long fileBytes)
		{
			// 典型 CSV 每行约 40-200 字节；取下界 64 字节估算行数，宁可小估也不要多占。
			const unsigned long long estimate = fileBytes / 64ull;
			if (estimate > 4096ull * 1024ull)
			{
				return static_cast<std::size_t>(4096ull * 1024ull);
			}
			return static_cast<std::size_t>(estimate);
		}

		/**
		 * @brief 打开文件并查询其体积。
		 * @param [IN] filePath 文件路径。
		 * @param [OUT] file 文件句柄输出（需调用方关闭）。
		 * @param [OUT] fileSize 文件字节数输出。
		 * @param [OUT] error 失败原因描述。
		 * @return 打开成功返回 true。
		 */
		bool OpenFile(const std::wstring& filePath, FILE*& file, unsigned long long& fileSize,
		              std::wstring& error)
		{
			file = _wfopen(filePath.c_str(), L"rb");
			if (file == nullptr)
			{
				error = L"无法打开文件，请确认路径与访问权限。";
				return false;
			}

			// 使用 64 位定位接口，避免 long 在部分平台下只有 32 位而无法处理大文件。
			if (_fseeki64(file, 0, SEEK_END) != 0)
			{
				std::fclose(file);
				file = nullptr;
				error = L"无法定位文件末尾。";
				return false;
			}

			const long long size = _ftelli64(file);
			if (size < 0)
			{
				std::fclose(file);
				file = nullptr;
				error = L"无法获取文件长度。";
				return false;
			}
			if (size == 0)
			{
				std::fclose(file);
				file = nullptr;
				error = L"文件内容为空。";
				return false;
			}
			if (_fseeki64(file, 0, SEEK_SET) != 0)
			{
				std::fclose(file);
				file = nullptr;
				error = L"无法回到文件开头。";
				return false;
			}

			fileSize = static_cast<unsigned long long>(size);
			return true;
		}

		/**
		 * @brief 统计一行中某个候选分隔符出现的次数。
		 * @param [IN] begin 行起始指针。
		 * @param [IN] end 行结束指针（不包含）。
		 * @param [IN] candidate 候选分隔符。
		 * @return 出现次数。
		 */
		int CountDelimiter(const char* begin, const char* end, char candidate)
		{
			int count = 0;
			bool inQuote = false;
			for (const char* p = begin; p < end; ++p)
			{
				if (*p == '"')
				{
					inQuote = !inQuote;
				}
				else if (*p == candidate && !inQuote)
				{
					++count;
				}
			}
			return count;
		}

		/**
		 * @brief 依据表头行推断分隔符。
		 * @param [IN] begin 表头行起始指针。
		 * @param [IN] end 表头行结束指针（不包含）。
		 * @return 推断出的分隔符。
		 */
		char DetectDelimiter(const char* begin, const char* end)
		{
			static const char kCandidates[] = {',', ';', '\t', '|'};

			char best = ',';
			int bestCount = 0;
			for (const char candidate : kCandidates)
			{
				const int count = CountDelimiter(begin, end, candidate);
				if (count > bestCount)
				{
					bestCount = count;
					best = candidate;
				}
			}
			return best;
		}

		/**
		 * @brief 将一行文本按分隔符拆分为多个字段（支持双引号包裹与转义）。
		 * @param [IN] begin 行起始指针。
		 * @param [IN] end 行结束指针（不包含）。
		 * @param [IN] delimiter 分隔符。
		 * @param [OUT] fields 字段区间输出。
		 */
		void SplitFields(const char* begin, const char* end, char delimiter, std::vector<FieldSpan>& fields)
		{
			fields.clear();

			const char* fieldBegin = begin;
			bool inQuote = false;
			for (const char* p = begin; p < end; ++p)
			{
				const char c = *p;
				if (c == '"')
				{
					if (inQuote && (p + 1) < end && p[1] == '"')
					{
						++p;
						continue;
					}
					inQuote = !inQuote;
				}
				else if (c == delimiter && !inQuote)
				{
					FieldSpan span;
					span.begin = fieldBegin;
					span.end = p;
					fields.push_back(span);
					fieldBegin = p + 1;
				}
			}

			FieldSpan span;
			span.begin = fieldBegin;
			span.end = end;
			fields.push_back(span);
		}

		/**
		 * @brief 将字段区间转换为字符串并去除引号与空白。
		 * @param [IN] span 字段区间。
		 * @return 规范化后的字段文本。
		 */
		std::wstring FieldToText(const FieldSpan& span)
		{
			std::wstring text = Utf8ToWide(span.begin, static_cast<int>(span.end - span.begin));
			return StripQuotes(text);
		}

		/**
		 * @brief 判断字段是否应当被整行跳过（空行或注释行）。
		 * @param [IN] span 首字段区间。
		 * @param [IN] lineIsEmpty 该行是否为纯空白行。
		 * @return 需要跳过返回 true。
		 */
		bool ShouldSkipLine(const FieldSpan& span, bool lineIsEmpty)
		{
			if (lineIsEmpty)
			{
				return true;
			}
			if (span.begin == nullptr || span.begin >= span.end)
			{
				return false;
			}
			const char first = span.begin[0];
			return first == '#' || first == '%';
		}

		/**
		 * @brief 解析状态：跨读取块保存进度。
		 */
		struct ParseState
		{
			std::string pending;						/**< 尚未处理完的尾部字节（不完整行）。 */
			std::vector<FieldSpan> fields;				/**< 字段区间复用缓冲。 */
			std::vector<double> rowValues;			/**< 行数值复用缓冲（列优先存储时的中转）。 */
			bool headerReady = false;					/**< 是否已解析表头。 */
			unsigned long long bytesConsumed = 0;	/**< 已处理字节数（用于进度）。 */
		};

		/**
		 * @brief 处理一块完整行文本（不含换行符）。
		 * @param [IN,OUT] table 解析结果。
		 * @param [IN,OUT] state 解析状态。
		 * @param [IN] begin 行起始指针。
		 * @param [IN] end 行结束指针（不包含）。
		 * @return 解析可以继续返回 true；表头非法需要中止时返回 false。
		 */
		bool HandleLine(CsvTable& table, ParseState& state, const char* begin, const char* end)
		{
			const char* lineEnd = end;
			while (lineEnd > begin && lineEnd[-1] == '\r')
			{
				--lineEnd;
			}

			// 跳过纯空白行，但不产生数据行。
			const char* scan = begin;
			while (scan < lineEnd && (*scan == ' ' || *scan == '\t'))
			{
				++scan;
			}
			const bool lineIsEmpty = (scan >= lineEnd);

			if (!state.headerReady)
			{
				if (lineIsEmpty)
				{
					return true;
				}

				table.delimiter = DetectDelimiter(begin, lineEnd);
				SplitFields(begin, lineEnd, static_cast<char>(table.delimiter), state.fields);

				table.headers.clear();
				table.headers.reserve(state.fields.size());
				for (const FieldSpan& span : state.fields)
				{
					std::wstring text = FieldToText(span);
					if (text.empty())
					{
						text = L"Column" + std::to_wstring(table.headers.size() + 1);
					}
					table.headers.push_back(text);
				}

				if (table.headers.empty())
				{
					return false;
				}

				// 列优先存储：一次性为每列预留容量，避免逐行扩容（百万行时复制代价可观）。
				const std::size_t capacity = EstimateRowCapacity(table.fileBytes);
				table.columns.assign(table.headers.size(), std::vector<double>());
				for (std::vector<double>& column : table.columns)
				{
					if (capacity > 0)
					{
						column.reserve(capacity);
					}
				}
				state.rowValues.assign(table.headers.size(), kMissingValue);

				state.headerReady = true;
				return true;
			}

			SplitFields(begin, lineEnd, static_cast<char>(table.delimiter), state.fields);

			// 空行与注释行（以 # 或 % 开头）不参与数据统计。
			if (ShouldSkipLine(state.fields.empty() ? FieldSpan() : state.fields.front(), lineIsEmpty))
			{
				return true;
			}

			if (state.fields.size() != table.headers.size())
			{
				++table.skippedRowCount;
			}

			bool rowHasValue = false;
			for (std::size_t column = 0; column < state.rowValues.size(); ++column)
			{
				double value = kMissingValue;
				if (column < state.fields.size() &&
				    TryParseDouble(state.fields[column].begin, state.fields[column].end, value))
				{
					rowHasValue = true;
				}
				state.rowValues[column] = value;
			}

			// 整行都没有有效数值时该行直接丢弃（与旧行为一致）：
			// 列优先存储要求每列等长，因此必须整行一起跳过，不能只补某一列。
			if (!rowHasValue)
			{
				return true;
			}

			for (std::size_t column = 0; column < state.rowValues.size(); ++column)
			{
				table.columns[column].push_back(state.rowValues[column]);
			}
			++table.rowCount;
			++table.sourceRowCount;
			return true;
		}
	}

	bool LoadCsvTable(const std::wstring& filePath, CsvTable& table, std::wstring& error,
	                  const CsvProgress& progress)
	{
		table = CsvTable();
		error.clear();

		FILE* file = nullptr;
		unsigned long long fileSize = 0;
		if (!OpenFile(filePath, file, fileSize, error))
		{
			return false;
		}
		table.fileBytes = fileSize;

		ParseState state;
		std::string staging;
		staging.resize(kReadChunkBytes);

		bool cancelled = false;
		bool fatal = false;

		while (!cancelled && !fatal)
		{
			const size_t readCount = std::fread(&staging[0], 1, staging.size(), file);
			if (readCount == 0)
			{
				break;
			}
			state.bytesConsumed += readCount;

			state.pending.append(staging.data(), readCount);

			// 首个块处理前剥离 UTF-8 BOM，避免首列名被污染（BOM 必然落在第一块内）。
			if (!state.headerReady && state.pending.size() >= 3 &&
			    static_cast<unsigned char>(state.pending[0]) == 0xEF &&
			    static_cast<unsigned char>(state.pending[1]) == 0xBB &&
			    static_cast<unsigned char>(state.pending[2]) == 0xBF)
			{
				state.pending.erase(0, 3);
			}

			// 处理 pending 中所有以换行结束的完整行。
			std::size_t lineStart = 0;
			while (true)
			{
				const std::size_t newline = state.pending.find('\n', lineStart);
				if (newline == std::string::npos)
				{
					break;
				}
				if (!HandleLine(table, state, state.pending.data() + lineStart,
				                state.pending.data() + newline))
				{
					fatal = true;
					break;
				}
				lineStart = newline + 1;
			}
			if (fatal)
			{
				break;
			}
			state.pending.erase(0, lineStart);

			if (progress)
			{
				const double ratio = (fileSize > 0)
				                         ? static_cast<double>(state.bytesConsumed) /
				                               static_cast<double>(fileSize)
				                         : 0.0;
				if (!progress(ratio > 1.0 ? 1.0 : ratio))
				{
					cancelled = true;
				}
			}
		}

		// 处理文件末尾没有换行符的最后一行。
		if (!cancelled && !fatal && !state.pending.empty())
		{
			if (!HandleLine(table, state, state.pending.data(), state.pending.data() + state.pending.size()))
			{
				fatal = true;
			}
		}
		std::fclose(file);

		if (cancelled)
		{
			error = L"已取消加载。";
			return false;
		}
		if (table.headers.empty())
		{
			error = fatal ? L"表头为空，无法解析列名。" : L"未从文件中解析出有效数据行。";
			return false;
		}
		if (!table.HasData())
		{
			error = L"未从文件中解析出有效数据行。";
			return false;
		}
		return true;
	}

} // namespace jdi