#include "stdafx.h"
#include "AecDbGroupOpening.h"
#include "AecDbOpening.h"
#include "AecDbWall.h"
#include "MFCDbDwgFiler.h"
#include "AecGripCback.h"
#include "KTSetting.h"
#include <vector>
#include <algorithm>

extern AcGePoint3d DLLIMPEXP MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
Adesk::UInt32 AecDbGroupXOpening::kCurrentVersionNumber = 1;

ACRX_DXF_DEFINE_MEMBERS(AecDbGroupXOpening, AecDbXOpening,
						AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
						AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
						AEC_DBGXOPENING,
						"AecDbGroupXOpening"
						"|Product Desc:     shanghua earthworm app obj"
						"|Company:          shanghua inc"
						"|WEB Address:      www.shanghuasoft.com")


AecDbGroupXOpening::AecDbGroupXOpening(void)
{
}

AecDbGroupXOpening::~AecDbGroupXOpening(void)
{
}

bool AecDbGroupXOpening::GetForHouseSubtract(AcDbVoidPtrArray& arSolidPtrs) const
{
	assertReadEnabled();

	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		if (pXOpening != NULL)
		{
			pXOpening->GetForHouseSubtract(arSolidPtrs);
		}
	}
	return true;
}

void AecDbGroupXOpening::subList() const
{
	acutPrintf(_T("\n组合门窗"));
	AecDbEntityBase::subList();
	m_mapSpecXData.List();

	AecDbXOpening* pXOpening = NULL;
	for(int i = 0;i < m_lstOpening.length();i++)
	{
		pXOpening = m_lstOpening.at(i);
		#ifndef ZWCAD
		pXOpening->list();
		#endif
	}
}

