/***********************************************************************************************************************
*
* 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 "HXmlElement.h"
#include "HXFeatureTreeReport.h"

#include <algorithm>
#include <cmath>
#include <sstream>
#include <stdlib.h>
#include <vector>

//######################################################################################################################
void HXFeatureTreeReport::traverseIndexes(const A3DUns32 uiSize, const A3DUns32* puiIndexes)
{
	if (uiSize == 0)
		return;

	// max size of one uint: "%u " 14 + 1 = 15
	const A3DUns32           uiFormat  = 15;
	const size_t             uiMaxSize = static_cast<size_t>(uiSize) * static_cast<size_t>(uiFormat);
	std::vector<A3DUTF8Char> pc(uiMaxSize + 1, '\0');

	// store indexes in ascending order: useful for non regression tests
	std::vector<A3DUns32> indexes(puiIndexes, puiIndexes + uiSize);
	std::sort(indexes.begin(), indexes.end());

	size_t uiNext = 0;
	for (const auto& index: indexes)
	{
		const size_t uiwritten = sprintf_s(pc.data() + uiNext, uiMaxSize - uiNext, "%u ", index);
		uiNext += uiwritten;
	}

	if (uiNext != 0)
	{
		// To remove the end whitespace.
		pc[uiNext - 1] = '\0';
	}

	m_sReport.setAttribute("size"   , (int)uiSize);
	m_sReport.setAttribute("indexes", pc.data());
}

//######################################################################################################################
A3DStatus HXFeatureTreeReport::visitEnter(const A3DFRMTreeConnector& /*sConnector*/)
{
	m_failed_count = 0;
	m_not_implemented_node_count = 0;
	m_not_implemented_subnode_count = 0;
	m_mandatory_missing_count = 0;
	m_hole_mandatory_missing_count = 0;
	m_pattern_mandatory_missing_count = 0;
	return A3D_SUCCESS;
}

A3DStatus HXFeatureTreeReport::visitLeave(const A3DFRMTreeConnector& /*sConnector*/)
{
	return A3D_SUCCESS;
}

void HXFeatureTreeReport::traverseFeatureStatus(const A3DFRMFeatureConnector& sConnector)
{
	switch (sConnector.m_sData.m_sType.m_eStatus)
	{
	case kA3DFRMStatus_Failed: m_sReport.setAttribute("status", "Failed"); break;
	case kA3DFRMStatus_NotYetImplemented: m_sReport.setAttribute("status", "NotYetImplemented"); break;
	case kA3DFRMStatus_Success: // ignored, otherwise the XML file is too verbose
	default: break;
	}
}

template<typename T>
void DumpFRMFeatureData(HXmlReport& report, const A3DUns32 size, const T* values)
{
	if (size == 0)
	{
		report.setAttribute("data", "empty");
	}
	else
	{
		std::ostringstream os;
		os << values[0];
		for (A3DUns32 i = 1; i < size; ++i)
			os << " " << values[i];

		report.setAttribute("data", os.str().c_str());
	}
}

void HXFeatureTreeReport::traverseFeatureData(const A3DFRMFeatureConnector& sConnector)
{
	switch (sConnector.m_sData.m_eDataType)
	{
	case kA3DFRMDataInteger:
	{
		A3DFRMIntegerData sIntegerData;
		A3D_INITIALIZE_DATA(A3DFRMIntegerData, sIntegerData);
		A3DFRMIntegerDataGet(sConnector.GetA3DEntity(), &sIntegerData);
		DumpFRMFeatureData(m_sReport, sIntegerData.m_uiValuesSize, sIntegerData.m_piValues);
		A3DFRMIntegerDataGet(NULL, &sIntegerData);
		break;
	}
	case kA3DFRMDataDouble:
	{
		A3DFRMDoubleData sDoubleData;
		A3D_INITIALIZE_DATA(A3DFRMDoubleData, sDoubleData);
		A3DFRMDoubleDataGet(sConnector.GetA3DEntity(), &sDoubleData);

		// We keep three digits after the decimal point without rounding for the output.
		std::transform(sDoubleData.m_pdValues, sDoubleData.m_pdValues + sDoubleData.m_uiValuesSize,
			sDoubleData.m_pdValues, [](double value)
		{
			return std::trunc(value * 1000.0) / 1000.0;
		});

		DumpFRMFeatureData(m_sReport, sDoubleData.m_uiValuesSize, sDoubleData.m_pdValues);
		A3DFRMDoubleDataGet(NULL, &sDoubleData);
		break;
	}
	case kA3DFRMDataString:
	{
		A3DFRMStringData sStringData;
		A3D_INITIALIZE_DATA(A3DFRMStringData, sStringData);
		A3DFRMStringDataGet(sConnector.GetA3DEntity(), &sStringData);
		if (sStringData.m_uiValuesSize == 0)
		{
			m_sReport.setAttribute("data", "empty");
		}
		else
		{
			std::ostringstream os;
			os << sStringData.m_ppcValues[0];
			for (A3DUns32 i = 1; i < sStringData.m_uiValuesSize; ++i)
				if (sStringData.m_ppcValues[i] != nullptr)
					// we use a separator between the values for the .xsl file, in case the values contain spaces
					os << " xts3dx " << sStringData.m_ppcValues[i];

			m_sReport.setAttribute("data", os.str().c_str());
		}
		A3DFRMStringDataGet(NULL, &sStringData);
		break;
	}
	case kA3DFRMDataEnum:
	{
		A3DInt32     iEnumValue    = 0;
		A3DUTF8Char* pcStringValue = NULL;
		A3DFRMEnumDataGet(sConnector.GetA3DEntity(), &iEnumValue, &pcStringValue);
		if (pcStringValue)
			m_sReport.setAttribute("Value", pcStringValue);
		else
			m_sReport.setAttribute("Value", static_cast<int>(iEnumValue));

		A3DFRMEnumDataGet(NULL, &iEnumValue, &pcStringValue);
		break;
	}
	default:
		break;
	}
}

