/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 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 <stdlib.h>
#include <set>
#include<sstream>

#include "HXmlElement.h"
#include "HXFeatureTreeReport.h"


//######################################################################################################################
int traverseIndexes(const A3DUTF8Char* name, const A3DUns32 uiSize, const A3DUns32* pui, TiXmlElement* setting)
{

	A3DUns32 gnAllocatedStrings = 0;
	A3DUTF8Char gbigstring[65536];

	if (uiSize > 0)
	{
		A3DUns32 ui = 0;
		TiXmlElement* uints = new TiXmlElement(name);
		uints->SetAttribute("size", (int)uiSize);

		// max size of one uint: "%d " 14+1=15
		A3DUns32 uiFormat = 15;
		A3DUTF8Char* pc = NULL;
		size_t uiMaxSize = sizeof(gbigstring)-1;
		if (uiFormat*uiSize > 65536)
		{
			uiMaxSize = size_t(uiSize * uiFormat);
			pc = (A3DUTF8Char*)malloc((uiMaxSize +1) * sizeof(A3DUTF8Char));
			pc[0] = 0;
			gnAllocatedStrings++;
		}
		else
			pc = gbigstring;

		// store temporarily indexes in a set so it is stored in ascending order: useful for non regression tests
		std::set<A3DUns32> setIndexes;
		for (ui = 0; ui < uiSize; ++ui)
		{
			setIndexes.insert(pui[ui]);
		}

		size_t uiNext = 0;
		for (auto const& itSetIndexes : setIndexes)
		{
			int iwritten = sprintf_s(pc + uiNext, uiMaxSize - uiNext, "%u ", itSetIndexes);
			uiNext += size_t(iwritten);
		}
		pc[uiNext] = 0;

		uints->SetAttribute("indexes", pc);
		setting->LinkEndChild(uints);

		if (uiFormat*uiSize > 65536)
			free(pc);
	}
	return A3D_SUCCESS;
}

//######################################################################################################################


A3DStatus HXFeatureTreeReport::visitEnter(const A3DFRMTreeConnector& /*sConnector*/)
{
	m_failed_count = 0;
	m_non_implemented_node_count = 0;
	m_non_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)
{
	if (sConnector.m_sData.m_sType.m_eStatus == kA3DFRMStatus_Failed)
	{
		m_sReport.setAttribute("status", "failed");

	}
	else if (sConnector.m_sData.m_sType.m_eStatus != kA3DFRMStatus_Success)
	{
		m_sReport.setAttribute("status", "non_implemented");
	}
}


void  HXFeatureTreeReport::traverseFeatureData(const A3DFRMFeatureConnector& sConnector)
{
	A3DFRMIntegerData sIntegerData;
	A3DFRMDoubleData sDoubleData;
	A3DFRMStringData sStringData;
	A3DInt32 iEnumValue;
	A3DUTF8Char* pcValueAsString = NULL;
	std::ostringstream s;

	switch (sConnector.m_sData.m_eDataType)
	{
	case kA3DFRMDataInteger:
		A3D_INITIALIZE_DATA(A3DFRMIntegerData, sIntegerData);
		A3DFRMIntegerDataGet(sConnector.GetA3DEntity(), &sIntegerData);
		if (sIntegerData.m_uiValuesSize == 0)
		{
			m_sReport.setAttribute("data", "empty");
			A3DFRMIntegerDataGet(NULL, &sIntegerData);
			return;
		}
		s << sIntegerData.m_piValues[0];
		for (A3DUns32 i = 1; i < sIntegerData.m_uiValuesSize; ++i)
		{
			s << ", ";
			s << sIntegerData.m_piValues[i];
			if (((i + 1) % 4) == 0)
				s << ",";
		}
		m_sReport.setAttribute("data", s.str().c_str());
		A3DFRMIntegerDataGet(NULL, &sIntegerData);
		break;
	case kA3DFRMDataDouble:
		A3D_INITIALIZE_DATA(A3DFRMDoubleData, sDoubleData);
		A3DFRMDoubleDataGet(sConnector.GetA3DEntity(), &sDoubleData);
		if (sDoubleData.m_uiValuesSize == 0)
		{
			m_sReport.setAttribute("data", "empty");
			A3DFRMDoubleDataGet(NULL, &sDoubleData);
			return;
		}
		s << sDoubleData.m_pdValues[0];
		for (A3DUns32 i = 1; i < sDoubleData.m_uiValuesSize; ++i)
		{
			s << ", ";
			s << sDoubleData.m_pdValues[i];
			if (((i + 1) % 4) == 0)
				s << ",";
		}
		m_sReport.setAttribute("data", s.str().c_str());
		A3DFRMDoubleDataGet(NULL, &sDoubleData);
		break;
	case kA3DFRMDataString:
		A3D_INITIALIZE_DATA(A3DFRMStringData, sStringData);
		A3DFRMStringDataGet(sConnector.GetA3DEntity(), &sStringData);
		if (sStringData.m_uiValuesSize == 0)
		{
			m_sReport.setAttribute("data", "empty");
			A3DFRMStringDataGet(NULL, &sStringData);
			return;
		}
		s << sStringData.m_ppcValues[0];
		for (A3DUns32 i =1; i < sStringData.m_uiValuesSize; ++i)
		{
			s << " xts3dx ";
			if(sStringData.m_ppcValues[i] == nullptr)
				s << "NULL";
			else
				s << sStringData.m_ppcValues[i];
		}
		m_sReport.setAttribute("data", s.str().c_str());
		A3DFRMStringDataGet(NULL, &sStringData);
		break;
	case kA3DFRMDataEnum:
		A3DFRMEnumDataGet(sConnector.GetA3DEntity(), &iEnumValue, &pcValueAsString);
		if (pcValueAsString)
			m_sReport.setAttribute("Value", pcValueAsString);
		else
			m_sReport.setAttribute("Value", iEnumValue);
		A3DFRMEnumDataGet(NULL, &iEnumValue, &pcValueAsString);
		break;
	default:
		break;
	}
}



