// XWall.cpp: implementation of the XWall class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

//#include <arxtools.h>

#include "tapi.h"
#include "XWall.h"
#include "XBlock.h"
#include "TelDef.h"

#define XD_WIN      _T("wpline")            // sr add  app  reg
#define XD_WINTHICK _T("wthick")            // sr add  app  reg

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

#define MAXWALLTHICK 720

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

XWall::XWall()
{
	m_bFirst = TRUE;
}

XWall::~XWall()
{

}

XWall::XWall(Entity ent)
{
	m_bFirst = TRUE;
	m_ent = ent;
	IsArcWall();
}

BOOL XWall::IsArcWall()
{
	if(m_ent.Is(_T("ARC"))){
		XArc arc(m_ent);
		arc.GetStartPoint(m_ptStart);
		arc.GetEndPoint(m_ptEnd);
	//	arc.GetPoints(m_ptStart, m_ptEnd);
		m_ent.GetData(10, m_ptCen);
		m_ent.GetData(40, &m_nRadius);
		return TRUE;
	}
	else{
		XLine line(m_ent, 1);
		m_ptStart = line.StartPoint();
		m_ptEnd = line.EndPoint();
		m_nAngle = ads_angle(m_ptStart, m_ptEnd);
	}
	return FALSE;
}

 
Entity XWall::GetNextWallLine(XPoint ptPick)
{
	XPoint ptUcs = Wcs2Ucs(ptPick);
	PickSet ssSel(SS_FREE);
	if(IsArcWall())
		GetPointPickSet(ptUcs, ssSel, RBList(RTDXF0, _T("ARC"), 8, LAY_WALL, NULL), MAXWALLTHICK/2);
	else
		GetPointPickSet(ptUcs, ssSel, RBList(RTDXF0, _T("LINE"), 8, LAY_WALL, NULL), MAXWALLTHICK/2);
	if(ssSel.Length() < 2){
		return Entity();
	}	

	ssSel -= m_ent;
	long len = ssSel.Length();
	for(long i=0;i<len;i++){
		Entity entWall = ssSel[i];
		if(m_ent.Is(_T("ARC")) && entWall.Is(_T("ARC"))){
			XPoint ptCen;
			double Radius;
			entWall.GetData(10, ptCen);
			entWall.GetData(40, &Radius);
			if(ptCen == m_ptCen){
				return entWall;
			}
		}
		else if(m_ent.Is(_T("LINE")) && entWall.Is(_T("LINE"))){
			XLine l1(m_ent, 1);
			XLine l2(entWall, 1);
			if(l2.GetLength() < MAXWALLTHICK/2) //接门窗墙
				continue;
			double ang1 = ads_angle(l1.StartPoint(), l1.EndPoint());
			double ang2 = ads_angle(l2.StartPoint(), l2.EndPoint());
			if((l1.StartPoint() & l2 ) == PR_EXTEND)
				continue;
			if(fabs(ang1 - ang2) < 0.01 || fabs(fabs(ang1 - ang2) - PI) < 0.01 || fabs(fabs(ang1 - ang2) - PI*2) < 0.01)
				return entWall;
		}
	}
	return Entity();
}

Entity XWall::GetWinFromWall(Entity ent, XPoint pt)
{
	RBList rbMask = ads_buildlist( -4, _T("<or"),
	   -4, _T("<and"), RTDXF0, _T("INSERT"), 8, LAY_WIN, -4, _T("and>"),  
	   -4, _T("<and"), RTDXF0, _T("INSERT"), 8, LAY_COLU, -4, _T("and>"),  
	   -4, _T("or>"), NULL);

	PickSet ss(SS_FREE);
	GetPointPickSet(pt, ss, rbMask, MAXWALLTHICK / 2);
	long len = ss.Length();
	if(ss.Length() < 1 )
		return Entity();
	else if(ss.Length() == 1 )
		return ss[0L];
	double nMinDist = -1.0;
	long Index = -1;
	for (long i=0;i<len;i++){
		Entity entBlk = ss[i];
		XPoint ptIns;
		entBlk.GetData(10, &ptIns);
		double nDist = ads_distance(pt, ptIns);
		if(nMinDist > nDist || nMinDist < 0) {
			nMinDist = nDist;
			Index = i;
		}
		
	}
	return ss[Index]; 
	
}

