#include "stdafx.h"
#include "gecsint.h"
#include "brbrep.h"
#include "brbftrav.h"
#include "brfltrav.h"
#include "brloop.h"
#include "brface.h"
#include "bredge.h"
#include "brletrav.h"
#include "brmesh.h"
#include "brm2dctl.h"
#include "brmesh2d.h"
#include "brmetrav.h"
#include "brentrav.h"
#include "brnode.h"
#include "breptools.h"
#include "brhit.h"

const double kPi = 3.14159265358979323846;
const double kTwoPi = 6.28318530717958647692;
const double kHalfPi = 1.57079632679489661923;
const double kRad2Deg = 57.295779513082323;
const double kDeg2Rad = 0.0174563292519943295;

#define __TRANS_ENTIEY_ID_(id) case id: return #id
namespace
{
	CString transEntityId(AcGe::EntityId &type)
	{
		switch (type)
		{
			__TRANS_ENTIEY_ID_(kEntity2d);
			__TRANS_ENTIEY_ID_(kEntity3d);
			__TRANS_ENTIEY_ID_(kPointEnt2d);
			__TRANS_ENTIEY_ID_(kPointEnt3d);
			__TRANS_ENTIEY_ID_(kPosition2d);
			__TRANS_ENTIEY_ID_(kPosition3d);
			__TRANS_ENTIEY_ID_(kPointOnCurve2d);
			__TRANS_ENTIEY_ID_(kPointOnCurve3d);
			__TRANS_ENTIEY_ID_(kPointOnSurface);
			__TRANS_ENTIEY_ID_(kBoundedPlane);
			__TRANS_ENTIEY_ID_(kCircArc2d);
			__TRANS_ENTIEY_ID_(kCircArc3d);
			__TRANS_ENTIEY_ID_(kConic2d);
			__TRANS_ENTIEY_ID_(kConic3d);
			__TRANS_ENTIEY_ID_(kCurve2d);
			__TRANS_ENTIEY_ID_(kCurve3d);
			__TRANS_ENTIEY_ID_(kEllipArc2d);
			__TRANS_ENTIEY_ID_(kEllipArc3d);
			__TRANS_ENTIEY_ID_(kLine2d);
			__TRANS_ENTIEY_ID_(kLine3d);
			__TRANS_ENTIEY_ID_(kLinearEnt2d);
			__TRANS_ENTIEY_ID_(kLinearEnt3d);
			__TRANS_ENTIEY_ID_(kLineSeg2d);
			__TRANS_ENTIEY_ID_(kLineSeg3d);
			__TRANS_ENTIEY_ID_(kPlanarEnt);
			__TRANS_ENTIEY_ID_(kPlane);
			__TRANS_ENTIEY_ID_(kRay2d);
			__TRANS_ENTIEY_ID_(kRay3d);
			__TRANS_ENTIEY_ID_(kSurface);
			__TRANS_ENTIEY_ID_(kSphere);
			__TRANS_ENTIEY_ID_(kCylinder);
			__TRANS_ENTIEY_ID_(kTorus);
			__TRANS_ENTIEY_ID_(kCone);
			__TRANS_ENTIEY_ID_(kSplineEnt2d);
			__TRANS_ENTIEY_ID_(kPolyline2d);
			__TRANS_ENTIEY_ID_(kAugPolyline2d);
			__TRANS_ENTIEY_ID_(kNurbCurve2d);
			__TRANS_ENTIEY_ID_(kDSpline2d);
			__TRANS_ENTIEY_ID_(kCubicSplineCurve2d);
			__TRANS_ENTIEY_ID_(kSplineEnt3d);
			__TRANS_ENTIEY_ID_(kPolyline3d);
			__TRANS_ENTIEY_ID_(kAugPolyline3d);
			__TRANS_ENTIEY_ID_(kNurbCurve3d);
			__TRANS_ENTIEY_ID_(kDSpline3d);
			__TRANS_ENTIEY_ID_(kCubicSplineCurve3d);
			__TRANS_ENTIEY_ID_(kTrimmedCrv2d);
			__TRANS_ENTIEY_ID_(kCompositeCrv2d);
			__TRANS_ENTIEY_ID_(kCompositeCrv3d);
			__TRANS_ENTIEY_ID_(kExternalSurface);
			__TRANS_ENTIEY_ID_(kNurbSurface);
			__TRANS_ENTIEY_ID_(kTrimmedSurface);
			__TRANS_ENTIEY_ID_(kOffsetSurface);
			__TRANS_ENTIEY_ID_(kEnvelope2d);
			__TRANS_ENTIEY_ID_(kCurveBoundedSurface);
			__TRANS_ENTIEY_ID_(kExternalCurve3d);
			__TRANS_ENTIEY_ID_(kExternalCurve2d);
			__TRANS_ENTIEY_ID_(kSurfaceCurve2dTo3d);
			__TRANS_ENTIEY_ID_(kSurfaceCurve3dTo2d);
			__TRANS_ENTIEY_ID_(kExternalBoundedSurface);
			__TRANS_ENTIEY_ID_(kCurveCurveInt2d);
			__TRANS_ENTIEY_ID_(kCurveCurveInt3d);
			__TRANS_ENTIEY_ID_(kBoundBlock2d);
			__TRANS_ENTIEY_ID_(kBoundBlock3d);
			__TRANS_ENTIEY_ID_(kOffsetCurve2d);
			__TRANS_ENTIEY_ID_(kOffsetCurve3d);
			__TRANS_ENTIEY_ID_(kPolynomCurve3d);
			__TRANS_ENTIEY_ID_(kBezierCurve3d);
			__TRANS_ENTIEY_ID_(kObject);
			__TRANS_ENTIEY_ID_(kFitData3d);
			__TRANS_ENTIEY_ID_(kHatch);
			__TRANS_ENTIEY_ID_(kTrimmedCurve2d);
			__TRANS_ENTIEY_ID_(kTrimmedCurve3d);
			__TRANS_ENTIEY_ID_(kCurveSampleData);
			__TRANS_ENTIEY_ID_(kEllipCone);
			__TRANS_ENTIEY_ID_(kEllipCylinder);
			__TRANS_ENTIEY_ID_(kIntervalBoundBlock);
			__TRANS_ENTIEY_ID_(kClipBoundary2d);
			__TRANS_ENTIEY_ID_(kExternalObject);
			__TRANS_ENTIEY_ID_(kCurveSurfaceInt);
			__TRANS_ENTIEY_ID_(kSurfaceSurfaceInt);
			__TRANS_ENTIEY_ID_(kHelix);
		default:
			break;
		}
		return _T("");
	}