A3DStatus HXFeatureTreeReport::visitEnter(const A3DFRMFeatureConnector& sConnector)
{
	switch (sConnector.m_sData.m_sType.m_eFamily) {
	case kA3DFamily_Root:
	{
		m_sReport.createSubNode("NODE");
		m_sReport.addNode(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_None:
		default: m_sReport.setAttribute("Root_type", "unknown");	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_TYPE"); break;
		case kA3DFRMEnumDataType_Mode:  m_sReport.setAttribute("Type_type", "MODE_TYPE"); break;
		case kA3DFRMEnumDataType_Depth:  m_sReport.setAttribute("Type_type", "DEPTH_TYPE"); break;
		case kA3DFRMEnumDataType_Pattern:  m_sReport.setAttribute("Type_type", "PATTERN_TYPE"); break;
		case kA3DFRMEnumDataType_HoleShape:  m_sReport.setAttribute("Type_type", "HOLE_TYPE"); break;
		case kA3DFRMEnumDataType_DepthLevel:  m_sReport.setAttribute("Type_type", "DEPTH_LEVEL_TYPE"); break;
		case kA3DFRMEnumDataType_Chamfer:  m_sReport.setAttribute("Type_type", "CHAMFER_TYPE"); break;
		case kA3DFRMEnumDataType_Fillet:  m_sReport.setAttribute("Type_type", "FILLET_TYPE"); break;
		case kA3DFRMEnumDataType_FilletLength:  m_sReport.setAttribute("Type_type", "FILLET_LENGTH_TYPE"); break;
		case kA3DFRMEnumDataType_FilletConic:  m_sReport.setAttribute("Type_type", "FILLET_CONIC_TYPE"); break;
		case kA3DFRMEnumDataType_LengthMode:  m_sReport.setAttribute("Type_type", "LENGTH_MODE"); break;
		case kA3DFRMEnumDataType_PatternMaster:  m_sReport.setAttribute("Type_type", "PATTERN_MASTER_TYPE"); break;
		case kA3DFRMEnumDataType_ReferenceMaster: m_sReport.setAttribute("Type_type", "REFERENCE_MASTER_TYPE"); break;
		case kA3DFRMDoubleNone:
		default: m_sReport.setAttribute("Type_type", "unknown");	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", "unknown");	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", "extension_and_step"); break;
		case kA3DFRMDoubleLinearParameter: m_sReport.setAttribute("double_type", "linear_parameter"); break;
		case kA3DFRMDoubleUVParameter: m_sReport.setAttribute("double_type", "uv_parameter"); break;
		case kA3DFRMDoubleRadius: m_sReport.setAttribute("double_type", "radius"); break;
		case kA3DFRMDoubleNone:
		default: m_sReport.setAttribute("double_type", "unknown");	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", "unknown");	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 kA3DFRMStringDataNone:
		default: m_sReport.setAttribute("double_type", "unknown");	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 kA3DFRMStringDataNone:
		default: m_sReport.setAttribute("double_type", "unknown");	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", "Values"); break;
		case kA3DFRMDefinitionType_FilletLength: m_sReport.setAttribute("definition_type", "FilletLength"); break;
		case kA3DFRMDefinitionType_ReferenceMaster: m_sReport.setAttribute("definition_type", "ReferenceMaster"); break;
		case kA3DFRMDefinitionType_None:
		default: m_sReport.setAttribute("definition_type", "unknown");	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", "unknown");	break;
			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", "unknown");	break;
			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", "unknown");	break;
			break;
		}
		break;
	}
	default:
	{
		m_sReport.createSubNode("FEATURE");
		m_sReport.setAttribute("data_type", "unknown");
	}
	}
	traverseFeatureStatus(sConnector);
	traverseFeatureData(sConnector);


	return A3D_SUCCESS;
}

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

