/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2025 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/

#include <A3DSDKIncludes.h>
#include "PRC2XML.h"



//######################################################################################################################
static A3DStatus stTraverseSrfNurbsData(const A3DSurfNurbsData& sData, _TiXmlElement* setting)
{
	setting->SetAttribute("m_eKnotType", (int)sData.m_eKnotType);
	setting->SetAttribute("m_eSurfaceForm", (int)sData.m_eSurfaceForm);
	setting->SetAttribute("m_uiUDegree", (int)sData.m_uiUDegree);
	setting->SetAttribute("m_uiVDegree", (int)sData.m_uiVDegree);

	traverseDoubles("m_pdUKnots", sData.m_uiUKnotSize, sData.m_pdUKnots, setting);
	traverseDoubles("m_pdVKnots", sData.m_uiVKnotSize, sData.m_pdVKnots, setting);
	traversePoints("m_pCtrlPts", sData.m_uiUCtrlSize * sData.m_uiVCtrlSize, sData.m_pCtrlPts, setting);

	if (sData.m_pdWeights)
		traverseDoubles("m_pdWeights", sData.m_uiUCtrlSize * sData.m_uiVCtrlSize, sData.m_pdWeights, setting);

	return A3D_SUCCESS;
}

//######################################################################################################################
static A3DStatus stTraverseSrfNurbs(const A3DSurfNurbs* pSrf, _TiXmlElement* setting)
{
	A3DSurfNurbsData sData;
	A3D_INITIALIZE_DATA(A3DSurfNurbsData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfNurbsData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfNurbsGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		stTraverseSrfNurbsData(sData, srf);
		CHECK_RET(A3DSurfNurbsGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
static A3DStatus stTraverseSrfAsNurbs(const A3DSurfBase* pSrf, _TiXmlElement* setting)
{
	A3DSurfNurbsData sData;
	A3D_INITIALIZE_DATA(A3DSurfNurbsData, sData);

	A3DDouble dTolerance = 1e-3;
	A3DStatus iRet = A3DSurfBaseWithDomainGetAsNurbs(pSrf, nullptr, dTolerance, false, &sData);
	if (iRet == A3D_SUCCESS)
	{
		stTraverseSrfNurbsData(sData, setting);
		CHECK_RET(A3DSurfNurbsGet(NULL, &sData));
	}
	else
	{
		setting->SetAttribute("error", iRet);
	}

	return iRet;
}

//######################################################################################################################
A3DStatus traverseSrfPlane(const A3DSurfPlane* pSrf, _TiXmlElement* setting)
{
	A3DSurfPlaneData sData;
	A3D_INITIALIZE_DATA(A3DSurfPlaneData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfPlaneData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfPlaneGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);

		CHECK_RET(A3DSurfPlaneGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Cylinder
static A3DStatus stTraverseSrfCylinder(const A3DSurfCylinder* pSrf, _TiXmlElement* setting)
{
	A3DSurfCylinderData sData;
	A3D_INITIALIZE_DATA(A3DSurfCylinderData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfCylinderData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfCylinderGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);
		setDoubleAttribute(srf, "m_dRadius", sData.m_dRadius);

		CHECK_RET(A3DSurfCylinderGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Sphere
static A3DStatus stTraverseSrfSphere(const A3DSurfSphere* pSrf, _TiXmlElement* setting)
{
	A3DSurfSphereData sData;
	A3D_INITIALIZE_DATA(A3DSurfSphereData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfSphereData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfSphereGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);
		setDoubleAttribute(srf, "m_dRadius", sData.m_dRadius);

		CHECK_RET(A3DSurfSphereGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Revolution
static A3DStatus stTraverseSrfRevolution(const A3DSurfRevolution* pSrf, _TiXmlElement* setting)
{
	A3DSurfRevolutionData sData;
	A3D_INITIALIZE_DATA(A3DSurfRevolutionData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfRevolutionData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfRevolutionGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);

		// 基准曲线（若存在）
		if (sData.m_pCurve)
			traverseCurve(sData.m_pCurve, srf);

		// 轴心与方向作为点输出
		traversePoints("m_sOrigin", 1, &sData.m_sOrigin, srf);
		traversePoints("m_sDirection", 1, &sData.m_sDirection, srf);

		CHECK_RET(A3DSurfRevolutionGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Cone
static A3DStatus stTraverseSrfCone(const A3DSurfCone* pSrf, _TiXmlElement* setting)
{
	A3DSurfConeData sData;
	A3D_INITIALIZE_DATA(A3DSurfConeData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfConeData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfConeGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);
		setDoubleAttribute(srf, "m_dRadius", sData.m_dRadius);
		setDoubleAttribute(srf, "m_dSemiAngle", sData.m_dSemiAngle);
		srf->SetAttribute("m_bInsideOut", (int)sData.m_bInsideOut);

		CHECK_RET(A3DSurfConeGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Cylindrical (basis surface)
static A3DStatus stTraverseSrfCylindrical(const A3DSurfCylindrical* pSrf, _TiXmlElement* setting)
{
	A3DSurfCylindricalData sData;
	A3D_INITIALIZE_DATA(A3DSurfCylindricalData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfCylindricalData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfCylindricalGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);
		// Basis surface
		if (sData.m_pBasisSurf)
			traverseSurface(sData.m_pBasisSurf, srf);

		CHECK_RET(A3DSurfCylindricalGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Offset
static A3DStatus stTraverseSrfOffset(const A3DSurfOffset* pSrf, _TiXmlElement* setting)
{
	A3DSurfOffsetData sData;
	A3D_INITIALIZE_DATA(A3DSurfOffsetData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfOffsetData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfOffsetGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);
		setDoubleAttribute(srf, "m_dOffset", sData.m_dOffset);
		// basis surface
		if (sData.m_pBasisSurf)
			traverseSurface(sData.m_pBasisSurf, srf);

		CHECK_RET(A3DSurfOffsetGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Pipe
static A3DStatus stTraverseSrfPipe(const A3DSurfPipe* pSrf, _TiXmlElement* setting)
{
	A3DSurfPipeData sData;
	A3D_INITIALIZE_DATA(A3DSurfPipeData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfPipeData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfPipeGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);
		setDoubleAttribute(srf, "m_dRadius", sData.m_dRadius);

		// spine and origine are curves
		if (sData.m_pSpine)
			traverseCurve(sData.m_pSpine, srf);
		if (sData.m_pOrigine)
			traverseCurve(sData.m_pOrigine, srf);

		CHECK_RET(A3DSurfPipeGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Ruled
static A3DStatus stTraverseSrfRuled(const A3DSurfRuled* pSrf, _TiXmlElement* setting)
{
	A3DSurfRuledData sData;
	A3D_INITIALIZE_DATA(A3DSurfRuledData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfRuledData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfRuledGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);

		// first and second basis curves
		if (sData.m_pFirstCurve)
			traverseCurve(sData.m_pFirstCurve, srf);
		if (sData.m_pSecondCurve)
			traverseCurve(sData.m_pSecondCurve, srf);

		CHECK_RET(A3DSurfRuledGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Extrusion
static A3DStatus stTraverseSrfExtrusion(const A3DSurfExtrusion* pSrf, _TiXmlElement* setting)
{
	A3DSurfExtrusionData sData;
	A3D_INITIALIZE_DATA(A3DSurfExtrusionData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfExtrusionData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfExtrusionGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);

		if (sData.m_pCurve)
			traverseCurve(sData.m_pCurve, srf);

		traversePoints("m_sDirection", 1, &sData.m_sDirection, srf);

		CHECK_RET(A3DSurfExtrusionGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// FromCurves
static A3DStatus stTraverseSrfFromCurves(const A3DSurfFromCurves* pSrf, _TiXmlElement* setting)
{
	A3DSurfFromCurvesData sData;
	A3D_INITIALIZE_DATA(A3DSurfFromCurvesData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfFromCurvesData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfFromCurvesGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);

		traversePoints("m_sOrigin", 1, &sData.m_sOrigin, srf);
		if (sData.m_pFirstCurve)
			traverseCurve(sData.m_pFirstCurve, srf);
		if (sData.m_pSecondCurve)
			traverseCurve(sData.m_pSecondCurve, srf);

		CHECK_RET(A3DSurfFromCurvesGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
// Torus
static A3DStatus stTraverseSrfTorus(const A3DSurfTorus* pSrf, _TiXmlElement* setting)
{
	A3DSurfTorusData sData;
	A3D_INITIALIZE_DATA(A3DSurfTorusData, sData);

	_TiXmlElement* srf = new _TiXmlElement("A3DSurfTorusData");
	traverseSource(pSrf, srf);

	A3DStatus iRet = A3DSurfTorusGet(pSrf, &sData);
	if (iRet == A3D_SUCCESS)
	{
		traverseCartesianTransformationData(sData.m_sTrsf, srf);
		traverseUVParam(&sData.m_sParam, srf);

		setDoubleAttribute(srf, "m_dMajorRadius", sData.m_dMajorRadius);
		setDoubleAttribute(srf, "m_dMinorRadius", sData.m_dMinorRadius);

		CHECK_RET(A3DSurfTorusGet(NULL, &sData));
	}
	else
	{
		srf->SetAttribute("error", iRet);
	}

	setting->LinkEndChild(srf);
	return iRet;
}

//######################################################################################################################
A3DStatus traverseSurface(const A3DSurfBase* pSrf, _TiXmlElement* setting)
{
	_TiXmlElement* srf = new _TiXmlElement("A3DSurfBase");
	traverseSource(pSrf, srf);

	A3DEEntityType eType;
	A3DStatus iRet = A3DEntityGetType(pSrf, &eType);
	if (iRet == A3D_SUCCESS)
	{
		switch (eType)
		{
		case kA3DTypeSurfNurbs:
			iRet = stTraverseSrfNurbs(pSrf, srf);
			break;
		case kA3DTypeSurfPlane:
			iRet = traverseSrfPlane(pSrf, srf);
			break;
		case kA3DTypeSurfBlend01:
			iRet = A3D_NOT_IMPLEMENTED;
			break;
		case kA3DTypeSurfBlend02:
			iRet = A3D_NOT_IMPLEMENTED;
			break;
		case kA3DTypeSurfBlend03:
			iRet = A3D_NOT_IMPLEMENTED;
			break;
		case kA3DTypeSurfCone:
			iRet = stTraverseSrfCone((const A3DSurfCone*)pSrf, srf);
			break;
		case kA3DTypeSurfCylinder:
			iRet = stTraverseSrfCylinder((const A3DSurfCylinder*)pSrf, srf);
			break;
		case kA3DTypeSurfCylindrical:
			iRet = stTraverseSrfCylindrical((const A3DSurfCylindrical*)pSrf, srf);
			break;
		case kA3DTypeSurfOffset:
			iRet = stTraverseSrfOffset((const A3DSurfOffset*)pSrf, srf);
			break;
		case kA3DTypeSurfPipe:
			iRet = stTraverseSrfPipe((const A3DSurfPipe*)pSrf, srf);
			break;
		case kA3DTypeSurfRuled:
			iRet = stTraverseSrfRuled((const A3DSurfRuled*)pSrf, srf);
			break;
		case kA3DTypeSurfSphere:
			iRet = stTraverseSrfSphere((const A3DSurfSphere*)pSrf, srf);
			break;
		case kA3DTypeSurfRevolution:
			iRet = stTraverseSrfRevolution((const A3DSurfRevolution*)pSrf, srf);
			break;
		case kA3DTypeSurfExtrusion:
			iRet = stTraverseSrfExtrusion((const A3DSurfExtrusion*)pSrf, srf);
			break;
		case kA3DTypeSurfFromCurves:
			iRet = stTraverseSrfFromCurves((const A3DSurfFromCurves*)pSrf, srf);
			break;
		case kA3DTypeSurfTorus:
			iRet = stTraverseSrfTorus((const A3DSurfTorus*)pSrf, srf);
			break;
		case kA3DTypeSurfTransform:
			iRet = A3D_NOT_IMPLEMENTED;
			break;
		case kA3DTypeSurfBlend04:
			iRet = A3D_NOT_IMPLEMENTED;
			break;
		default:
			iRet = A3D_NOT_IMPLEMENTED;
			break;
		}
	}
	else if (iRet == A3D_NOT_IMPLEMENTED)
		iRet = stTraverseSrfAsNurbs(pSrf, srf);

	A3DDomainData oDomain;
	A3D_INITIALIZE_DATA(A3DDomainData, oDomain);
	CHECK_RET(A3DSurfGetDomain(pSrf, &oDomain));
	setDoubleAttribute(srf, "m_sMin.m_dX", oDomain.m_sMin.m_dX);
	setDoubleAttribute(srf, "m_sMin.m_dY", oDomain.m_sMin.m_dY);
	setDoubleAttribute(srf, "m_sMax.m_dX", oDomain.m_sMax.m_dX);
	setDoubleAttribute(srf, "m_sMax.m_dY", oDomain.m_sMax.m_dY);

	setting->LinkEndChild(srf);

	return iRet;
}