#include "stdafx.h"
#include "TSupportFunc.h"
#include "TCoverBooleanOper.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

static void FreeBuffer(AcDbVoidPtrArray& arCurves)
{
	for (int i = 0;i < arCurves.length();i++)
	{
		AcDbEntity* pEnt = (AcDbEntity*)arCurves.at(i);
		if (pEnt != NULL)
		{
			delete pEnt;
		}
	}
	arCurves.setLogicalLength(0);	
}

AcGePoint3d TSupportFunc::Mid(AcGePoint3d ptGe1,AcGePoint3d ptGe2)
{
	return AcGePoint3d((ptGe1.x + ptGe2.x) / 2.0,(ptGe1.y + ptGe2.y) / 2.0,(ptGe1.z + ptGe2.z) / 2.0);
}

double TSupportFunc::PixelToWcs(int nPixel)
{
	ads_point ptScreenSize;
    double nViewSize;
	struct resbuf rb1,rb2;
	acedGetVar(_T("ScreenSize"), &rb1);
	acedGetVar(_T("ViewSize"), &rb2);
	nViewSize = rb2.resval.rreal;
	ads_point_set(rb1.resval.rpoint,ptScreenSize);
	
    if (ptScreenSize[1] < 1.0E-6 || nViewSize < 1.0E-6)
        return 0.0;
	
	double hight = (nViewSize / ptScreenSize[Y]) * nPixel;
    return hight;
}

AcGePoint3d TSupportFunc::Mid(AcDbCurve* pCurve)
{
	AcGePoint3d ptSta,ptEnd;
	pCurve->getStartPoint(ptSta);
	pCurve->getEndPoint(ptEnd);

	AcDbLine* pLine = AcDbLine::cast(pCurve);
	if (pLine != NULL)
	{
		return Mid(ptSta,ptEnd);
	}

	AcDbArc* pArc = AcDbArc::cast(pCurve);
	if (pArc != NULL)
	{
		AcGePoint3d ptMid = Mid(ptSta,ptEnd);
		AcGePoint3d ptCen = pArc->center();

		AcGeVector3d vt = ptEnd - ptSta;
		vt.normalize();
		vt.rotateBy(PI / 2.0,pArc->normal());
		ptSta = ptCen + pArc->radius() * 2.0 * vt;
		ptEnd = ptCen - pArc->radius() * 2.0 * vt;

		AcDbLine line(ptSta,ptEnd);

		AcGePoint3dArray pts;
		line.intersectWith(pArc,AcDb::kOnBothOperands,pts);

		if (pts.length() > 0)
			return pts.first();
	}

	//判断 pcurve的中点是否在 other 上
	double dSta = 0.0,dEnd = 0.0;
	pCurve->getStartParam(dSta);
	pCurve->getEndParam(dEnd);
	pCurve->getPointAtParam(dSta + (dEnd - dSta) / 2.0,ptSta);
	return ptSta;
}

AcDbArc* TSupportFunc::FormatArc(AcGePoint3d& ptGe1,AcGePoint3d& ptGe2,AcGePoint3d& ptGe3)
{
	AcDbArc* pArcThis = NULL;
	AcGeCircArc3d cirArc3d;
	cirArc3d.set(ptGe1,ptGe2,ptGe3);

	AcDbCircle cir;
	cir.setCenter(cirArc3d.center());
	cir.setRadius(cirArc3d.radius());
	cir.setNormal(cirArc3d.normal());

	AcGePoint3dArray arPts;
	arPts.append(ptGe1);
	arPts.append(ptGe3);

	AcDbVoidPtrArray arCurPtrs;
	cir.getSplitCurves(arPts,arCurPtrs);

	double dPara = 0.0;
	AcDbCurve* pCurve = NULL;
	for (int j = 0;j < arCurPtrs.length();j++)
	{
		pCurve = (AcDbCurve*)arCurPtrs.at(j);
		if (pCurve != NULL)
		{
			if (Acad::eOk == pCurve->getParamAtPoint(ptGe2,dPara))
			{
				AcDbArc* pArc = AcDbArc::cast(pCurve);
				if (pArc != NULL)
				{
					pArcThis = pArc;
					arCurPtrs.removeAt(j);
				}
				break;
			}
		}
	}
	FreeBuffer(arCurPtrs);
	return pArcThis;
}

