#include "stdafx.h"
#include "AecDbZLineXOpening.h"
#include "AecDbOpening.h"
#include "AecDbWall.h"
#include "MFCDbDwgFiler.h"
#include "AecGripCback.h"
#include "KTSetting.h"
#include "AcGiExplodeDraw.h"
#include <vector>
#include <algorithm>
#include "AecDbXDrawPointer.h"

static const Adesk::UInt16 kBlue           = 5;
static const Adesk::UInt16 kWhite          = 7;
static const Adesk::UInt16 kColorByLayer   = 256;

extern DLLIMPEXP AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
extern BOOL GetDocScale(double& dPScale);

Adesk::UInt32 AecDbZLineXOpening::kCurrentVersionNumber = 1;

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


AecDbZLineXOpening::AecDbZLineXOpening(void)
{

}

AecDbZLineXOpening::~AecDbZLineXOpening(void)
{

}

void AecDbZLineXOpening::SetZLinePoints(const AcGePoint3dArray& arPts)
{
	AssertWriteEnabled();
	m_arZLines.removeAll();
	m_arZLines.append(arPts);
}

void AecDbZLineXOpening::GetZLinePoints(AcGePoint3dArray& arPts) const
{
	assertReadEnabled();
	arPts.append(m_arZLines);
}

void AecDbZLineXOpening::SetOpeningData(const OpeningData& data,const AcDbObjectIdArray& arIds)
{
	AssertWriteEnabled();

	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(KEY_THICK,data.dThick);

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

	CString sKey;
	for(int i = 0;i < 16;i++)
	{
		sKey.Format(_T("%s_%d"),KEY_N,i+1);
		m_mapSpecXData.SetAt(sKey,data.dXData[i]);
	}

	m_mapSpecXData.SetAt(KEY_BAYWIN,data.bBayWin);
	m_mapSpecXData.SetAt(KEY_FTG,data.bFTG);
	m_mapSpecXData.SetAt(KEY_ADDBAF1,data.bAddBaf1);
	m_mapSpecXData.SetAt(KEY_ADDBAF2,data.bAddBaf2);

	/*for(int i = 0;i < arIds.length();i++)
	{
		sKey.Format(_T("IdCNT%d"),i+1);
		m_mapSpecXData.SetAt(sKey,arIds.at(i).asOldId());
	}*/
	m_arAssocIds.append(arIds);
		
	m_mapSpecXData.SetAt(KEY_NO,data.szNo);
	m_mapSpecXData.SetAt(KEY_LabelText, data.szNo);
	m_mapSpecXData.SetAt(KEY_FACTORY,data.szFactory);

	//编号
	AcGePoint3d ptOn = data.ptPos;
	ptOn += AcGeVector3d(1,1,0) * 2.0 * data.dThick;//默认
	m_mapSpecXData.SetAt(KEY_NOPOS,ptOn);

}