BOOL XWall::GetWinData(Entity entWin, double &nWallThick, XPointList &lstPt)
{
	AcDbObjectId eId;
	AcDbEntity *pEnt;
	acdbGetObjectId(eId, entWin);
	if(!eId)
		return FALSE;
	acdbOpenObject(pEnt, eId, AcDb::kForRead);

	resbuf *pxData = pEnt->xData(XD_WIN);
	if(!pxData){
		pEnt->close();                    //根本没有扩展数据！
		return FALSE;
	}
	resbuf *pNext = pxData->rbnext;
	XBlock myBlock(entWin);
	while(pNext) {
		AcGePoint3d ptBlk;
		XPoint xpoint;
		if(pNext->restype == 1010) {
			xpoint = pNext->resval.rpoint;
			ptBlk = xpoint;
			ptBlk = ptBlk.transformBy(myBlock.GetMatrix3d());
			lstPt.NewAppend(ptBlk);
		}
		pNext = pNext->rbnext;
	}
	ads_relrb(pxData);
	resbuf *pxData2 = pEnt->xData(XD_WINTHICK);
	if(!pxData2){
		pEnt->close();                    //根本没有扩展数据！
		return FALSE;
	}
	resbuf *pNext2 = pxData2->rbnext;
	if(pNext2 && pNext2->restype == 1040) 
		nWallThick = pNext2->resval.rreal;
	ads_relrb(pxData2);

	pEnt->close();
	return TRUE;
}

extern BOOL Is2LineOnLine(XLine line1, XLine line2);
extern BOOL Is2ArcOnArc(XArc arc1, XArc arc2);