A3DStatus HXFeatureTreeReport::visitEnter(const A3DFRMFeatureConnector& sConnector)
{
	switch (sConnector.m_sData.m_sType.m_eFamily)
	{
	case kA3DFamily_Root:
		m_sReport.createSubNode("Node");
		traverseRootBaseData(sConnector.GetA3DEntity());
		m_sReport.setAttribute("data_type", "root");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMRoot_Node: m_sReport.setAttribute("root_type", "Node"); break;
		case kA3DFRMRoot_Container: m_sReport.setAttribute("root_type", "Container"); break;
		case kA3DFRMRoot_Package: m_sReport.setAttribute("root_type", "Package"); break;
		case kA3DFRMRoot_None:
		default: m_sReport.setAttribute("root_type", "None"); break;
		}
		break;
	case kA3DFamily_Information:
		m_sReport.createSubNode("Feature");
		break;
	case kA3DFamily_Type:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "type");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMEnumDataType_CAD: m_sReport.setAttribute("type_type", "CAD"); break;
		case kA3DFRMEnumDataType_Mode: m_sReport.setAttribute("type_type", "Mode"); break;
		case kA3DFRMEnumDataType_Depth: m_sReport.setAttribute("type_type", "Depth"); break;
		case kA3DFRMEnumDataType_Pattern: m_sReport.setAttribute("type_type", "Pattern"); break;
		case kA3DFRMEnumDataType_HoleShape: m_sReport.setAttribute("type_type", "HoleShape"); break;
		case kA3DFRMEnumDataType_DepthLevel: m_sReport.setAttribute("type_type", "DepthLevel"); break;
		case kA3DFRMEnumDataType_RevolveAngle: m_sReport.setAttribute("type_type", "RevolveAngle"); break;
		case kA3DFRMEnumDataType_Chamfer: m_sReport.setAttribute("type_type", "Chamfer"); break;
		case kA3DFRMEnumDataType_Fillet: m_sReport.setAttribute("type_type", "Fillet"); break;
		case kA3DFRMEnumDataType_FilletLength: m_sReport.setAttribute("type_type", "FilletLength"); break;
		case kA3DFRMEnumDataType_FilletConic: m_sReport.setAttribute("type_type", "FilletConic"); break;
		case kA3DFRMEnumDataType_LengthMode: m_sReport.setAttribute("type_type", "LengthMode"); break;
		case kA3DFRMEnumDataType_PatternMaster: m_sReport.setAttribute("type_type", "PatternMaster"); break;
		case kA3DFRMEnumDataType_ReferenceMaster: m_sReport.setAttribute("type_type", "ReferenceMaster"); break;
		case kA3DFRMDoubleNone:
		default: m_sReport.setAttribute("type_type", "None"); break;
		}
		break;
	case kA3DFamily_FeatureDefinition:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "feature_definition");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMFeatureDefinitionType_Hole: m_sReport.setAttribute("feature_definition_type", "Hole"); break;
		case kA3DFRMFeatureDefinitionType_Pattern: m_sReport.setAttribute("feature_definition_type", "Pattern"); break;
		case kA3DFRMFeatureDefinitionType_Sketch: m_sReport.setAttribute("feature_definition_type", "Sketch"); break;
		case kA3DFRMFeatureDefinitionType_Thread: m_sReport.setAttribute("feature_definition_type", "Thread"); break;
		case kA3DFRMFeatureDefinitionType_Extrude: m_sReport.setAttribute("feature_definition_type", "Extrude"); break;
		case kA3DFRMFeatureDefinitionType_Revolve: m_sReport.setAttribute("feature_definition_type", "Revolve"); break;
		case kA3DFRMFeatureDefinitionType_Cosmetic: m_sReport.setAttribute("feature_definition_type", "Cosmetic"); break;
		case kA3DFRMFeatureDefinitionType_Chamfer: m_sReport.setAttribute("feature_definition_type", "Chamfer"); break;
		case kA3DFRMFeatureDefinitionType_Fillet: m_sReport.setAttribute("feature_definition_type", "Fillet"); break;
		case kA3DFRMFeatureDefinitionType_Mirror: m_sReport.setAttribute("feature_definition_type", "Mirror"); break;
		case kA3DFRMFeatureDefinitionType_Symmetry: m_sReport.setAttribute("feature_definition_type", "Symmetry"); break;
		case kA3DFRMFeatureDefinitionType_Translate: m_sReport.setAttribute("feature_definition_type", "Translate"); break;
		case kA3DFRMFeatureDefinitionType_Rotate: m_sReport.setAttribute("feature_definition_type", "Rotate"); break;
		case kA3DFRMFeatureDefinitionType_None:
		default: m_sReport.setAttribute("definition_type", "None"); break;
		}
		break;
	case kA3DFamily_DoubleData:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "double");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMDoubleValue:  m_sReport.setAttribute("double_type", "Value"); break;
		case kA3DFRMDoubleUnit:	 m_sReport.setAttribute("double_type", "Unit"); break;
		case kA3DFRMDoubleOffset: m_sReport.setAttribute("double_type", "Offset"); break;
		case kA3DFRMDoubleDepth: m_sReport.setAttribute("double_type", "Depth"); break;
		case kA3DFRMDoubleDiameter: m_sReport.setAttribute("double_type", "Diameter"); break;
		case kA3DFRMDoubleAngle: m_sReport.setAttribute("double_type", "Angle"); break;
		case kA3DFRMDoublePitch: m_sReport.setAttribute("double_type", "Pitch"); break;
		case kA3DFRMDoubleDistance: m_sReport.setAttribute("double_type", "Distance"); break;
		case kA3DFRMDoubleExtensionAndStep: m_sReport.setAttribute("double_type", "ExtensionAndStep"); break;
		case kA3DFRMDoubleLinearParameter: m_sReport.setAttribute("double_type", "LinearParameter"); break;
		case kA3DFRMDoubleUVParameter: m_sReport.setAttribute("double_type", "UVParameter"); break;
		case kA3DFRMDoubleRadius: m_sReport.setAttribute("double_type", "Radius"); break;
		case kA3DFRMDoubleNone:
		default: m_sReport.setAttribute("double_type", "None"); break;
		}
		break;
	case kA3DFamily_IntegerData:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "integer");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMIntegerDataValue: m_sReport.setAttribute("integer_type", "Value"); break;
		case kA3DFRMIntegerDataBoolean: m_sReport.setAttribute("integer_type", "Boolean"); break;
		case kA3DFRMIntegerDataIndex: m_sReport.setAttribute("integer_type", "Index"); break;
		case kA3DFRMIntegerDataKeepSpecification: m_sReport.setAttribute("integer_type", "KeepSpecification"); break;
		case kA3DFRMIntegerDataRadialAlignment: m_sReport.setAttribute("integer_type", "RadialAlignment"); break;
		case kA3DFRMIntegerDataClockwise: m_sReport.setAttribute("integer_type", "Clockwise"); break;
		case kA3DFRMIntegerDataId: m_sReport.setAttribute("integer_type", "Id"); break;
		case kA3DFRMIntegerDataFlip: m_sReport.setAttribute("integer_type", "Flip"); break;
		case kA3DFRMIntegerDataType: m_sReport.setAttribute("integer_type", "Type"); break;
		case kA3DFRMIntegerDataCount: m_sReport.setAttribute("integer_type", "Count"); break;
		case kA3DFRMIntegerDataSize: m_sReport.setAttribute("integer_type", "Size"); break;
		case kA3DFRMIntegerDataNbStart: m_sReport.setAttribute("integer_type", "NbStart"); break;
		case kA3DFRMIntegerDataNone:
		default: m_sReport.setAttribute("integer_type", "None"); break;
		}
		break;
	case kA3DFamily_StringData:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "string");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMStringDataName: m_sReport.setAttribute("string_type", "Name"); break;
		case kA3DFRMStringDataAttribute: m_sReport.setAttribute("string_type", "Attribute"); break;
		case kA3DFRMStringDataType: m_sReport.setAttribute("string_type", "Type"); break;
		case kA3DFRMStringDataValue: m_sReport.setAttribute("string_type", "Value"); break;
		case kA3DFRMStringDataOption: m_sReport.setAttribute("string_type", "Option"); break;
		case kA3DFRMStringDataNone:
		default: m_sReport.setAttribute("string_type", "None"); break;
		}
		break;
	case kA3DFamily_Value:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "value");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMValueType_Length: m_sReport.setAttribute("value_type", "Length"); break;
		case kA3DFRMValueType_Angle: m_sReport.setAttribute("value_type", "Angle"); break;
		case kA3DFRMValueType_Diameter: m_sReport.setAttribute("value_type", "Diameter"); break;
		case kA3DFRMValueType_Radius: m_sReport.setAttribute("value_type", "Radius"); break;
		case kA3DFRMValueType_Depth: m_sReport.setAttribute("value_type", "Depth"); break;
		case kA3DFRMValueType_Thickness: m_sReport.setAttribute("value_type", "Thickness"); break;
		case kA3DFRMValueType_Offset: m_sReport.setAttribute("value_type", "Offset"); break;
		case kA3DFRMValueType_Distance: m_sReport.setAttribute("value_type", "Distance"); break;
		case kA3DFRMValueType_Coords: m_sReport.setAttribute("value_type", "Coords"); break;
		case kA3DFRMValueType_Vector: m_sReport.setAttribute("value_type", "Vector"); break;
		case kA3DFRMValueType_Matrix: m_sReport.setAttribute("value_type", "Matrix"); break;
		case kA3DFRMValueType_Area: m_sReport.setAttribute("value_type", "Area"); break;
		case kA3DFRMValueType_Volume: m_sReport.setAttribute("value_type", "Volume"); break;
		case kA3DFRMValueType_Mass: m_sReport.setAttribute("value_type", "Mass"); break;
		case kA3DFRMValueType_Time: m_sReport.setAttribute("value_type", "Time"); break;
		case kA3DFRMValueType_None:
		default: m_sReport.setAttribute("value_type", "None"); break;
		}
		break;
	case kA3DFamily_Definition:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "definition");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMDefinitionType_Depth: m_sReport.setAttribute("definition_type", "Depth"); break;
		case kA3DFRMDefinitionType_DepthFrom: m_sReport.setAttribute("definition_type", "DepthFrom"); break;
		case kA3DFRMDefinitionType_Position: m_sReport.setAttribute("definition_type", "Position"); break;
		case kA3DFRMDefinitionType_Direction: m_sReport.setAttribute("definition_type", "Direction"); break;
		case kA3DFRMDefinitionType_Thread: m_sReport.setAttribute("definition_type", "Thread"); break;
		case kA3DFRMDefinitionType_Shape: m_sReport.setAttribute("definition_type", "Shape"); break;
		case kA3DFRMDefinitionType_Reference: m_sReport.setAttribute("definition_type", "Reference"); break;
		case kA3DFRMDefinitionType_Sketch: m_sReport.setAttribute("definition_type", "Sketch"); break;
		case kA3DFRMDefinitionType_RevolveAngle: m_sReport.setAttribute("definition_type", "RevolveAngle"); break;
		case kA3DFRMDefinitionType_RevolveAngleFrom: m_sReport.setAttribute("definition_type", "RevolveAngleFrom"); break;
		case kA3DFRMDefinitionType_Axis: m_sReport.setAttribute("definition_type", "Axis"); break;
		case kA3DFRMDefinitionType_Chamfer: m_sReport.setAttribute("definition_type", "Chamfer"); break;
		case kA3DFRMDefinitionType_FilletLength: m_sReport.setAttribute("definition_type", "FilletLength"); break;
		case kA3DFRMDefinitionType_ReferenceMaster: m_sReport.setAttribute("definition_type", "ReferenceMaster"); break;
		case kA3DFRMDefinitionType_Tolerance: m_sReport.setAttribute("definition_type", "Tolerance"); break;
		case kA3DFRMDefinitionType_None:
		default: m_sReport.setAttribute("definition_type", "None"); break;
		}
		break;
	case kA3DFamily_Definition_Hole:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "definition_hole");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMDefinitionHoleType_RectangularDefinition:	m_sReport.setAttribute("definition_hole_type", "RectangularDefinition"); break;
		case kA3DFRMDefinitionHoleType_ChamferDefinition:	m_sReport.setAttribute("definition_hole_type", "ChamferDefinition"); break;
		case kA3DFRMDefinitionHoleType_CboreDefinition:	m_sReport.setAttribute("definition_hole_type", "CboreDefinition"); break;
		case kA3DFRMDefinitionHoleType_SunkDefinition:	m_sReport.setAttribute("definition_hole_type", "SunkDefinition"); break;
		case kA3DFRMDefinitionHoleType_TaperedDefinition:	m_sReport.setAttribute("definition_hole_type", "TaperedDefinition"); break;
		case kA3DFRMDefinitionHoleType_StandardDefinition:	m_sReport.setAttribute("definition_hole_type", "StandardDefinition"); break;
		case kA3DFRMDefinitionHoleType_ElementDefinition:	m_sReport.setAttribute("definition_hole_type", "ElementDefinition"); break;
		case kA3DFRMDefinitionHoleType_None:
		default: m_sReport.setAttribute("definition_hole_type", "None"); break;
		}
		break;
	case kA3DFamily_Definition_Pattern:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "definition_pattern");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMDefinitionPatternType_PatternMaster: m_sReport.setAttribute("definition_pattern_type", "PatternMaster"); break;
		case kA3DFRMDefinitionPatternType_PolygonalShape: m_sReport.setAttribute("definition_pattern_type", "PolygonalShape"); break;
		case kA3DFRMDefinitionPatternType_SpiralShape: m_sReport.setAttribute("definition_pattern_type", "SpiralShape"); break;
		case kA3DFRMDefinitionPatternType_DirectionSpacing: m_sReport.setAttribute("definition_pattern_type", "DirectionSpacing"); break;
		case kA3DFRMDefinitionPatternType_AxialSpacing: m_sReport.setAttribute("definition_pattern_type", "AxialSpacing"); break;
		case kA3DFRMDefinitionPatternType_RadialSpacing: m_sReport.setAttribute("definition_pattern_type", "RadialSpacing"); break;
		case kA3DFRMDefinitionPatternType_PolygonalSpacing: m_sReport.setAttribute("definition_pattern_type", "PolygonalSpacing"); break;
		case kA3DFRMDefinitionPatternType_SpiralSpacing: m_sReport.setAttribute("definition_pattern_type", "SpiralSpacing"); break;
		case kA3DFRMDefinitionPatternType_InstanceStatus: m_sReport.setAttribute("definition_pattern_type", "InstanceStatus"); break;
		case kA3DFRMDefinitionPatternType_InstanceInformation:m_sReport.setAttribute("definition_pattern_type", "InstanceInformation"); break;
		case kA3DFRMDefinitionPatternType_None:
		default: m_sReport.setAttribute("definition_pattern_type", "None"); break;
		}
		break;
	case kA3DFamily_Definition_Thread:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "definition_thread");
		switch (sConnector.m_sData.m_sType.m_uiType)
		{
		case kA3DFRMDefinitionThreadType_Undercut: m_sReport.setAttribute("definition_thread_type", "Undercut"); break;
		case kA3DFRMDefinitionThreadType_Shaft: m_sReport.setAttribute("definition_thread_type", "Shaft"); break;
		case kA3DFRMDefinitionThreadType_None:
		default: m_sReport.setAttribute("definition_thread_type", "None"); break;
		}
		break;
	default:
		m_sReport.createSubNode("Feature");
		m_sReport.setAttribute("data_type", "None");
	}

	traverseFeatureStatus(sConnector);
	traverseFeatureData(sConnector);

	return A3D_SUCCESS;
}

