#include "StdAfx.h"
#include "SplineCurveModel.h"
#include "SplineAlgorithm.h"

#include <algorithm>
#include <cmath>

namespace
{
	bool IsFinitePoint(const dfPoint& p)
	{
		return std::isfinite(p.x0) && std::isfinite(p.y0);
	}

	bool IsDegenerateSegment(const dfPoint& p0, const dfPoint& p1, const dfPoint& p2, const dfPoint& p3)
	{
		const double eps = 1e-12;
		auto dist2 = [](const dfPoint& a, const dfPoint& b)
		{
			double dx = a.x0 - b.x0;
			double dy = a.y0 - b.y0;
			return dx * dx + dy * dy;
		};
		return dist2(p1, p2) <= eps;
	}

	/** Catmull-Rom 插值：t∈[0,1] 返回 p1→p2 段上参数 t 处的点 */
	dfPoint CatmullRom(const dfPoint& p0, const dfPoint& p1, const dfPoint& p2, const dfPoint& p3, double t)
	{
		const double t2 = t * t;
		const double t3 = t2 * t;
		dfPoint out;
		out.x0 = 0.5 * (
			(2 * p1.x0)
			+ (-p0.x0 + p2.x0) * t
			+ (2 * p0.x0 - 5 * p1.x0 + 4 * p2.x0 - p3.x0) * t2
			+ (-p0.x0 + 3 * p1.x0 - 3 * p2.x0 + p3.x0) * t3);
		out.y0 = 0.5 * (
			(2 * p1.y0)
			+ (-p0.y0 + p2.y0) * t
			+ (2 * p0.y0 - 5 * p1.y0 + 4 * p2.y0 - p3.y0) * t2
			+ (-p0.y0 + 3 * p1.y0 - 3 * p2.y0 + p3.y0) * t3);
		out.z0 = p1.z0;
		out.l = p1.l;
		out.no = p1.no;
		return out;
	}
}

SplineCurveModel::SplineCurveModel(int samplesPerSegment)
	: m_samplesPerSegment(samplesPerSegment > 0 ? samplesPerSegment : 30)
{
}

const std::vector<dfPoint>& SplineCurveModel::GetControlPoints() const
{
	return m_controlPoints;
}

std::vector<dfPoint>& SplineCurveModel::GetControlPoints()
{
	return m_controlPoints;
}

const std::vector<SegmentMeta>& SplineCurveModel::GetSegmentMeta() const
{
	return m_segmentMeta;
}

const std::vector<RenderPointWithSeg>& SplineCurveModel::GetRenderPoints() const
{
	return m_renderPoints;
}

int SplineCurveModel::GetControlPointCount() const
{
	return static_cast<int>(m_controlPoints.size());
}

int SplineCurveModel::GetSegmentCount() const
{
	return static_cast<int>(m_segmentMeta.size());
}

bool SplineCurveModel::IsValid() const
{
	return GetControlPointCount() >= 2;
}

int SplineCurveModel::GetSamplesPerSegment() const
{
	return m_samplesPerSegment;
}

void SplineCurveModel::SetSamplesPerSegment(int n)
{
	m_samplesPerSegment = (n > 0) ? n : 1;
}

std::vector<dfPoint> SplineCurveModel::SampleSegment(
	const dfPoint& p0, const dfPoint& p1, const dfPoint& p2, const dfPoint& p3,
	int samplesPerSegment)
{
	if (IsDegenerateSegment(p0, p1, p2, p3))
		return { p1, p2 };

	std::vector<dfPoint> result;
	result.reserve(samplesPerSegment + 1);
	for (int j = 0; j <= samplesPerSegment; ++j)
	{
		const double t = static_cast<double>(j) / samplesPerSegment;
		dfPoint dp = CatmullRom(p0, p1, p2, p3, t);
		if (!IsFinitePoint(dp))
			dp = (j <= samplesPerSegment / 2) ? p1 : p2;
		result.push_back(dp);
	}
	return result;
}

void SplineCurveModel::InitSegmentMeta()
{
	const int n = static_cast<int>(m_controlPoints.size());
	m_segmentMeta.clear();
	m_segmentMeta.reserve((std::max)(0, n - 1));
	for (int i = 0; i < n - 1; ++i)
		m_segmentMeta.push_back({ SegmentSource::Algorithm, {} });
}