Acad::ErrorStatus AecDbGroupXOpening::subTransformBy(const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();

	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		if (pXOpening != NULL)
		{
			pXOpening->transformBy(xform);
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbGroupXOpening::subGetGripPoints( AcDbGripDataPtrArray& grips,
													   const double curViewUnitSize,
													   const int gripSize,
													   const AcGeVector3d& curViewDir,
													   const int bitflags) const
{
	assertReadEnabled();

	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		if (pXOpening != NULL)
		{
			AcDbGripDataPtrArray subGrips;
			pXOpening->getGripPoints(subGrips,curViewUnitSize,gripSize,curViewDir,bitflags);

			for(int n = 0;n < subGrips.length();n++)
			{
				AcDbGripData* pGripData = subGrips.at(n);
				AecGripData* pAGripData = (AecGripData*)pGripData->appData();
				pAGripData->nSegIndex = i;
			}
			grips.append(subGrips);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbGroupXOpening::subMoveGripPointsAt(const AcDbVoidPtrArray& appData, const AcGeVector3d& offset, const int bitflags)
{
	AssertWriteEnabled();

	PreRefreshWallDraw();

	for(int n = 0;n < appData.length();n++)
	{
		AecGripData* pAppData = (AecGripData*)appData.at(n);
		if (pAppData->nSegIndex > -1 && pAppData->nSegIndex < m_lstOpening.length())
		{
			AecDbXOpening* pXOpening = m_lstOpening.at(pAppData->nSegIndex);

			AcDbVoidPtrArray subAppData;
			subAppData.append(pAppData);
			pXOpening->moveGripPointsAt(subAppData,offset,999);
			break;
		}
	}

	PositionSideBySide();
	RefreshWallDraw();

	return Acad::eOk;
}

Acad::ErrorStatus AecDbGroupXOpening::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();
	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		if (pXOpening != NULL)
		{
			pXOpening->getStretchPoints(stretchPoints);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbGroupXOpening::subMoveStretchPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
	AssertWriteEnabled();

	int nGripIndex = indices.first();
	if (nGripIndex > -1 && nGripIndex < m_lstOpening.length())
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(nGripIndex);
		if (pXOpening != NULL)
		{
			AcDbIntArray subInd;
			subInd.append(0);
			pXOpening->moveStretchPointsAt(subInd,offset);
			PositionSideBySide();
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbGroupXOpening::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgInFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

	//----- Object version number needs to be read first
	Adesk::UInt32 version =0 ;
	if ( (es = pFiler->readUInt32 (&version)) != Acad::eOk )
		return (es) ;

	if ( version > AecDbGroupXOpening::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy) ;

	Adesk::Int32 nLen = 0;
	pFiler->readInt32(&nLen);

	m_lstOpening.removeAll();
	for(int i = 0;i < nLen;i++)
	{
		AecDbXOpening* pXOpening = new AecDbXOpening;
		pXOpening->dwgInFields(pFiler);
		m_lstOpening.append(pXOpening);
	}

	//2D
	m_mapSpecXData.dwgInFields(pFiler);

	return (pFiler->filerStatus ());
}

Acad::ErrorStatus AecDbGroupXOpening::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();

	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgOutFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

	//----- Object version number needs to be saved first
	if ( (es =pFiler->writeUInt32 (AecDbGroupXOpening::kCurrentVersionNumber)) != Acad::eOk )
		return (es) ;

	Adesk::Int32 nLen = m_lstOpening.length();
	pFiler->writeInt32(nLen);

	for (int i = 0;i < nLen;i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		pXOpening->dwgOutFields(pFiler);
	}

	//2D
	m_mapSpecXData.dwgOutFields(pFiler);

	return (pFiler->filerStatus ());
}

Acad::ErrorStatus AecDbGroupXOpening::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbGroupXOpening::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbGroupXOpening::subErase(Adesk::Boolean erasing)
{
	if (erasing)
	{
		PreRefreshWallDraw();//修复墙体
	}
	else
	{
		RefreshWallDraw();//
	}
	return AcDbEntity::subErase(erasing);
}

Acad::ErrorStatus AecDbGroupXOpening::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcGeVector3d vtDir;
	m_mapSpecXData.GetAt(PIPE_DIR,vtDir);
	vtDir.normalize();

	int nType = 0;
	AecComplexCurve drawSides;
	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		pXOpening->Draw2d(dc);

		nType = 0;
		pXOpening->GetSpecialtyData(AcDb::kForRead)->GetAt(KEY_TYPE,nType);

		if (nType == 1)//只取窗户
		{
			pXOpening->GetSideLines(drawSides,vtDir);
		}
	}

	//排序,去除首尾
	drawSides.removeFirst();

	if (drawSides.length() > 1)
		drawSides.removeLast();

	//门的裁剪墙线预先在插入门的时候;
	AecComplexCurve win2d;
	GetSideLines(win2d,vtDir);

	//测试
	/*AcDbLine* pLn = NULL;
	for (int i = 0;i < win2d.length();i++)
	{
		AecEqui::AecCurveElement& el = win2d.atByRef(i);
		
		if ( AecComplexCurve::MakeLine(el,pLn) )
		{
			pLn->setColorIndex(3);
			CKTCadUtility::AddToBlockTableRecord(pLn);
			pLn->close();
		}
	}*/

	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	Adesk::UInt16 nCrBk = colorIndex();

	int nColor = nCrBk;
	if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
	{
		dc.SetColor(nColor);
	}

	AecComplexCurve win2dEnd;
	for (int i = 0;i < win2d.length();i++)
	{
		AecEqui::AecCurveElement& el = win2d.atByRef(i);
		if (el.gsMark == 0)
		{
			win2dEnd.append(el);
		}

		if (i == win2d.length() - 1)
		{
			for(int n = 0;n < drawSides.length();n++)
			{
				AecEqui::AecCurveElement& elIn = drawSides.atByRef(n);
				if (elIn.gsMark == 0)
				{
					win2dEnd.append(elIn);
				}
			}
		}
	}

	//设置为墙体的图层
	AcDbObjectId idWallLay = KTSetting::InitLayer(_T("LAY_WALL"),true);
	AecComplexCurveDraw win2dEndDraw;
	win2dEndDraw.SetEdage(win2dEnd);
	win2dEndDraw.Draw2d(dc,idWallLay,idWallLay,idWallLay);

	//绘制编号
	CString sLable = GetLabel();
	sLable.TrimRight(_T(" "));
	if (!sLable.IsEmpty() && sLable.CompareNoCase(_T("No")) != 0 )
	{
		if ( sLable.GetLength() < 36)//<IDCreate
			DrawLabel(dc,sLable);
	}

	dc.SetColor(nCrBk);
	dc.SetLayer(idCurLay);
	dc.SetLineType(idCurLty);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbGroupXOpening::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();

	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		pXOpening->Draw3d(dc);
	}

	return Acad::eOk;
}

int AecDbGroupXOpening::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
{
	assertReadEnabled();

	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		pXOpening->GetDraw2dables(nDrawStyle,arEntPtrs);
	}
	return Acad::eOk;
}

int AecDbGroupXOpening::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs,bool bWriteBimInfo/* = false */) const
{
	assertReadEnabled();

	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		pXOpening->GetDraw3dables(arEntPtrs,bWriteBimInfo);
	}
	return Acad::eOk;
}

int AecDbGroupXOpening::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray&  arRegionPtrs) const
{
	assertReadEnabled();

	for(int i = 0;i < m_lstOpening.length();i++)
	{
		AecDbXOpening* pXOpening = m_lstOpening.at(i);
		pXOpening->GetSectionDraw(ptFr,ptTo,vtViewDir,vtTo,arRegionPtrs);
	}
	return Acad::eOk;
}

