#include "stdafx.h"
#include "TableDataImporter.h"
#include "TsvParser.h"
#include "SigmaView.h"
#include <map>

//-----------------------------------------------------------------------------
// 列名与默认值（仅本文件使用，不暴露）
//-----------------------------------------------------------------------------
namespace
{
	static const CString COL_X(_T("X"));
	static const CString COL_Y(_T("Y"));
	static const CString COL_Z(_T("Z"));
	static const CString COL_L(_T("L"));
	static const CString COL_NAME(_T("名称"));
	static const CString COL_LAYER(_T("图层"));
	static const CString DEFAULT_LAYER(_T("0"));

	/** 整表导入前校验并取绘图对象，失败返回 nullptr */
	CXy* GetXyForTableImport(CSigmaView* pView, const TsvParser::TableData& tableData, const TCHAR* tracePrefix)
	{
		if (pView == nullptr || pView->m_pDoc == nullptr)
		{
			TRACE("%s - 视图或文档为空\n", tracePrefix);
			return nullptr;
		}
		CXy* pXy = pView->m_pDoc->GetDraw();
		if (pXy == nullptr)
		{
			TRACE("%s - 无法获取绘图对象\n", tracePrefix);
			return nullptr;
		}
		if (tableData.IsEmpty())
		{
			TRACE("%s - 表格数据为空\n", tracePrefix);
			return nullptr;
		}
		if (tableData.GetColumnIndex(COL_X) < 0 || tableData.GetColumnIndex(COL_Y) < 0)
		{
			TRACE("%s - 缺少必需的 X 或 Y 列\n", tracePrefix);
			return nullptr;
		}
		return pXy;
	}

	/** 将单个点加入文档（layerName 必填；name 为空则不设置名称） */
	void AddOnePointToDocument(CXy* pXy, double x, double y, double z, const CString& layerName, const CString& name)
	{
		CPointNameEx* pPoint = new CPointNameEx();
		pPoint->x0 = x;
		pPoint->y0 = y;
		pPoint->z0 = z;
		if (!name.IsEmpty())
			pPoint->SetName(name);

		CLayer* pLayer = pXy->FindAddLayer(layerName);
		POSITION pos = pXy->AddElement(pPoint, DOUBLEFOX_POINT);
		COne* pOne = pXy->GetAt(pos);
		pOne->SetLayer(pLayer);
	}
}

namespace
{
	struct CurveEntry
	{
		double x, y, z, length;
		CString name;
		CString layer;
	};

	/** 整表曲线导入：解析 → 按图层/名称分组 → 写入文档，实现细节集中在此类 */
	class CurveTableImporter
	{
	public:
		/** @return 导入曲线条数，无有效数据返回 -1 */
		int Import(CXy* pXy, const TsvParser::TableData& tableData)
		{
			std::vector<CurveEntry> entries = ParseTableToCurveEntries(tableData);
			if (entries.empty())
				return -1;
			std::map<CString, std::vector<std::vector<CurveEntry>>> layerCurves = GroupEntriesByLayerAndCurveName(entries);
			return AddCurvesToDocument(pXy, layerCurves);
		}

	private:
		static std::vector<CurveEntry> ParseTableToCurveEntries(const TsvParser::TableData& tableData)
		{
			std::vector<CurveEntry> entries;
			for (const auto& row : tableData.rows)
			{
				CString strX = tableData.GetValue(row, COL_X);
				CString strY = tableData.GetValue(row, COL_Y);
				if (strX.IsEmpty() || strY.IsEmpty())
					continue;

				CurveEntry entry;
				entry.x = _tstof(strX);
				entry.y = _tstof(strY);
				entry.z = tableData.GetDoubleValue(row, COL_Z, 0.0);
				entry.length = tableData.GetDoubleValue(row, COL_L, 0.0);
				entry.name = tableData.GetValue(row, COL_NAME);
				entry.layer = tableData.GetValue(row, COL_LAYER);
				if (entry.layer.IsEmpty())
					entry.layer = DEFAULT_LAYER;
				entries.push_back(entry);
			}
			return entries;
		}