std::pair<int, int> SplineCurveModel::GetAffectedSegmentRange(int controlPointIndex, int segmentCount)
{
	/* Catmull-Rom 局部支撑：控制点 i 影响段 i-2, i-1, i, i+1 */
	const int start = (std::max)(0, controlPointIndex - 2);
	const int end = (std::min)(segmentCount - 1, controlPointIndex + 1);
	return { start, end };
}

int SplineCurveModel::InsertControlPoint(int index, const dfPoint& point)
{
	const int n = static_cast<int>(m_controlPoints.size());
	if (index < 0 || index > n)
		return -1;

	m_controlPoints.insert(m_controlPoints.begin() + index, point);

	const int segToSplit = index - 1;
	if (segToSplit >= 0 && segToSplit < static_cast<int>(m_segmentMeta.size()))
	{
		SegmentMeta& meta = m_segmentMeta[segToSplit];
		meta.source = SegmentSource::Algorithm;
		meta.points.clear();
	}
	m_segmentMeta.insert(m_segmentMeta.begin() + index, { SegmentSource::Algorithm, {} });

	const int nSeg = static_cast<int>(m_segmentMeta.size());
	const auto range = GetAffectedSegmentRange(index, nSeg);

	// 将受影响范围内的 Original 段标记为 Algorithm
	for (int i = range.first; i <= range.second; ++i)
	{
		if (i >= 0 && i < nSeg && m_segmentMeta[i].source == SegmentSource::Original)
		{
			m_segmentMeta[i].source = SegmentSource::Algorithm;
			m_segmentMeta[i].points.clear();
		}
	}

	RebuildRenderPoints(&range);
	return index;
}

bool SplineCurveModel::RemoveControlPoint(int index)
{
	const int n = static_cast<int>(m_controlPoints.size());
	if (n <= 3 || index < 0 || index >= n)
		return false;

	m_controlPoints.erase(m_controlPoints.begin() + index);

	const int leftIdx = index - 1;
	const int rightIdx = index;
	if (leftIdx >= 0 && rightIdx < static_cast<int>(m_segmentMeta.size()))
	{
		// 删除控制点后，合并的段一律用算法重建
		m_segmentMeta[leftIdx].source = SegmentSource::Algorithm;
		m_segmentMeta[leftIdx].points.clear();
	}
	m_segmentMeta.erase(m_segmentMeta.begin() + index);

	// 将受影响范围内的 Original 段标记为 Algorithm
	const int nSeg = static_cast<int>(m_segmentMeta.size());
	if (nSeg > 0)
	{
		const int effectiveIndex = (std::min)(index, nSeg - 1);
		const auto range = GetAffectedSegmentRange(effectiveIndex, nSeg);
		for (int i = range.first; i <= range.second; ++i)
		{
			if (i >= 0 && i < nSeg && m_segmentMeta[i].source == SegmentSource::Original)
			{
				m_segmentMeta[i].source = SegmentSource::Algorithm;
				m_segmentMeta[i].points.clear();
			}
		}
	}

	RebuildRenderPoints();
	return true;
}

void SplineCurveModel::UpdateControlPoint(int index, double x, double y)
{
	const int n = static_cast<int>(m_controlPoints.size());
	if (index < 0 || index >= n)
		return;
	m_controlPoints[index].x0 = x;
	m_controlPoints[index].y0 = y;

	const int nSeg = static_cast<int>(m_segmentMeta.size());
	const auto range = GetAffectedSegmentRange(index, nSeg);

	// 将受影响范围内的 Original 段标记为 Algorithm，使其被 Catmull-Rom 重新计算
	for (int i = range.first; i <= range.second; ++i)
	{
		if (i >= 0 && i < nSeg && m_segmentMeta[i].source == SegmentSource::Original)
		{
			m_segmentMeta[i].source = SegmentSource::Algorithm;
			m_segmentMeta[i].points.clear();
		}
	}

	RebuildRenderPoints(&range);
}