A3DStatus HXFeatureTreeReport::visitLeave(const A3DFRMFeatureConnector& /*sConnector*/)
{
	m_sReport.closeSubNode();
	return A3D_SUCCESS;
}

void HXFeatureTreeReport::DumpIndexesBy3(
	const char*     name,
	const A3DUns32  uiAdditionalIndexesSize,
	const A3DUns32* puiAdditionalIndexes)
{
	if (uiAdditionalIndexesSize % 3)
		return;

	for (A3DUns32 i = 0; i + 2 < uiAdditionalIndexesSize; i += 3)
	{
		char acName[255];
		sprintf_s(acName, sizeof(acName) - 1, "%d %d %d",
			puiAdditionalIndexes[i],
			puiAdditionalIndexes[i + 1],
			puiAdditionalIndexes[i + 2]);

		HXmlElement* pXmlElement= new HXmlElement(name);
		pXmlElement->SetAttribute("indexes", acName);

		m_sReport.addNode(pXmlElement);
	}
}

void HXFeatureTreeReport::DumpIndexesBy4(
	const char*     name,
	const A3DUns32  uiAdditionalIndexesSize,
	const A3DUns32* puiAdditionalIndexes)
{
	if (uiAdditionalIndexesSize % 4)
		return;

	for (A3DUns32 i = 0; i + 3 < uiAdditionalIndexesSize; i += 4)
	{
		char acName[255];
		sprintf_s(acName, sizeof(acName) - 1, "%d %d %d %d",
			puiAdditionalIndexes[i],
			puiAdditionalIndexes[i + 1],
			puiAdditionalIndexes[i + 2],
			puiAdditionalIndexes[i + 3]);

		HXmlElement* pXmlElement = new HXmlElement(name);
		pXmlElement->SetAttribute("indexes", acName);

		m_sReport.addNode(pXmlElement);
	}
}