void AecDbZLineXOpening::subList() const
{
	acutPrintf(_T("\n带型门窗"));
	AecDbXOpening::subList();

	for(int i = 0;i < m_arZLines.length();i++)
	{
		const AcGePoint3d& ptPos = m_arZLines.at(i);
		acutPrintf(_T("\nPos:x=%.3f y=%.3f bulge=%.3f"),ptPos.x,ptPos.y,ptPos.z);
	}
}

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

	double dBulge = 0.0;
	for(int i = 0;i < m_arZLines.length();i++)
	{
		AcGePoint3d& ptPos = m_arZLines.at(i);

		dBulge = ptPos.z;
		ptPos.transformBy(xform);
		ptPos.z = dBulge;//bulge不变
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbZLineXOpening::subGetGripPoints( AcDbGripDataPtrArray& grips,
													   const double curViewUnitSize,
													   const int gripSize,
													   const AcGeVector3d& curViewDir,
													   const int bitflags) const
{
	AcGePoint3dArray gripPoints;
	gripPoints.append(m_arZLines.first());
	gripPoints.append(m_arZLines.last());

	AcGePoint3d ptPos;
	if ( m_mapSpecXData.GetAt(KEY_NOPOS,ptPos) )
		gripPoints.append(ptPos);

	int nColor = kWhite;
	AcDbGripData* pGripData = NULL;

	EPosition ePos = eStart;
	CString sTip = _T("门窗的两侧调整点");;
	for (int i = 0;i < gripPoints.length();i++)
	{
		if (i > 1)
		{
			ePos = eMid;
			sTip = _T("门窗的编号点");
		}

		memset(&m_pGripAppData[i],0,sizeof(AecGripData));
		m_pGripAppData[i].nIndex = i;
		m_pGripAppData[i].nSegIndex = -1;
		m_pGripAppData[i].ePos = ePos;
		m_pGripAppData[i].nColor = kBlue;
		m_pGripAppData[i].ptGrip = gripPoints.at(i);
		_tcscpy(m_pGripAppData[i].szTip,sTip);
		//_tcscpy(m_pGripAppData[i].szID,m_sGUID);
		m_pGripAppData[i].pOwner = (AcDbEntity*)this;

		pGripData = new AcDbGripData;
		pGripData->setGripPoint(gripPoints.at(i));
		pGripData->setAppData((void*)&m_pGripAppData[i]);
		pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
		pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
		grips.append(pGripData);
	}

	//调用基类加入单击修改
	SubAddHitEditGrip(grips);

	return Acad::eOk;
}

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

	if (HitOnGripEdit(appData))
	{
		return Acad::eOk;
	}

	AecGripData* pAppData = NULL;
	AcDbIntArray arIndex;

	if ( appData.isEmpty() )
	{
		return Acad::eOk;
	}

	if (m_arZLines.length() < 2)
		return Acad::eOk;

	pAppData = (AecGripData*)appData.first();
	int nGripIndex = pAppData->nIndex;

	AcGePoint3d ptOn;
	AcGeVector3d vtDir,vtOffxy;
	switch(nGripIndex)
	{
	case 0:
		{
			vtDir = m_arZLines.at(0) - m_arZLines.at(1);
			vtDir.z = 0.0;
			vtDir.normalize();
			vtDir.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

			vtOffxy = offset.orthoProject(vtDir);
			m_arZLines.first() += vtOffxy;

			break;
		}
	case 1:
		{
			vtDir = m_arZLines.last() - m_arZLines.at(m_arZLines.length() - 2);
			vtDir.z = 0.0;
			vtDir.normalize();
			vtDir.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

			vtOffxy = offset.orthoProject(vtDir);
			m_arZLines.last() += vtOffxy;

			break;
		}
	case 2:
		{
			m_mapSpecXData.GetAt(KEY_NOPOS,ptOn);
			ptOn += offset;
			m_mapSpecXData.SetAt(KEY_NOPOS,ptOn);

			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbZLineXOpening::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();

	stretchPoints.append(m_arZLines.first());
	stretchPoints.append(m_arZLines.last());

	return Acad::eOk;
}

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

	if (indices.length() == 1)
	{
		int nPos = indices.first();
		AcGeVector3d vtDir,vtOffxy;

		switch(nPos)
		{
		case 0:
			{
				vtDir = m_arZLines.at(0) - m_arZLines.at(1);
				vtDir.z = 0.0;
				vtDir.normalize();
				vtDir.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

				vtOffxy = offset.orthoProject(vtDir);
				m_arZLines.first() += vtOffxy;

				break;
			}
		case 1:
			{
				vtDir = m_arZLines.last() - m_arZLines.at(m_arZLines.length() - 2);
				vtDir.z = 0.0;
				vtDir.normalize();
				vtDir.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

				vtOffxy = offset.orthoProject(vtDir);
				m_arZLines.last() += vtOffxy;

				break;
			}
		default:
			break;
		}
	}
	else if (indices.length() == 2)
	{
		for(int i = 0;i < m_arZLines.length();i++)
		{
			m_arZLines.at(i) += offset;
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbZLineXOpening::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 > AecDbZLineXOpening::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy) ;

	m_mapSpecXData.dwgInFields(pFiler);

	//2D
	AcDbSoftPointerId id;
	Adesk::Int32 nLen = 0;
	pFiler->readInt32(&nLen);
	for (int i = 0;i < nLen;i++)
	{
		pFiler->readSoftPointerId(&id);
		m_arAssocIds.append(id);
	}

	AcGePoint3d ptOn;
	m_arZLines.removeAll();
	pFiler->readInt32(&nLen);
	for(int i = 0;i < nLen;i++)
	{
		pFiler->readPoint3d(&ptOn);
		m_arZLines.append(ptOn);
	}

	return (pFiler->filerStatus ());
}

Acad::ErrorStatus AecDbZLineXOpening::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 (AecDbZLineXOpening::kCurrentVersionNumber)) != Acad::eOk )
		return (es) ;

	m_mapSpecXData.dwgOutFields(pFiler);

	//2D
	Adesk::Int32 nLen = 0;

	nLen = m_arAssocIds.length();
	pFiler->writeInt32(nLen);
	for (int i = 0;i < nLen;i++)
	{
		pFiler->writeSoftPointerId(m_arAssocIds.at(i));
	}
	
	nLen = m_arZLines.length();
	pFiler->writeInt32(nLen);
	for(int i = 0;i < nLen;i++)
	{
		pFiler->writePoint3d(m_arZLines.at(i));
	}

	return (pFiler->filerStatus ());
}

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

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

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