void SplineCurveModel::RebuildRenderPoints(const std::pair<int, int>* affectedRange)
{
	const int n = static_cast<int>(m_controlPoints.size());
	const int nSeg = n - 1;
	if (nSeg <= 0)
	{
		m_renderPoints.clear();
		return;
	}

	int startSeg = 0;
	int endSeg = nSeg - 1;
	if (affectedRange)
	{
		startSeg = (std::max)(0, affectedRange->first);
		endSeg = (std::min)(nSeg - 1, affectedRange->second);
	}

	auto cp = [this, n](int i) -> const dfPoint& {
		i = (std::max)(0, (std::min)(n - 1, i));
		return m_controlPoints[i];
	};

	for (int i = startSeg; i <= endSeg; ++i)
	{
		if (i < 0 || i >= nSeg)
			continue;
		SegmentMeta& meta = m_segmentMeta[i];
		if (meta.source == SegmentSource::Algorithm)
		{
			const dfPoint p0 = cp(i - 1);
			const dfPoint p1 = cp(i);
			const dfPoint p2 = cp(i + 1);
			const dfPoint p3 = cp(i + 2);
			meta.points = SampleSegment(p0, p1, p2, p3, m_samplesPerSegment);
		}
	}

	m_renderPoints.clear();
	for (int i = 0; i < nSeg; ++i)
	{
		for (const auto& pt : m_segmentMeta[i].points)
			m_renderPoints.push_back({ pt, i });
	}
}

void SplineCurveModel::ToCCurveEx(CCurveEx& outCurve) const
{
	CPointList pl;
	for (const auto& rp : m_renderPoints)
		pl.AddTail(rp.point);
	if (pl.IsEmpty())
		return;
	outCurve.SetPoints(pl, 4, TRUE);
}

bool SplineCurveModel::InitFromCCurveEx(const CCurveEx& curve, double splineStep)
{
	if (curve.num < 2)
		return false;

	m_controlPoints.clear();
	m_segmentMeta.clear();
	m_renderPoints.clear();

	// 保持原始曲线拷贝，用于提取段数据
	CCurveEx origCurve = curve;

	CCurveEx tempInput = curve;
	CCurveEx simplifiedOutput;
	double errorThreshold = splineStep;
	SplineAlgorithm::SimplifyCurve(tempInput, errorThreshold, 0, simplifiedOutput);

	if (simplifiedOutput.num < 2)
		return false;

	dfPoint pt;
	for (int i = 0; i < simplifiedOutput.num; ++i)
	{
		simplifiedOutput.GetPoint(i, pt);
		m_controlPoints.push_back(pt);
	}

	// 若调用方给出了期望步长，则根据抽稀后的控制点估算一个合适的每段采样数
	if (splineStep > 0.0 && m_controlPoints.size() >= 2)
	{
		double totalLen = 0.0;
		for (size_t i = 1; i < m_controlPoints.size(); ++i)
		{
			const dfPoint& a = m_controlPoints[i - 1];
			const dfPoint& b = m_controlPoints[i];
			const double dx = b.x0 - a.x0;
			const double dy = b.y0 - a.y0;
			totalLen += std::sqrt(dx * dx + dy * dy);
		}

		const int segCount = static_cast<int>(m_controlPoints.size()) - 1;
		if (segCount > 0 && totalLen > 0.0)
		{
			const double avgLen = totalLen / segCount;
			int samples = static_cast<int>(std::ceil(avgLen / splineStep));
			if (samples < 1)
				samples = 1;
			m_samplesPerSegment = samples;
		}
	}

	// 将控制点映射回原始曲线索引，保留原始段的精确点数据
	std::vector<int> indices = SplineAlgorithm::FindClosestPointIndices(m_controlPoints, &origCurve);

	// 确保首尾索引覆盖完整曲线
	if (indices.size() >= 2)
	{
		indices[0] = 0;
		indices[indices.size() - 1] = origCurve.num - 1;
	}

	const int segCount = static_cast<int>(m_controlPoints.size()) - 1;
	m_segmentMeta.clear();
	m_segmentMeta.reserve(segCount);

	for (int i = 0; i < segCount; ++i)
	{
		SegmentMeta meta;
		int startIdx = (i < static_cast<int>(indices.size())) ? indices[i] : -1;
		int endIdx = ((i + 1) < static_cast<int>(indices.size())) ? indices[i + 1] : -1;

		if (startIdx >= 0 && endIdx >= 0 && endIdx < origCurve.num && startIdx <= endIdx)
		{
			meta.source = SegmentSource::Original;
			dfPoint p;
			for (int j = startIdx; j <= endIdx; ++j)
			{
				origCurve.GetPoint(j, p);
				meta.points.push_back(p);
			}
		}
		else
		{
			// 无法映射的段，用 Catmull-Rom 算法重建
			meta.source = SegmentSource::Algorithm;
		}

		m_segmentMeta.push_back(std::move(meta));
	}

	// 仅重建 Algorithm 段的渲染点，Original 段已有精确数据
	RebuildRenderPoints(nullptr);
	return true;
}