void HXFeatureTreeReport::traverseMiscReferenceOnTessData(const A3DMiscEntityReference* pEntityReference)
{
	m_sReport.createSubNode("ReferenceOnTessellation");

	A3DMiscReferenceOnTessData sReferenceOnTessData;
	A3D_INITIALIZE_DATA(A3DMiscReferenceOnTessData, sReferenceOnTessData);
	A3DStatus iRet = A3DMiscReferenceOnTessGet(pEntityReference, &sReferenceOnTessData);
	if (iRet != A3D_SUCCESS)
		return;

	traverseMiscReferenceOnBRep(
		sReferenceOnTessData.m_pPolyBrepModel,
		sReferenceOnTessData.m_eTopoItemType,
		sReferenceOnTessData.m_puiAdditionalIndexes,
		sReferenceOnTessData.m_uiSize);

	A3DMiscReferenceOnTessGet(NULL, &sReferenceOnTessData);

	m_sReport.closeSubNode();
}

void HXFeatureTreeReport::traverseMiscReferenceOnCsysItem(const A3DMiscReferenceOnCsysItem* pEntityReference)
{
	m_sReport.createSubNode("ReferenceOnCSYSItem");

	A3DMiscReferenceOnCsysItemData sA3DMiscReferenceOnCSYSITemData;
	A3D_INITIALIZE_DATA(A3DMiscReferenceOnCsysItemData, sA3DMiscReferenceOnCSYSITemData);
	A3DStatus iRet = A3DMiscReferenceOnCsysItemGet(pEntityReference, &sA3DMiscReferenceOnCSYSITemData);
	if (iRet != A3D_SUCCESS || !sA3DMiscReferenceOnCSYSITemData.m_pCoordinateSystem)
		return;

	A3DRootBaseData sCSYSRootData;
	A3D_INITIALIZE_DATA(A3DRootBaseData, sCSYSRootData);
	if (A3DRootBaseGet(sA3DMiscReferenceOnCSYSITemData.m_pCoordinateSystem, &sCSYSRootData) == A3D_SUCCESS)
	{
		m_sReport.setAttribute("index", sA3DMiscReferenceOnCSYSITemData.m_uiIndex);
		A3DRootBaseGet(NULL, &sCSYSRootData);
	}

	traverseRootBaseData(sA3DMiscReferenceOnCSYSITemData.m_pCoordinateSystem);

	m_sReport.closeSubNode();
}