	CString transLoopType(AcBr::LoopType &type)
	{
		switch (type)
		{
			__TRANS_ENTIEY_ID_(AcBr::kLoopUnclassified);
			__TRANS_ENTIEY_ID_(AcBr::kLoopExterior);
			__TRANS_ENTIEY_ID_(AcBr::kLoopInterior);
			__TRANS_ENTIEY_ID_(AcBr::kLoopWinding);
		default:
			break;
		}
		return _T("");
	}

	CString transAcBrError(AcBr::ErrorStatus er)
	{
		switch (er)
		{
			__TRANS_ENTIEY_ID_(AcBr::eOk);
			__TRANS_ENTIEY_ID_(AcBr::eNotImplementedYet);
			__TRANS_ENTIEY_ID_(AcBr::eNotApplicable);
			__TRANS_ENTIEY_ID_(AcBr::eInvalidInput);
			__TRANS_ENTIEY_ID_(AcBr::eOutOfMemory);
			__TRANS_ENTIEY_ID_(Acad::eUnrecoverableErrors);
			__TRANS_ENTIEY_ID_(AcBr::eWrongObjectType);
			__TRANS_ENTIEY_ID_(AcBr::eWrongSubentityType);
			__TRANS_ENTIEY_ID_(AcBr::eNullObjectId);
			__TRANS_ENTIEY_ID_(AcBr::eNullSubentityId);
			__TRANS_ENTIEY_ID_(Acad::eWrongDatabase);
			__TRANS_ENTIEY_ID_(AcBr::eMissingGeometry);
			__TRANS_ENTIEY_ID_(AcBr::eMissingSubentity);
			__TRANS_ENTIEY_ID_(Acad::eAmbiguousOutput);
			__TRANS_ENTIEY_ID_(AcBr::eBrepChanged);
			__TRANS_ENTIEY_ID_(AcBr::eUnsuitableTopology);
			__TRANS_ENTIEY_ID_(AcBr::eDegenerateTopology);
			__TRANS_ENTIEY_ID_(AcBr::eUninitialisedObject);
		default:
			break;
		}
		return _T("");
	}

	bool intersectWidth(AcBrEntity &brepEnt
	, const AcGeLinearEnt3d &line
	, AcGePoint3dArray &ar)
	{
		Adesk::UInt32 numHitsFound = 0;
		AcBrHit *hits = NULL;
		AcGePoint3d pt;
		if (brepEnt.getLineContainment(line, 0, numHitsFound, hits) == AcBr::eOk)
		{
			for (int i(0); i < numHitsFound; ++i)
			{
				AcBrEntity *entityAssociated = NULL;
				if (hits[i].getEntityAssociated(entityAssociated) == AcBr::eOk)
				{
					if (brepEnt.isEqualTo(entityAssociated))
					{
						if (hits[i].getPoint(pt) == AcBr::eOk)
							ar.append(pt);
					}
				}
			}
		}
		delete[] hits;
		return numHitsFound != 0;
	}

}

bool BrepTools::intersectWith_by_whole(AcDb3dSolid *pSolid
	, const AcGeLinearEnt3d &line
	, AcGePoint3dArray &ar)
{
	AcBrBrep brepEntity;
	if (brepEntity.set((const AcDbEntity &)*pSolid) != AcBr::eOk) return false;
	return ::intersectWidth(brepEntity, line, ar);
}