static bool SortOpeningData(OpeningData& data1,OpeningData& data2)
{
	if (data1.dParamInWall > data2.dParamInWall)
	{
		return true;//as
	}
	return false;//ds
}

bool AecDbGroupXOpening::PositionSideBySide()
{
	AssertWriteEnabled();

	AcDbObjectId idWall;
	AcDbObjectIdArray arIDS;
	std::vector<OpeningData> arOpenDatas;
	CString sBlk2ds,sBlk3ds;
	double dW = 0.0,dH = 0.0,dBomEl = 999999.0;
	OpeningData opData;
	memset(&opData,0,sizeof(OpeningData));

	AecDbXOpening* pXOpening = NULL;
	for(int i = 0;i < m_lstOpening.length();i++)
	{
		pXOpening = m_lstOpening.at(i);
		pXOpening->GetSpecialtyData(AcDb::kForRead)->GetAt(KEY_IDCNT1,idWall);

		if (arIDS.find(idWall) == -1)
			arIDS.append(idWall);

		pXOpening->GetOpeningData(opData);
		opData.dUserPtr = (PVOID)pXOpening;
		arOpenDatas.push_back(opData);

		sBlk2ds += opData.szBlockName2d;
		sBlk3ds += opData.szBlockName3d;

		dW += opData.dWidth;//总宽
		dH = __max(opData.dHeight,dH);//整体高
		dBomEl = __min(opData.dBomEl,dBomEl);
	}
	
	if (arIDS.length() == 1)
	{
		//排序,仅仅支持直墙
		std::sort(arOpenDatas.begin(),arOpenDatas.end(),SortOpeningData);

		AcGePoint3d ptIns = arOpenDatas.front().ptPos;
		if (arOpenDatas.size() > 1)
		{
			ptIns = MidPoint(arOpenDatas.front().ptPos,arOpenDatas.back().ptPos);
		}

		AcGeVector3d vtDir = arOpenDatas.back().ptPos - arOpenDatas.front().ptPos;
		vtDir.z = 0.0;//门窗总是垂直地面放置
		vtDir.normalize();
		AcGePoint3d ptL = ptIns - vtDir * 0.5 * dW;
		AcGePoint3d ptOn,ptPos;
		AcGeVector3d vtOff;

		//调整 m_lstOpening
		m_lstOpening.removeAll();
		for(int i = 0;i < arOpenDatas.size();i++)
		{
			OpeningData& op = arOpenDatas.at(i);
			pXOpening = (AecDbXOpening*)op.dUserPtr;

			//调整位置
			op.ptPos = ptL + 0.5 * op.dWidth * vtDir;
			ptL += vtDir * op.dWidth;

			pXOpening->GetSpecialtyData(AcDb::kForWrite)->GetAt(KEY_ORGPT,ptPos);
			pXOpening->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_ORGPT,op.ptPos);
			
			vtOff = op.ptPos - ptPos;
			pXOpening->GetSpecialtyData(AcDb::kForWrite)->GetAt(KEY_PTON,ptOn);

			ptOn += vtOff;
			pXOpening->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_PTON,ptOn);

			pXOpening->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_FLAG,1);
			m_lstOpening.append(pXOpening);

			if (i == 0)
			m_mapSpecXData.CopyFrom(pXOpening->GetSpecialtyData());
		}

		OpeningData data;
		data.ptPos = ptIns;
		data.nType = 2;
		data.dWidth = dW;
		data.dHeight = dH;
		data.dBomEl = dBomEl;

		_tcscpy(data.szName,_T("组合门窗"));
		_tcscpy(data.szBlockName2d,sBlk2ds);
		_tcscpy(data.szBlockName3d,sBlk3ds);
		_tcscpy(data.szSpec,arOpenDatas.front().szSpec);
		_tcscpy(data.szFactory,arOpenDatas.front().szFactory);
		_tcscpy(data.szNo,arOpenDatas.front().szNo);

		m_mapSpecXData.SetAt(KEY_TYPE,data.nType);
		m_mapSpecXData.SetAt(KEY_FLAG,data.nFlag);
		m_mapSpecXData.SetAt(KEY_Width,data.dWidth);
		m_mapSpecXData.SetAt(KEY_HEIGHT,data.dHeight);
		m_mapSpecXData.SetAt(KEY_ORGPT,data.ptPos);
		m_mapSpecXData.SetAt(PIPE_DIR,vtDir);

		data.ptPos.z = dBomEl;
		m_mapSpecXData.SetAt(KEY_PTON,data.ptPos);
		
		m_mapSpecXData.SetAt(KEY_NAME,data.szName);
		m_mapSpecXData.SetAt(KEY_BLK2D,data.szBlockName2d);
		m_mapSpecXData.SetAt(KEY_BLK3D,data.szBlockName3d);

		m_mapSpecXData.SetAt(PIPE_SPEC,data.szSpec);
		m_mapSpecXData.SetAt(KEY_BOMEL,data.dBomEl);

		m_mapSpecXData.SetAt(KEY_IDCNT1,idWall);
		m_mapSpecXData.SetAt(KEY_NO,data.szNo);

		m_mapSpecXData.SetAt(KEY_FACTORY,data.szFactory);

		return true;
	}
	else
	{
		acutPrintf(_T("\n门窗不共墙,组合门窗失败!"));
	}
	return false;
}