void HXFeatureTreeReport::traverseMiscReferenceOnTopology(const A3DMiscReferenceOnTopology* pEntityReference)
{
	m_sReport.createSubNode("ReferenceOnTopology");

	A3DMiscReferenceOnTopologyData sReferenceOnTopologyData;
	A3D_INITIALIZE_DATA(A3DMiscReferenceOnTopologyData, sReferenceOnTopologyData);
	A3DStatus iRet = A3DMiscReferenceOnTopologyGet((A3DMiscReferenceOnTopology*)pEntityReference, &sReferenceOnTopologyData);
	if (iRet != A3D_SUCCESS)
		return;

	traverseMiscReferenceOnBRep(
		sReferenceOnTopologyData.m_pBrepData,
		sReferenceOnTopologyData.m_eTopoItemType,
		sReferenceOnTopologyData.m_puiAdditionalIndexes,
		sReferenceOnTopologyData.m_uiSize);

	A3DMiscReferenceOnTopologyGet(NULL, &sReferenceOnTopologyData);

	m_sReport.closeSubNode();
}

void HXFeatureTreeReport::traverseMiscReferenceOnBRep(
	const A3DEntity*     pEntity,
	const A3DEEntityType eType,
	const A3DUns32*      puiAdditionalIndexes,
	const A3DUns32       uiAdditionalIndexesSize)
{
	switch (eType)
	{
	case kA3DTypeTopoEdge:
		m_sReport.setAttribute("topo_type", "Edge");
		DumpIndexesBy3("Edge", uiAdditionalIndexesSize, puiAdditionalIndexes);
		break;
	case kA3DTypeTopoCoEdge:
		m_sReport.setAttribute("topo_type", "CoEdge");
		DumpIndexesBy3("Edge", uiAdditionalIndexesSize, puiAdditionalIndexes);
		break;
	case kA3DTypeTopoFace:
		m_sReport.setAttribute("topo_type", "Face");
		traverseIndexes(uiAdditionalIndexesSize, puiAdditionalIndexes);
		break;
	case kA3DTypeTopoUniqueVertex:
		m_sReport.setAttribute("topo_type", "UniqueVertex");
		DumpIndexesBy4("Vertex", uiAdditionalIndexesSize, puiAdditionalIndexes);
		break;
	case kA3DTypeTopoMultipleVertex:
		m_sReport.setAttribute("topo_type", "MultipleVertex");
		DumpIndexesBy4("Vertex", uiAdditionalIndexesSize, puiAdditionalIndexes);
		break;
	case kA3DTypeUnknown:
	default:
		break;
	}

	traverseRootBaseData(pEntity);
}