Entity XWall::GetWinNextWall(Entity entWin, Entity FirstWall, XPoint &ptStart,	XPoly2D &xpoly1)
{
	PickSet ssSel(SS_FREE);
	ads_point lowPt, upPt, lowPt2, upPt2;
	lowPt[2] = upPt[2] = lowPt2[2] = upPt2[2] = 0;
	entWin.GetExtend(lowPt, upPt);
	lowPt[0] -= 100;
	lowPt[1] -= 100;
	upPt[0] += 100;
	upPt[1] += 100;

	lowPt2[0] = upPt[0];
	lowPt2[1] = lowPt[1];
 	upPt2[0] = lowPt[0];
	upPt2[1] = upPt[1];
 
 	RBList rbMask = ads_buildlist( -4, _T("<or"),
	   -4, _T("<and"), RTDXF0, _T("LINE"), 8, LAY_WALL, -4, _T("and>"),  
	   -4, _T("<and"), RTDXF0, _T("ARC"), 8, LAY_WALL, -4, _T("and>"),  
	   -4, _T("or>"), NULL);
	ssSel.Get(_T("C"), upPt, lowPt, rbMask);
 	if(ssSel.Length() < 2)
		return Entity();
 
	ssSel -= FirstWall;
	long len = ssSel.Length();
	for(long i=0;i<len;i++){
		Entity entTmp = ssSel[i];
		if(FirstWall.Is(_T("LINE")) && entTmp.Is(_T("LINE"))){
			XLine fLine(FirstWall);
			XLine nLine(entTmp);
			if(Is2LineOnLine(fLine, nLine)){
				if(ads_distance(ptStart, nLine.StartPoint()) > ads_distance(ptStart, nLine.EndPoint()))
					ptStart = nLine.EndPoint();
				else
					ptStart = nLine.StartPoint();
				return entTmp;
			}
		}
		else if(FirstWall.Is(_T("ARC")) && entTmp.Is(_T("ARC"))){
			XPoint ptS, ptE;
			XArc fArc(FirstWall);
			XArc nArc(entTmp);
			if(Is2ArcOnArc(fArc, nArc)){
				nArc.GetStartPoint(ptS);
				nArc.GetEndPoint(ptE);
			//	nArc.GetPoints(ptS, ptE);
				if(ads_distance(ptStart, ptS) > ads_distance(ptStart, ptE))
					ptStart = ptE;
				else
					ptStart = ptS;
				return entTmp;
			}
		}
	}
	XPointList lstPt;
	double nWallThick = 0.0;
	if(!GetWinData(entWin, nWallThick, lstPt))
		return Entity();

	XPoly2D xpoly;
	for(int j=0;j<lstPt.Length();j++)
		xpoly.AppendNode(*lstPt[j]);
	
	XPoint ptTEMP;
	for(j=0;j<2;j++){
		xpoly.Offset(nWallThick / 2, xpoly1);
		XPoint ptTmp1, ptTmp2;
		ptTmp1 = *xpoly1[0];
		ptTmp2 = *xpoly1[xpoly1.Length() - 1];
		if(ptTmp1 == ptStart || ptTmp2 == ptStart){
			if(ptTmp1 == ptStart) ptTEMP = ptTmp2;
			if(ptTmp2 == ptStart) ptTEMP = ptTmp1;
			break;
		}
		nWallThick = -nWallThick;
	}
	PickSet sspt(SS_FREE);
	GetPointPickSet(ptTEMP, sspt, rbMask, 2);
	len = sspt.Length();
	for(i=0;i<len;i++){
		Entity entCul = sspt[i];
		if(entCul.Is(_T("ARC")))
			return Entity();
		XLine line(entCul);
		if(line.GetLength() == nWallThick)
			break;
		if(line.StartPoint() == ptTEMP || line.EndPoint() == ptTEMP){
			if(line.StartPoint() == ptTEMP) ptStart = line.StartPoint();
			if(line.EndPoint() == ptTEMP) ptStart = line.EndPoint();
			return entCul;
		}
	}

	return Entity();
}

Entity XWall::GetWallFromPt(Entity ent, XPoint pt)
{
	RBList rbMask = ads_buildlist( -4, _T("<or"),
	   -4, _T("<and"), RTDXF0, _T("LINE"), 8, LAY_WALL, -4, _T("and>"),  
	   -4, _T("<and"), RTDXF0, _T("ARC"), 8, LAY_WALL, -4, _T("and>"),  
	   -4, _T("or>"), NULL);
	PickSet ssTemp(SS_FREE);
	GetPointPickSet(pt, ssTemp, rbMask, 2);
	int len = ssTemp.Length();
	if(ssTemp.Length() < 2){
		return Entity();
	}
	ssTemp -= ent;
	if(len == 2)
		return ssTemp[0L];
	for(long i=0;i<len - 1;i++){
		Entity entCul = ssTemp[i];
		XPoint ptStart, ptEnd;
		GetWire2Point(entCul, ptStart, ptEnd);
		if(ptStart == pt || ptEnd == pt)
			return entCul;
	}
	return ssTemp[0L];

}

BOOL XWall::IsEndWall(Entity ent)
{
	XPoint ptStart, ptEnd;
	GetWire2Point(ent, ptStart, ptEnd);
	Entity ent1 = GetWallFromPt(ent, ptStart);
	Entity ent2 = GetWallFromPt(ent, ptEnd);
	if(!ent1 || !ent2)
		return FALSE;
	if(ent1.Is(_T("LINE")) && ent2.Is(_T("LINE"))){
		XLine line1(ent1, 1);
		XLine line2(ent2, 1);
		double ang1 = ads_angle(line1.StartPoint(), line1.EndPoint());
		double ang2 = ads_angle(line2.StartPoint(), line2.EndPoint());
		if(fabs(ang1 - ang2) < 0.1 || fabs(fabs(ang1 - ang2) - PI) < 0.1)
			return TRUE;
	}
	else if(ent1.Is(_T("ARC")) && ent2.Is(_T("ARC"))){
		XArc arc1(ent1);
		XArc arc2(ent2);
		if(arc1.GetCenterPt() == arc2.GetCenterPt())
			return TRUE;
	}
	return FALSE;
}