		/** 按图层分组，同一图层内再按“名称”连续段切分为多条曲线 */
		static std::map<CString, std::vector<std::vector<CurveEntry>>> GroupEntriesByLayerAndCurveName(const std::vector<CurveEntry>& entries)
		{
			std::map<CString, std::vector<CurveEntry>> layerEntries;
			for (const auto& entry : entries)
				layerEntries[entry.layer].push_back(entry);

			std::map<CString, std::vector<std::vector<CurveEntry>>> layerCurves;
			for (const auto& layerPair : layerEntries)
			{
				const CString& layerName = layerPair.first;
				const auto& layerPoints = layerPair.second;

				std::vector<std::vector<CurveEntry>> curves;
				std::vector<CurveEntry> currentCurve;
				CString currentName;

				for (const auto& entry : layerPoints)
				{
					if (currentCurve.empty() || currentName != entry.name)
					{
						if (!currentCurve.empty())
						{
							curves.push_back(currentCurve);
							currentCurve.clear();
						}
						currentName = entry.name;
					}
					currentCurve.push_back(entry);
				}
				if (!currentCurve.empty())
					curves.push_back(currentCurve);

				layerCurves[layerName] = curves;
			}
			return layerCurves;
		}

		static int AddCurvesToDocument(CXy* pXy, const std::map<CString, std::vector<std::vector<CurveEntry>>>& layerCurves)
		{
			int importCount = 0;
			for (const auto& layerPair : layerCurves)
			{
				const CString& layerName = layerPair.first;
				const auto& curves = layerPair.second;
				CLayer* pLayer = pXy->FindAddLayer(layerName);

				for (const auto& curvePoints : curves)
				{
					if (curvePoints.empty())
						continue;

					CCurveEx* pCurve = new CCurveEx();
					pCurve->SetName(curvePoints[0].name);
					pCurve->Create((int)curvePoints.size());
					pCurve->width = 1;

					for (size_t i = 0; i < curvePoints.size(); i++)
					{
						pCurve->x[i] = curvePoints[i].x;
						pCurve->y[i] = curvePoints[i].y;
						pCurve->z[i] = curvePoints[i].z;
						pCurve->l[i] = curvePoints[i].length;
					}
					pCurve->GetLocation();

					POSITION pos = pXy->AddElement(pCurve, DOUBLEFOX_CURVE);
					COne* pOne = pXy->GetAt(pos);
					pOne->SetLayer(pLayer);
					importCount++;
				}
			}
			return importCount;
		}
	};
}

int ImportTableAsCurves(CSigmaView* pView, const TsvParser::TableData& tableData)
{
	CXy* pXy = GetXyForTableImport(pView, tableData, _T("ImportTableAsCurves"));
	if (pXy == nullptr)
		return -1;

	int importCount = CurveTableImporter().Import(pXy, tableData);
	if (importCount < 0)
	{
		TRACE("ImportTableAsCurves - 没有有效的数据行\n");
		return -1;
	}
	TRACE("ImportTableAsCurves - 成功导入 %d 条曲线\n", importCount);
	return importCount;
}

//=============================================================================
// 流式按行导入
//=============================================================================

void BuildColumnIndexMapFromHeaders(const std::vector<CString>& headers, std::map<CString, int>& outMap)
{
	outMap.clear();
	for (size_t i = 0; i < headers.size(); i++)
	{
		CString key = headers[i];
		key.MakeUpper();
		key.Trim();
		outMap[key] = (int)i;
	}
}

CString GetRowValue(const std::vector<CString>& row, const std::map<CString, int>& columnIndexMap, const CString& columnName)
{
	CString key = columnName;
	key.MakeUpper();
	key.Trim();
	auto it = columnIndexMap.find(key);
	if (it != columnIndexMap.end() && it->second >= 0 && it->second < (int)row.size())
	{
		CString v = row[it->second];
		v.Trim();
		return v;
	}
	return _T("");
}

double GetRowDoubleValue(const std::vector<CString>& row, const std::map<CString, int>& columnIndexMap, const CString& columnName, double defaultValue)
{
	CString s = GetRowValue(row, columnIndexMap, columnName);
	if (s.IsEmpty())
		return defaultValue;
	return _tstof(s);
}