void HXFeatureTreeReport::traverseDrawingBlock(const A3DDrawingBlockBasic *pDrwBlock)
{
	A3DInt32 iRet = A3D_SUCCESS;

	A3DDrawingBlockBasicData sDrwBlockData;
	A3D_INITIALIZE_DATA(A3DDrawingBlockBasicData, sDrwBlockData);

	m_sReport.createSubNode("DrawingBlock"); 
	
	if ((iRet = A3DDrawingBlockBasicGet((A3DDrawingBlockBasic const*)pDrwBlock, &sDrwBlockData)) == A3D_SUCCESS)
	{
		m_sReport.setAttribute("nb_entities", (int)sDrwBlockData.m_uiDrwEntitiesSize);
		m_sReport.setAttribute("nb_markups", (int)sDrwBlockData.m_uiMarkupsSize);
		m_sReport.setAttribute("nb_drawing_blocks", (int)sDrwBlockData.m_uiDrwBlocksSize);

		traverseRootBaseData(pDrwBlock);

		for (A3DUns32 ui = 0; ui < sDrwBlockData.m_uiDrwBlocksSize; ++ui)
			traverseDrawingBlock(sDrwBlockData.m_ppDrwBlocks[ui]);

		A3DDrawingBlockBasicGet(NULL, &sDrwBlockData);
	}
	m_sReport.closeSubNode();
}