//返回TRUE:  搜索到断墙,  FALSE: 封闭墙
BOOL XWall::DoSearch(XPoint pt, PickSet &ss)
{
	Entity ent = m_ent;
	RBList rbMask = ads_buildlist( -4, _T("<or"),
	   -4, _T("<and"), RTDXF0, _T("LINE"), 8, LAY_WALL, -4, _T("and>"),  
	   -4, _T("<and"), RTDXF0, _T("ARC"), 8, LAY_WALL, -4, _T("and>"),  
	   -4, _T("or>"), NULL);

	while(1){
		PickSet ssTemp(SS_FREE);
		Entity entTemp = ent;
		XPoint ptStart, ptEnd;
		XPoly2D xpoly;
		GetPointPickSet(pt, ssTemp, rbMask, 10);
		int iLen = ssTemp.Length();

		if(ssTemp.Length() < 1)
			break;
	  
		if(ssTemp.Length() == 1){                        //1:墙到头  2:连柱子
			Entity entWin = GetWinFromWall(ent, pt);
			if(!!entWin){
				ent = GetWinNextWall(entWin, ent, pt, xpoly);
				if(!ent){
					AppendTail(pt);
					return TRUE;
				}
			}
			else
				break;
		}
		else if(ssTemp.Length() >= 2){
			if(ssTemp.Length() == 2){         //1:墙到头  2:墙转弯
				ssTemp -= ent;
				ent = ssTemp[0L];
			}
			else {                            //遇到超短墙
				ssTemp -= ent;
				for(long j=0;j<ssTemp.Length();j++){
					Entity entCul = ssTemp[j];
					XPoint ptStart, ptEnd;
					GetWire2Point(entCul, ptStart, ptEnd);
					if(ptStart == pt || ptEnd == pt){
						ent = entCul;
						break;
					}
				}

			}

			XCurveSegment seg(ent);
			if(seg.GetLength() < MAXWALLTHICK && IsEndWall(ent)){//到墙末端
				XCurveSegment seg(ent);
				XPoint ptMid = seg.MidPoint();
				Entity entWin = GetWinFromWall(ent, ptMid);
				if(!!entWin){
					ent = GetWinNextWall(entWin, entTemp, pt, xpoly);
					if(!ent){
						AppendTail(pt);
						return TRUE;
					}
					else{
						if(!!xpoly){ //转角窗
						 
							int lenPoly = xpoly.Length();
							for(int ii=1;ii<lenPoly;ii++){
								if(*xpoly[0] == pt)
									m_ptPolyEnd = *xpoly[lenPoly - ii];
								else if(*xpoly[lenPoly - 1] == pt)
  									m_ptPolyEnd = *xpoly[ii];
								XCurveSegment seg;
								XLine line(m_ptPolyStart, m_ptPolyEnd, LS_FINITE);
								seg = line;
 								XPoint ptStartm, ptEndm;
								GetWire2Point(m_ent, ptStartm, ptEndm);
								if(ptEndm == m_ptPolyStart)
									ptFirstTemp = m_ptPolyEnd;
								else{
									m_lstSeg.Append(new XCurveSegment(seg));
								}
								m_ptPolyStart = m_ptPolyEnd; 
							}
						}
					}
				}		
				else{
					AppendTail(pt);
					return TRUE;
				}
			}
			else{
			 
  				m_ptPolyEnd = pt;
				XCurveSegment seg;
				if(entTemp.Is(_T("LINE"))){
					XLine line(m_ptPolyStart, m_ptPolyEnd, LS_FINITE);
					seg = line;
				}
				else if(entTemp.Is(_T("ARC"))){
					XArc aTemp(entTemp);
					XPoint ptMidTemp;
					aTemp.MidPoint(ptMidTemp);
					XArc arc(m_ptPolyStart, ptMidTemp, m_ptPolyEnd);
					seg = arc;
				}
				XPoint ptStartm, ptEndm;
				GetWire2Point(m_ent, ptStartm, ptEndm);
				if(ptEndm == m_ptPolyStart)
					ptFirstTemp = m_ptPolyEnd;
				else{
					m_lstSeg.Append(new XCurveSegment(seg));
				}
				
				m_ptPolyStart = m_ptPolyEnd; 
			}
		} 

		if(m_ent == ent){
			AppendTail(pt);
			return FALSE;
		}
		ss += ent;
		GetWire2Point(ent, ptStart, ptEnd);
		if(ptStart == pt)
			pt = ptEnd;
		else
			pt = ptStart;
	 
	 
	}
	return TRUE;
}