// 获取垂足点
BOOL TSupportFunc::GetVerticalFootPoint(const TComplexCurve& compCurve, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint, AcGePoint3d& ptVerFoot) const
{
	BOOL bIsSuc = FALSE;

	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));
	
	double dDisToLine = 0.0,dDisOld = 10000.0;
	AcDbArc* pArc = NULL;
	AcGePoint3d ptOnLine;
	AcDbLine line;
	int nIndex = -1;
	
	// 挑选离pick点最近的线
	for (int i = 0;i < compCurve.length();i++)
	{
		el = compCurve.at(i);
		
		if (el.ptGe[1].distanceTo(el.ptGe[2]) < 1e-3) // 直线
		{
			line.setStartPoint(el.ptGe[0]);
			line.setEndPoint(el.ptGe[1]);
			
			if (line.getClosestPointTo(pickPoint, ptOnLine, Adesk::kTrue) == Acad::eOk)
			{
				ptOnLine.z = pickPoint.z;
				dDisToLine = pickPoint.distanceTo(ptOnLine);
				if (dDisOld > dDisToLine)
				{
					dDisOld = dDisToLine;
					nIndex = i;
				}
			}
		}
		else // 曲线
		{
			pArc = TCoverBooleanOper::FormatArc(el.ptGe[0],el.ptGe[1],el.ptGe[2]);
			if (pArc != NULL)
			{
				if (pArc->getClosestPointTo(pickPoint, ptOnLine, Adesk::kTrue) == Acad::eOk)
				{
					dDisToLine = pickPoint.distanceTo(ptOnLine);
					if (dDisOld > dDisToLine)
					{
						dDisOld = dDisToLine;
						nIndex = i;
					}
				}
			}
		}
	}
	
	// 找到第一次取的点到该线的垂点
	if (nIndex != -1)
	{
		el = compCurve.at(nIndex);
		
		if (el.ptGe[1].distanceTo(el.ptGe[2]) < 1e-3) // 直线
		{
			line.setStartPoint(el.ptGe[0]);
			line.setEndPoint(el.ptGe[1]);
			
			if (line.getClosestPointTo(lastPoint, ptOnLine, Adesk::kTrue) == Acad::eOk)
			{
				ptVerFoot = ptOnLine;
				bIsSuc = TRUE;
			}
		}
		else // 曲线
		{
			pArc = TCoverBooleanOper::FormatArc(el.ptGe[0],el.ptGe[1],el.ptGe[2]);
			if (pArc != NULL)
			{
				if (pArc->getClosestPointTo(lastPoint, ptOnLine, Adesk::kTrue) == Acad::eOk)
				{
					ptVerFoot = ptOnLine;
					bIsSuc = TRUE;
				}
			}
		}
	}

	return bIsSuc;
}

// 获取最近点
BOOL TSupportFunc::GetNearestPoint(const TComplexCurve& compCurve, const AcGePoint3d& pickPoint, AcGePoint3d& ptNear) const
{
	BOOL bFind = FALSE;
	AcDbLine line;
	AcDbArc* pArc = NULL;
	double dDisToLine = 0.0,dDisOld = 10000.0;
	AcGePoint3d ptOnLine;

	// 挑选离pick点最近的线
	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));
	
	for (int i = 0;i < compCurve.length();i++)
	{
		el = compCurve.at(i);
		
		if (el.ptGe[1].distanceTo(el.ptGe[2]) < 1e-3) // 直线
		{
			line.setStartPoint(el.ptGe[0]);
			line.setEndPoint(el.ptGe[1]);
			
			if (line.getClosestPointTo(pickPoint, ptOnLine) == Acad::eOk)
			{
				ptOnLine.z = pickPoint.z;
				dDisToLine = pickPoint.distanceTo(ptOnLine);
				if (dDisOld > dDisToLine)
				{
					dDisOld = dDisToLine;
					ptNear = ptOnLine;
					bFind = TRUE;
				}
			}
		}
		else // 曲线
		{
			pArc = TCoverBooleanOper::FormatArc(el.ptGe[0],el.ptGe[1],el.ptGe[2]);
			if (pArc != NULL)
			{
				if (pArc->getClosestPointTo(pickPoint, ptOnLine) == Acad::eOk)
				{
					dDisToLine = pickPoint.distanceTo(ptOnLine);
					if (dDisOld > dDisToLine)
					{
						dDisOld = dDisToLine;
						ptNear = ptOnLine;
						bFind = TRUE;
					}
				}
			}
		}
	}

	return bFind;
}

// abc@bcd@ : sRetData = abc,sSrc = bcd@
BOOL TSupportFunc::SplitString(LPCTSTR pszKey, CString& sRetData, CString& sSrc) const
{
	sRetData.Empty();
	if (sSrc.IsEmpty() || pszKey == NULL)
	{
		return FALSE;
	}

	int nPos = sSrc.Find(pszKey, 0);
	if (nPos > 0)
	{
		sRetData = sSrc.Left(nPos);
		sSrc = sSrc.Right(sSrc.GetLength() - nPos - 1);

		return TRUE;
	}
	else
	{
		sRetData = sSrc;
		sRetData.TrimLeft();
		sRetData.TrimRight();
		if (!sRetData.IsEmpty())
		{
			sSrc.Empty();
			return TRUE;
		}
	}

	return FALSE;
}

// abc@bcd@ = 2;
int  TSupportFunc::GetSplitedCount(LPCTSTR pszKey, LPCTSTR pszSrc) const
{
	int nCount = 0;

	CString sTmp;
	CString sSrc(pszSrc);
	while (SplitString(pszKey, sTmp, sSrc))
	{
		nCount++;
	}

	return nCount;
}

int  TSupportFunc::GetClapboardDimension(TDbXDataMap* pXdMap, AcGeDoubleArray& arDimen,LPCTSTR pszClapType) const
{
	arDimen.setLogicalLength(0);

	if (pXdMap != NULL)
	{
		CString scbData,sData,sOffset;
		if(pXdMap->GetAt(pszClapType, scbData))
		{
			while (SplitString(KEY_CLP_MAIN_KEY,sData,scbData))
			{
				if (SplitString(KEY_CLP_SUB_KEY,sOffset,sData))
				{
					arDimen.append(_tstof(sOffset));
				}
			}

			if (arDimen.length() > 0)
			{
				arDimen.removeLast();
			}
		}
	}
	return arDimen.length();
}