void HXFeatureTreeReport::traverseEntityReference(const A3DEntity* pEntityReference)
{
	A3DMiscEntityReferenceData sData;
	A3D_INITIALIZE_DATA(A3DMiscEntityReferenceData, sData);

	A3DEEntityType eType = kA3DTypeUnknown;
	A3DEntityGetType(pEntityReference, &eType);

	if (eType == kA3DTypeMiscReferenceOnTopology)
	{
		traverseMiscReferenceOnTopology(pEntityReference);
	}
	else if (eType == kA3DTypeMiscReferenceOnCsysItem)
	{
		traverseMiscReferenceOnCsysItem(pEntityReference);
	}
	else if (eType == kA3DTypeFRMFeature)
	{
		traverseRootBaseData(pEntityReference);
	}
	else if (eType == kA3DTypeDrawingBlockBasic)
	{
		traverseDrawingBlock((const A3DDrawingBlockBasic *)pEntityReference);
	}
	else
	{
		if (eType == kA3DTypeRiPolyBrepModel)
		{
			traverseMiscReferenceOnTessData(pEntityReference);
		}
		else if (eType == kA3DTypeRiPlane)
		{
			A3DMiscMarkupLinkedItem* pLinkedItem = NULL;
			A3DRiPlaneSupportGet((const A3DRiPlane*)pEntityReference, &pLinkedItem);
			if (pLinkedItem)
			{
				m_sReport.createSubNode("Support");
				A3DMiscEntityReferenceGet(pLinkedItem, &sData);
				traverseEntityReference(sData.m_pEntity);
				m_sReport.closeSubNode();
			}
		}
		else if (eType == kA3DTypeRiCurve)
		{
			A3DMiscMarkupLinkedItem* pLinkedItem = NULL;
			A3DRiCurveSupportGet((const A3DRiCurve*)pEntityReference, &pLinkedItem);
			if (pLinkedItem)
			{
				m_sReport.createSubNode("Support");
				A3DMiscEntityReferenceGet(pLinkedItem, &sData);
				traverseEntityReference(sData.m_pEntity);
				m_sReport.closeSubNode();
			}
		}

		traverseRootBaseData(pEntityReference);
	}

	A3DMiscEntityReferenceGet(NULL, &sData);
}