bool AecDbZLineXOpening::GetStandardDraw2d(AecComplexCurve& draw2d,bool bHasEnd/* = true*/) const
{
	assertReadEnabled();

	OpeningData data;
	GetOpeningData(data);

	double dSpace = data.dThick / 3;//默认4线
	AcDbPolyline* pPl = FormatPolyline((AcGePoint3d *)m_arZLines.asArrayPtr(),m_arZLines.length());
	if (pPl != NULL)
	{
		AcDbVoidPtrArray arOffPls;
		pPl->getOffsetCurves( 0.5 * dSpace,arOffPls);
		pPl->getOffsetCurves(-0.5 * dSpace,arOffPls);

		pPl->getOffsetCurves( 1.5 * dSpace,arOffPls);
		pPl->getOffsetCurves(-1.5 * dSpace,arOffPls);

		AcDbCurve* pCurve = NULL;
		for(int i = 0;i < arOffPls.length();i++)
		{
			pCurve = (AcDbCurve*)arOffPls.at(i);
			draw2d.append(pCurve);
			delete pCurve;
		}
		delete pPl;
	}
	return true;
}

void AecDbZLineXOpening::GetSideLines(AecComplexCurve& draw2d,const AcGeVector3d& vtDir) const
{
	if (m_arZLines.length() > 1)
	{
		//sta
		double dThick = 0.0;
		m_mapSpecXData.GetAt(KEY_THICK,dThick);

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

		AcGeVector3d vtV = m_arZLines.at(0) - m_arZLines.at(1);
		vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
		vtV.normalize();
		
		AcGePoint3d ptGe[2];
		ptGe[0] = m_arZLines.first() + vtV * 0.5 * dThick;
		ptGe[1] = ptGe[0] - vtV * dThick;

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

		vtV = m_arZLines.last() - m_arZLines.at(m_arZLines.length() - 2);
		vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
		vtV.normalize();

		ptGe[0] = m_arZLines.last() + vtV * 0.5 * dThick;
		ptGe[1] = ptGe[0] - vtV * dThick;

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

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

	if ( dc.IsDragging() )
	{
		//return Acad::eOk;
	}

	//图层
	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());

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

	if ( Draw2DBuffers(dc))
	{
		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}

	AecDbXDrawPointer aecDbXDraw(this,_T("AecDbZLineXOpeningDraw"));
	aecDbXDraw.Draw2d(dc);

	AcDbVoidPtrArray arEntPtrs;
	dc.Get2dBuffer(arEntPtrs);
	Add2DBuffer(arEntPtrs);

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

	dc.SetLayer(idLay);
	dc.SetColor(nCrBk);

	return Acad::eOk;
}

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

	if ( dc.IsDragging() )
	{
		//return Acad::eOk;
	}

	//图层
	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());

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

	if ( Draw3DBuffers(dc))
	{
		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}

	AecDbXDrawPointer aecDbXDraw(this,_T("AecDbZLineXOpeningDraw"));
	aecDbXDraw.Draw3d(dc);

	AcDbVoidPtrArray arEntPtrs;
	dc.Get3dBuffer(arEntPtrs);
	Add3DBuffer(arEntPtrs);

	dc.SetLayer(idLay);
	dc.SetColor(nCrBk);

	return Acad::eOk;
}

bool AecDbZLineXOpening::GetForHouseSubtract(AcDbVoidPtrArray& arSolidPtrs) const
{
	assertReadEnabled();
	OpeningData data;
	GetOpeningData(data);

	AcGePoint3dArray arZLines;
	GetZLinePoints(arZLines);

	AcDbPolyline* pPl = FormatPolyline((AcGePoint3d *)arZLines.asArrayPtr(),arZLines.length());
	if (pPl != NULL)
	{
		AecDbXWall wall;
		double dBomEl = data.ptPos.z + data.dBomEl;
		pPl->setElevation(dBomEl);

		wall.SetBaseCurve(pPl);
		wall.SetWallData(data.dThick,data.dHeight,0.0,kMid);

		AcGiExplodeDraw dc(arSolidPtrs);
		wall.Draw3d(dc);
		wall.Clean3DBufferNoDel();
		return true;
	}
	return false;
}

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

	AcGiExplodeDraw xDraw(arEntPtrs);
	Draw2d(xDraw);

	return arEntPtrs.length();
}

int AecDbZLineXOpening::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs,bool bWriteBimInfo/* = false */) const
{
	return AecDbEntityBase::GetDraw3dables(arEntPtrs,bWriteBimInfo);
}