HXmlElement* HXFeatureTreeReport::traverseA3DMiscReferenceOnTessData(const A3DMiscEntityReference* pEntityReference)
{
	A3DMiscReferenceOnTessData sReferenceOnTessData;
	A3D_INITIALIZE_DATA(A3DMiscReferenceOnTessData, sReferenceOnTessData);
	if (A3DMiscReferenceOnTessGet(pEntityReference, &sReferenceOnTessData) != A3D_SUCCESS)
		return NULL;

	HXmlElement* pXmlReferenceOnTess = new HXmlElement("ReferenceOnTess");

	pXmlReferenceOnTess->SetAttribute("topotype", "Face");
	if (sReferenceOnTessData.m_uiSize == 0)
		pXmlReferenceOnTess->SetAttribute("ref_count", "error");

	for (A3DUns32 iFace = 0; iFace < sReferenceOnTessData.m_uiSize; iFace++)
		pXmlReferenceOnTess->SetAttribute("face_indice", sReferenceOnTessData.m_puiAdditionalIndexes[iFace]);

	A3DMiscReferenceOnTessGet(NULL, &sReferenceOnTessData);

	return pXmlReferenceOnTess;
}


HXmlElement* HXFeatureTreeReport::traverseA3DMiscReferenceOnCsysItem(const A3DMiscReferenceOnCsysItem* pEntityReference)
{
	HXmlElement* pXmlReferenceOnCsysItem = new HXmlElement("ReferenceOnCsysItem");

	A3DMiscReferenceOnCsysItemData sA3DMiscReferenceOnCSYSITemData;
	A3D_INITIALIZE_DATA(A3DMiscReferenceOnCsysItemData, sA3DMiscReferenceOnCSYSITemData);
	A3DStatus iRet = A3DMiscReferenceOnCsysItemGet(pEntityReference, &sA3DMiscReferenceOnCSYSITemData);
	if (iRet != A3D_SUCCESS || !sA3DMiscReferenceOnCSYSITemData.m_pCoordinateSystem)
	{
		pXmlReferenceOnCsysItem->SetAttribute("error_A3DMiscReferenceOnCsysItemGet", iRet);
		return pXmlReferenceOnCsysItem;
	}
	A3DRootBaseData sCSYSRootData;
	A3D_INITIALIZE_DATA(A3DRootBaseData, sCSYSRootData);
	if (A3DRootBaseGet(sA3DMiscReferenceOnCSYSITemData.m_pCoordinateSystem, &sCSYSRootData) == A3D_SUCCESS)
	{
		pXmlReferenceOnCsysItem->SetAttribute("cys_name", (sCSYSRootData.m_pcName && sCSYSRootData.m_pcName[0] != '\0') ? sCSYSRootData.m_pcName : "NULL");
		pXmlReferenceOnCsysItem->SetAttribute("index", sA3DMiscReferenceOnCSYSITemData.m_uiIndex);
		A3DRootBaseGet(NULL,&sCSYSRootData);
	}
	return pXmlReferenceOnCsysItem;
}