bool AecDbGroupXOpening::GetStandardDraw2d(AecComplexCurve& draw2d,bool bHasEnd/* = true*/) const
{
	double dWidth = 0.0;
	m_mapSpecXData.GetAt(KEY_Width,dWidth);

	AcGeVector3d vtDir;
	m_mapSpecXData.GetAt(PIPE_DIR,vtDir);

	AcGePoint3d ptOn;
	m_mapSpecXData.GetAt(KEY_PTON,ptOn);

	double dThick = 0.0;
	m_mapSpecXData.GetAt(KEY_THICK,dThick);

	AecEqui::AecCurveElement el;
	memset(&el,0,sizeof(AecEqui::AecCurveElement));

	AcGeVector3d vtV = vtDir;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	ptOn.z = 0.0;
	vtDir.normalize();

	AcGePoint3d ptGe[5];
	ptGe[0] = ptOn;
	ptGe[0] -= vtDir * 0.5 * dWidth;
	ptGe[0] += vtV * 0.5 * dThick;

	ptGe[1] = ptGe[0] + vtDir * dWidth;
	ptGe[2] = ptGe[1] - vtV * dThick;
	ptGe[3] = ptGe[2] - vtDir * dWidth;
	ptGe[4] = ptGe[0];

	if (bHasEnd)
	{
		el.ptGe[0] = ptGe[0];
		el.ptGe[1] = ptGe[1];
		el.ptGe[2] = ptGe[1];
		el.gsMark = 1;
		draw2d.append(el);

		el.ptGe[0] = ptGe[3];
		el.ptGe[1] = ptGe[2];
		el.ptGe[2] = ptGe[2];
		el.gsMark = 1;
		draw2d.append(el);

		el.ptGe[0] = ptGe[1];
		el.ptGe[1] = ptGe[2];
		el.ptGe[2] = ptGe[2];
		el.gsMark = 0;
		draw2d.append(el);

		el.ptGe[0] = ptGe[3];
		el.ptGe[1] = ptGe[0];
		el.ptGe[2] = ptGe[0];
		el.gsMark = 0;
		draw2d.append(el);
	}
	else
	{
		el.ptGe[0] = ptGe[0];
		el.ptGe[1] = ptGe[1];
		el.ptGe[2] = ptGe[1];
		draw2d.append(el);

		el.ptGe[0] = ptGe[3];
		el.ptGe[1] = ptGe[2];
		el.ptGe[2] = ptGe[2];
		draw2d.append(el);
	}
	return true;
}

void AecDbGroupXOpening::GetSideLines(AecComplexCurve& draw2d,const AcGeVector3d& vtDir) const
{
	int nGroup = 0;
	m_mapSpecXData.GetAt(KEY_FLAG,nGroup);

	int nType = 0;
	m_mapSpecXData.GetAt(KEY_TYPE,nType);

	double dWidth = 0.0;
	m_mapSpecXData.GetAt(KEY_Width,dWidth);

	AcGePoint3d ptOn;
	m_mapSpecXData.GetAt(KEY_PTON,ptOn);

	double dThick = 0.0;
	m_mapSpecXData.GetAt(KEY_THICK,dThick);

	AecEqui::AecCurveElement el;
	memset(&el,0,sizeof(AecEqui::AecCurveElement));

	AcGeVector3d vtV = vtDir;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	ptOn.z = 0.0;

	AcGePoint3d ptGe[5];
	ptGe[0] = ptOn;
	ptGe[0] -= vtDir * 0.5 * dWidth;
	ptGe[0] += vtV * 0.5 * dThick;

	ptGe[1] = ptGe[0] + vtDir * dWidth;
	ptGe[2] = ptGe[1] - vtV * dThick;
	ptGe[3] = ptGe[2] - vtDir * dWidth;
	ptGe[4] = ptGe[0];

	el.ptGe[0] = ptGe[3];
	el.ptGe[1] = ptGe[0];
	el.ptGe[2] = ptGe[0];
	el.gsMark = 0;
	draw2d.append(el);

	el.ptGe[0] = ptGe[1];
	el.ptGe[1] = ptGe[2];
	el.ptGe[2] = ptGe[2];
	el.gsMark = 0;
	draw2d.append(el);
}