bool BrepTools::intersectWith_by_loop_face(AcDb3dSolid *pSolid
	, const AcGeLinearEnt3d &line
	, AcGePoint3dArray &ar)
{
	AcBrBrep brepEntity;
	if (brepEntity.set((const AcDbEntity &)*pSolid) != AcBr::eOk) return false;

	AcBr::ErrorStatus returnValue = AcBr::eOk;
	AcBrBrepFaceTraverser brepFaceTrav;
	AcBrFace brepFace;

	while (!brepFaceTrav.done() && (returnValue == AcBr::eOk))
	{
		returnValue = brepFaceTrav.getFace(brepFace);
		if (returnValue != AcBr::eOk) return false;

		intersectWidth(brepFace, line, ar);

		returnValue = brepFaceTrav.next();
		if (returnValue != AcBr::eOk) return false;
	}

	return !ar.isEmpty();
}

bool BrepTools::relationWith(const AcDbRegion *pReg
	, const AcGePoint3d &pt
	, AcGe::PointContainment &iResult)
{
	AcBrBrep brepEntity;
	AcBrEntity *pBrepResult(NULL);
	if (brepEntity.set((const AcDbEntity &)*pReg) != AcBr::eOk) return false;

	if (!brepEntity.getPointContainment(pt, iResult, pBrepResult) == Acad::eOk) return false;

	if (pBrepResult != NULL)
	{
		delete pBrepResult;
		pBrepResult = NULL;
	}

	return true;
}

void BrepTools::init()
{
	int a = 0;
	return;
}

void BrepTools::listInfo3dSolid(const AcDb3dSolid *pSolid)
{
	AcBrBrep brep;
	if (brep.set((const AcDbEntity &)*pSolid) != AcBr::eOk) return;

	AcBrBrepFaceTraverser bft;
	AcBrFaceLoopTraverser bflt;
	AcBrLoopEdgeTraverser bet;
	AcBr::ErrorStatus bs = bft.setBrep(brep);
	if (bs != AcBr::eOk) return;

	AcGe::EntityId type;
	AcBrFace bf;
	AcBr::ErrorStatus es;
	for (int f(0); !bft.done(); bft.next(), ++f)
	{
		if ((es = bft.getFace(bf)) != Acad::eOk)
		{
			acutPrintf(_T("\n face%d FaceTraverser getFace error: %s"), f, transAcBrError(es));
			continue;
		}

		if ((es = bf.getSurfaceType(type)) == AcBr::eOk)
		{
			acutPrintf(_T("\n face%d type: %s"), f, transEntityId(type));
		}
		else
		{
			acutPrintf(_T("\n face%d getSurfaceType error: %s"), f, transAcBrError(es));
			continue;
		}
		
		if ((es = bflt.setFace(bf)) != AcBr::eOk)
		{
			acutPrintf(_T("\n face%d FaceLoopTraverser setFace error: %s"), f, transAcBrError(es));
			continue;
		}
		if ((es = bet.setLoop(bflt)) != Acad::eOk)
		{
			acutPrintf(_T("\n face%d LoopEdgeTraverser setLoop error: %s"), f, transAcBrError(es));
			continue;
		}
		
		for (int e(0); !bet.done(); bet.next(), ++e)
		{
			AcBrEdge edge;
			if ((es = bet.getEdge(edge)) != AcBr::eOk)
			{
				acutPrintf(_T("\n\t edge%d getEdge error:%s"), transAcBrError(es));
				continue;
			}

			AcBrLoop brLoop;
			if ((es = bet.getLoop(brLoop)) != AcBr::eOk)
			{
				acutPrintf(_T("\n\t loop%d getLoop error:%s"), transAcBrError(es));
				continue;
			}

			AcBr::LoopType ltype = AcBr::kUnclassified;
			if ((es = brLoop.getType(ltype)) == AcBr::eOk)
			{
				acutPrintf(_T("\n\t loop%d type: %s"), e, transLoopType(ltype));
			}
			else
			{
				acutPrintf(_T("\n\t loop%d get loop type: %s"), e, transAcBrError(es));
				continue;
			}

			if ((es = edge.getCurveType(type)) == AcBr::eOk)
			{
				acutPrintf(_T("\n\t edge%d curve type: %s"), e, transEntityId(type));
			}
			else
			{
				acutPrintf(_T("\n\t edge%d get edge curve type: %s"), e, transAcBrError(es));
				continue;
			}
		}
	}
}

void BrepTools::intersectSolid(const AcDb3dSolid *pSolid
	, const AcGeLinearEnt3d &line
	, AcGePoint3dArray &ar)
{
	AcBrBrep brep;
	AcBr::ErrorStatus es;
	if ((es = brep.set(*pSolid)) != AcBr::eOk)
	{
		acutPrintf(_T("\n brep set error:%s"), transAcBrError(es));
		return;
	}
	intersectWidth(brep, line, ar);
}