void XWall::AppendTail(XPoint pt)
{
  	m_ptPolyEnd = pt;
	XCurveSegment seg;
	if(m_ent.Is(_T("LINE"))){
		XLine line(m_ptPolyStart, ptFirstTemp, LS_FINITE);
		seg = line;
	}
	else if(m_ent.Is(_T("ARC"))){
		XArc aTemp(m_ent);
		XPoint ptMidTemp;
		aTemp.MidPoint(ptMidTemp);
		XArc arc(m_ptPolyStart, ptMidTemp, ptFirstTemp);
		seg = arc;
	}
	m_lstSeg.Append(new XCurveSegment(seg));
}

void XWall::SearchAllWallLine(PickSet &ss)
{
	XPoint ptStart, ptEnd;
	GetWire2Point(m_ent, ptStart, ptEnd);
	m_ptPolyStart = ptEnd;
	ss += m_ent;
	if(DoSearch(ptStart, ss)){
		m_bFirst = FALSE;
		DoSearch(ptEnd, ss);
	}

	GetExternalBoundaryFromCurves(m_lstSeg, m_poly);
	if(!m_poly)
		Callme(_T("外墙不封闭, 搜索失败!"));
}

 
BOOL XWall::GetInsEquipPt(XPoint &ptPick, double &nRotate, double nDist)
{
	Entity ent = GetNextWallLine(ptPick);
	if(!ent)
		return FALSE;
	XCurveSegment seg(ent);
	if(seg.Is(CURVE_LINE)){
		double angleWall = m_nAngle;
		double angleWall1 = m_nAngle;
		double angleWall2 = ads_angle(seg.StartPoint(), seg.EndPoint());
		double dn = fabs(angleWall2 - angleWall1);
		if(fabs(dn - PI) < 0.001){
			XLine line(seg.EndPoint(), seg.StartPoint(), 1);
			if(line.OnWhichSide(ptPick) == OFFSET_RIGHT)
				angleWall = angleWall + PI;
		}
		else if(seg.OnWhichSide(ptPick) == OFFSET_RIGHT)
			angleWall = angleWall + PI;
		ads_polar(ptPick, angleWall+(PI/2), nDist, ptPick);
		nRotate = angleWall * 180 / PI;
	}
 	else if(seg.Is(CURVE_ARC)){
		double angle = ads_angle(ptPick, m_ptCen);
		nRotate = angle * 180 / PI;
		if(seg.OnWhichSide(ptPick) == OFFSET_LEFT){
			ads_polar(ptPick, angle, nDist, ptPick);
			nRotate -= 90;
		}
		else{ 
			ads_polar(ptPick, angle, -nDist, ptPick);
			nRotate += 90;
		}
	}
 	return TRUE;
}