A3DStatus HXFeatureTreeReport::visitEnter(const A3DFRMLinkedItemConnector& sConnector)
{
	m_sReport.createSubNode("Connection");
	switch (sConnector.m_sData.m_eType)
	{
	case kA3DFRMLink_Outcome:
		m_sReport.setAttribute("Type", "Outcome");
		break;
	case kA3DFRMLink_Construction:
		m_sReport.setAttribute("Type", "Construction");
		break;
	case kA3DFRMLink_Position:
		m_sReport.setAttribute("Type", "Position");
		break;
	case kA3DFRMLink_Support:
		m_sReport.setAttribute("Type", "Support");
		break;
	case kA3DFRMLink_None:
	default:
		m_sReport.setAttribute("Type", "None");
		break;
	}

	if (sConnector.m_sData.m_pReference)
		traverseEntityReference(sConnector.m_sData.m_pReference);

	return A3D_SUCCESS;
}

A3DStatus HXFeatureTreeReport::visitLeave(const A3DFRMLinkedItemConnector& /*sConnector*/)
{
	m_sReport.closeSubNode();
	return A3D_SUCCESS;
}

A3DStatus HXFeatureTreeReport::visitEnter(const A3DFRMParameterConnector& sConnector)
{
	switch (sConnector.m_sData.m_eType)
	{
	case kA3DParameterType_Information:
	{
		m_sReport.createSubNode("Information");
		break;
	}
	case kA3DParameterType_Type:
	{
		m_sReport.createSubNode("Type");
		break;
	}
	case kA3DParameterType_Specification:
	{
		m_sReport.createSubNode("Specification");
		break;
	}
	case kA3DParameterType_FeatureDefinition:
	{
		m_sReport.createSubNode("FeatureDefinition");
		break;
	}
	case kA3DParameterType_Definition:
	{
		m_sReport.createSubNode("Definition");
		break;
	}
	case kA3DParameterType_Container:
	{
		m_sReport.createSubNode("Container");
		break;
	}
	case kA3DParameterType_ContainerInternal:
	{
		m_sReport.createSubNode("ContainerInternal");
		break;
	}
	case kA3DParameterType_Data:
	{
		m_sReport.createSubNode("Data");
		break;
	}
	case kA3DParameterType_None:
	default:
		m_sReport.createSubNode("None");
		break;
	}
	return A3D_SUCCESS;
}

A3DStatus HXFeatureTreeReport::visitLeave(const A3DFRMParameterConnector& /*sConnector*/)
{
	m_sReport.closeSubNode();
	return A3D_SUCCESS;
}

void HXFeatureTreeReport::traverseRootBaseData(const A3DEntity* pEntity)
{
	A3DRootBaseData sRBData;
	A3D_INITIALIZE_DATA(A3DRootBaseData, sRBData);
	A3DStatus iRet = A3DRootBaseGet(pEntity, &sRBData);
	if (iRet != A3D_SUCCESS)
		return;

	HXmlElement* pXmlRootBaseData = new HXmlElement("RootBase");
	m_sReport.addNode(pXmlRootBaseData);
	if (sRBData.m_pcName && sRBData.m_pcName[0] != '\0')
		pXmlRootBaseData->SetAttribute("name", sRBData.m_pcName);

	pXmlRootBaseData->SetAttribute("persistent_id", sRBData.m_uiPersistentId);
	pXmlRootBaseData->SetAttribute("non_persistent_id", sRBData.m_uiNonPersistentId);
	A3DRootBaseGet(NULL, &sRBData);
}

bool HXFeatureTreeReport::isAlreadyTreadted(const A3DFRMFeatureConnector& sFeature)
{
	std::vector<const A3DEntity*>::iterator feature = m_apAlreadyparsedFeatures.begin();
	for (; feature != m_apAlreadyparsedFeatures.end(); ++feature)
		if (*feature == sFeature.GetA3DEntity())
			return FALSE;

	m_apAlreadyparsedFeatures.push_back(sFeature.GetA3DEntity());
	return TRUE;
}