namespace
{
	/** 流式导入单行点，withName 为 true 时从行中取“名称”并设置。跳过无效行返回 true（不算失败）。 */
	bool ImportPointRowStreamImpl(CSigmaView* pView, const std::map<CString, int>& columnIndexMap, const std::vector<CString>& row, bool withName)
	{
		if (pView == nullptr || pView->m_pDoc == nullptr)
		{
			return false;
		}

		CXy* pXy = pView->m_pDoc->GetDraw();
		if (pXy == nullptr)
		{
			return false;
		}

		CString strX = GetRowValue(row, columnIndexMap, COL_X);
		CString strY = GetRowValue(row, columnIndexMap, COL_Y);
		if (strX.IsEmpty() || strY.IsEmpty())
		{
			return true; // 跳过无效行，不算失败
		}

		double x = _tstof(strX);
		double y = _tstof(strY);
		double z = GetRowDoubleValue(row, columnIndexMap, COL_Z, 0.0);
		CString layerName = GetRowValue(row, columnIndexMap, COL_LAYER);
		if (layerName.IsEmpty())
		{
			layerName = DEFAULT_LAYER;
		}

		CString name;
		if (withName)
		{
			name = GetRowValue(row, columnIndexMap, COL_NAME);
		}

		AddOnePointToDocument(pXy, x, y, z, layerName, name);
		return true;
	}
}

bool ImportPointRow(CSigmaView* pView, const std::map<CString, int>& columnIndexMap, const std::vector<CString>& row)
{
	return ImportPointRowStreamImpl(pView, columnIndexMap, row, true);
}

bool ImportXyzPointRow(CSigmaView* pView, const std::map<CString, int>& columnIndexMap, const std::vector<CString>& row)
{
	return ImportPointRowStreamImpl(pView, columnIndexMap, row, false);
}

// ---------------------------------------------------------------------------
// CurveStreamImporter
// ---------------------------------------------------------------------------

CurveStreamImporter::CurveStreamImporter(CSigmaView* pView)
	: m_pView(pView)
{
	if (pView && pView->m_pDoc)
		m_pXy = pView->m_pDoc->GetDraw();
}

void CurveStreamImporter::OnRow(const std::map<CString, int>& columnIndexMap, const std::vector<CString>& row)
{
	if (m_pXy == nullptr)
		return;
	CString strX = GetRowValue(row, columnIndexMap, COL_X);
	CString strY = GetRowValue(row, columnIndexMap, COL_Y);
	if (strX.IsEmpty() || strY.IsEmpty())
		return;

	double x = _tstof(strX);
	double y = _tstof(strY);
	double z = GetRowDoubleValue(row, columnIndexMap, COL_Z, 0.0);
	double l = GetRowDoubleValue(row, columnIndexMap, COL_L, 0.0);
	CString name = GetRowValue(row, columnIndexMap, COL_NAME);
	CString layer = GetRowValue(row, columnIndexMap, COL_LAYER);
	if (layer.IsEmpty())
		layer = DEFAULT_LAYER;

	if (!m_curX.empty() && (m_currentLayer != layer || m_currentName != name))
		FlushCurrentCurve();

	m_currentLayer = layer;
	m_currentName = name;
	m_curName = name;
	m_curX.push_back(x);
	m_curY.push_back(y);
	m_curZ.push_back(z);
	m_curL.push_back(l);
}

void CurveStreamImporter::FlushCurrentCurve()
{
	if (m_pXy == nullptr || m_curX.empty())
		return;

	CLayer* pLayer = m_pXy->FindAddLayer(m_currentLayer);
	CCurveEx* pCurve = new CCurveEx();
	pCurve->SetName(m_curName);
	pCurve->Create((int)m_curX.size());
	pCurve->width = 1;

	for (size_t i = 0; i < m_curX.size(); i++)
	{
		pCurve->x[i] = m_curX[i];
		pCurve->y[i] = m_curY[i];
		pCurve->z[i] = m_curZ[i];
		pCurve->l[i] = m_curL[i];
	}
	pCurve->GetLocation();

	POSITION pos = m_pXy->AddElement(pCurve, DOUBLEFOX_CURVE);
	COne* pOne = m_pXy->GetAt(pos);
	pOne->SetLayer(pLayer);

	m_curX.clear();
	m_curY.clear();
	m_curZ.clear();
	m_curL.clear();
	m_importCount++;
}

void CurveStreamImporter::End()
{
	FlushCurrentCurve();
}