HXmlElement* HXFeatureTreeReport::traverseReferenceOnTopology(const A3DMiscReferenceOnTopology* pEntityReference)
{
	A3DMiscReferenceOnTopologyData sReferenceOnTopologyData;
	A3D_INITIALIZE_DATA(A3DMiscReferenceOnTopologyData, sReferenceOnTopologyData);
	HXmlElement* pXmReferenceOnTopology = new HXmlElement("ReferenceOnTopology");
	if (A3DMiscReferenceOnTopologyGet((A3DMiscReferenceOnTopology*)pEntityReference, &sReferenceOnTopologyData) != A3D_SUCCESS)
	{
		pXmReferenceOnTopology->SetAttribute("error", "A3DMiscReferenceOnTopologyGet");
		return pXmReferenceOnTopology;
	}
	A3DUns32 i = 0;
	char acName[255];
	switch (sReferenceOnTopologyData.m_eTopoItemType)
	{
	case kA3DTypeTopoEdge:
		pXmReferenceOnTopology->SetAttribute("topo_type", "Edge");
		if (!(sReferenceOnTopologyData.m_uiSize != 3))
		{
			pXmReferenceOnTopology->SetAttribute("ref_count", "error");
			break;
		}
		while (i + 2 < sReferenceOnTopologyData.m_uiSize)
		{
			sprintf_s(acName, sizeof(acName)-1,"%d %d %d",
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+1],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+2]);
			pXmReferenceOnTopology->SetAttribute("face/loop/edge indexes", acName);
			i+=3;
		}
		break;
	case kA3DTypeTopoCoEdge:
		pXmReferenceOnTopology->SetAttribute("topotype", "CoEdge");
		if (!(sReferenceOnTopologyData.m_uiSize % 3))
		{
			pXmReferenceOnTopology->SetAttribute("ref_count", "error");
			break;
		}
		while (i + 2 < sReferenceOnTopologyData.m_uiSize)
		{
			sprintf_s(acName, sizeof(acName) - 1, "%d %d %d",
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+1],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+2]);
			pXmReferenceOnTopology->SetAttribute("face/loop/coedge indexes", acName);
			i+=3;
		}
		break;
	case kA3DTypeTopoFace:
		pXmReferenceOnTopology->SetAttribute("topotype", "Face");
		traverseIndexes("face_indexes", sReferenceOnTopologyData.m_uiSize, sReferenceOnTopologyData.m_puiAdditionalIndexes, pXmReferenceOnTopology);
		break;
	case kA3DTypeTopoUniqueVertex:
		pXmReferenceOnTopology->SetAttribute("topotype", "Unique Vertex");
		if (!(sReferenceOnTopologyData.m_uiSize %= 4))
		{
			pXmReferenceOnTopology->SetAttribute("ref_count", "error");
			break;
		}
		while (i + 3 < sReferenceOnTopologyData.m_uiSize)
		{
			sprintf_s(acName, sizeof(acName) - 1, "%d %d %d %d",
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+1],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+2],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+3]);
			pXmReferenceOnTopology->SetAttribute("face/loop/edge/vertex indexes", acName);
			i+=4;
		}
		break;
	case kA3DTypeTopoMultipleVertex:
		pXmReferenceOnTopology->SetAttribute("topotype", "Multiple Vertex");
		if (!(sReferenceOnTopologyData.m_uiSize % 4 != 0))
		{
			pXmReferenceOnTopology->SetAttribute("ref_count", "error");
			break;
		}
		while (i + 3 < sReferenceOnTopologyData.m_uiSize)
		{
			sprintf_s(acName, sizeof(acName) - 1, "%d %d %d %d",
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+1],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+2],
				sReferenceOnTopologyData.m_puiAdditionalIndexes[i+3]);
			pXmReferenceOnTopology->SetAttribute("face/loop/edge/vertex indexes", acName);
			i+=4;
		}
		break;
	default:
		pXmReferenceOnTopology->SetAttribute("linked_item_topo_reference", "unexpected");
		break;
	}
	A3DMiscReferenceOnTopologyGet(NULL,&sReferenceOnTopologyData);
	return pXmReferenceOnTopology;
}


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.addNode(traverseRootBaseData(pDrwBlock));
		m_sReport.setAttribute("Entity_count", (int)sDrwBlockData.m_uiDrwEntitiesSize);
		m_sReport.setAttribute("Markup_count", (int)sDrwBlockData.m_uiMarkupsSize);
		m_sReport.setAttribute("SubBlock_count", (int)sDrwBlockData.m_uiDrwBlocksSize);

		m_sReport.createSubNode("Subblock");
			{
		for (A3DUns32 ui = 0; ui < sDrwBlockData.m_uiDrwBlocksSize; ++ui)
			traverseDrawingBlock(sDrwBlockData.m_ppDrwBlocks[ui]);
			}
		m_sReport.closeSubNode();
		A3DDrawingBlockBasicGet(NULL,&sDrwBlockData);
	}
	m_sReport.closeSubNode();
}

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

	A3DEEntityType eType = kA3DTypeUnknown;
	iRet = A3DEntityGetType(pEntityReference, &eType);
	if (iRet != A3D_SUCCESS)
	{
		HXmlElement* entityreference = new HXmlElement("A3DEntityGetType");
		entityreference->SetAttribute("error", iRet);
		m_sReport.addNode(entityreference);
	}

	if (eType == kA3DTypeMiscReferenceOnTopology)
	{
		m_sReport.addNode(traverseReferenceOnTopology(pEntityReference));
	}
	else if (eType == kA3DTypeMiscReferenceOnCsysItem)
	{
		m_sReport.addNode(traverseA3DMiscReferenceOnCsysItem(pEntityReference));
	}
	else if (eType == kA3DTypeFRMFeature)
	{
		m_sReport.addNode(traverseRootBaseData(pEntityReference));
	}
	else if (eType == kA3DTypeDrawingBlockBasic)
	{
		traverseDrawingBlock((const A3DDrawingBlockBasic *)pEntityReference);
	}
	else
	{
		m_sReport.addNode(traverseRootBaseData(pEntityReference));

		if (eType == kA3DTypeRiPolyBrepModel)
		{
			m_sReport.addNode(traverseA3DMiscReferenceOnTessData(pEntityReference));
		}
		else if (eType == kA3DTypeRiPlane)
		{
			A3DMiscMarkupLinkedItem* pLinkedItem = NULL;
			A3DRiPlaneSupportGet((const A3DRiPlane*)pEntityReference, &pLinkedItem);
			if (pLinkedItem)
			{
				m_sReport.createSubNode("SUPPORT");
				{
					iRet = A3DMiscEntityReferenceGet(pLinkedItem, &sData);
					if (iRet != A3D_SUCCESS || sData.m_pEntity == NULL)
					{
						HXmlElement* entityreference = new HXmlElement("A3DMiscEntityReferenceGet");
						entityreference->SetAttribute("error", iRet);
						m_sReport.addNode(entityreference);
					}
					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");
				{
					iRet = A3DMiscEntityReferenceGet(pLinkedItem, &sData);
					if (iRet != A3D_SUCCESS || sData.m_pEntity == NULL)
					{
						HXmlElement* entityreference = new HXmlElement("A3DMiscEntityReferenceGet");
						entityreference->SetAttribute("error", iRet);
						m_sReport.addNode(entityreference);
					}
					traverseEntityReference(sData.m_pEntity);
					m_sReport.closeSubNode();
				}
			}
		}
	}
	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;
	default:
		m_sReport.setAttribute("Type", "Unknown");
		break;
	}
	if (sConnector.m_sData.m_pReference)
		traverseEntityReference(sConnector.m_sData.m_pReference);
	else
	{
		HXmlElement* entityreference = new HXmlElement("A3DFRMFeatureLinkedItemConnector");
		entityreference->SetAttribute("error", "no reference");
		m_sReport.addNode(entityreference);
	}

	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_None:
	{
		m_sReport.createSubNode("ROOT");
		break;
	}
	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("FEATURE_DEFINITION");
		break;
	}
	case kA3DParameterType_Definition:
	{
		m_sReport.createSubNode("DEFINITION");
		break;
	}
	case kA3DParameterType_Container:
	{
		m_sReport.createSubNode("CONTAINER");
		break;
	}
	case kA3DParameterType_ContainerInternal:
	{
		m_sReport.createSubNode("CONTAINER_INTERNAL");
		break;
	}
	case kA3DParameterType_Data:
	{
		m_sReport.createSubNode("DATA");
		break;
	}
	default:
		m_sReport.createSubNode("PARAMETER");
		break;
	}
	return A3D_SUCCESS;
}

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

HXmlElement* HXFeatureTreeReport::traverseRootBaseData(const A3DEntity* pEntity)
{
	A3DRootBaseData sRBData;
	A3D_INITIALIZE_DATA(A3DRootBaseData, sRBData);
	A3DStatus iRet2 = A3DRootBaseGet(pEntity, &sRBData);
	if (iRet2 != A3D_SUCCESS)
		return NULL;
	HXmlElement* pXmlRootBaseData = new HXmlElement("RootBaseData");
	if (sRBData.m_pcName && sRBData.m_pcName[0] != '\0')
		pXmlRootBaseData->SetAttribute("m_pcName", sRBData.m_pcName);

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


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;
}