#include "stdafx.h"
#include "AecDbRiverGroove.h"
#include "GiDrawUtility.h"
#include "CoreTools.h"

extern double PixelToWcs(int nPixel);
extern BOOL Is2DView();
extern AcGeVector3d GetUcsZvt();
extern void PushGripMessage(GripMessage&);

namespace
{
	AcDbRegion* getSection(const double &w
		, const double &h
		, const AcGePoint3d &ptOrg
		, const AcGeVector3d &vtNormal)
	{
		AcGeVector3d X(AcGeVector3d::kXAxis), Z(AcGeVector3d::kZAxis), vtN(vtNormal);
		AcGePoint3d pt0(AcGePoint3d::kOrigin), pt1(AcGePoint3d::kOrigin), pt2(AcGePoint3d::kOrigin), pt3(AcGePoint3d::kOrigin);

		vtN.rotateBy(PI * .5, Z);

		pt0 = ptOrg - vtN * (w * .5);
		pt1 = pt0 + Z * h;
		pt2 = pt1 + vtN * w;
		pt3 = pt2 - Z * h;

		AcDbVoidPtrArray arr;
		arr.append(new AcDbLine(pt0, pt1));
		arr.append(new AcDbLine(pt1, pt2));
		arr.append(new AcDbLine(pt2, pt3));
		arr.append(new AcDbLine(pt3, pt0));

		AcDbRegion *pReg = CoreTools::createRegion(arr);

		for (int i = 0; i < arr.length(); ++i)
			DELETE_PTR(arr[i]);
		arr.removeAll();

		if (!pReg) return NULL;

		return pReg;
	}

	AcDb3dSolid* makeSolid(const double &w1
		, const double &h1
		, const AcGePoint3d &pt1
		, const double &w2
		, const double &h2
		, const AcGePoint3d &pt2
		, const double &t
		, const AcGeVector3d &vtN
		, AcDbLine *pL
	)
	{
		AcDbRegion *pReg1(NULL), *pReg2(NULL)		// 内腔
			, *pReg11(NULL), *pReg22(NULL);		// 外腔

		// 四个截面起点
		AcGeVector3d Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt11(pt1 - Z * t), pt22(pt2 - Z * t);

		pReg1 = getSection(w1, h1, pt1, vtN);
		pReg2 = getSection(w2, h2, pt2, vtN);

		pReg11 = getSection(w1 + 2 * t, h1 + 2 * t, pt11, vtN);
		pReg22 = getSection(w2 + 2 * t, h2 + 2 * t, pt22, vtN);

		if (!pReg1 || !pReg2 || !pReg11 || !pReg22)
		{
			DELETE_PTR(pReg1);
			DELETE_PTR(pReg2);
			DELETE_PTR(pReg11);
			DELETE_PTR(pReg22);
			return NULL;
		}

		AcDb3dSolid *pSolid(NULL), *pSolid1(NULL);

		pSolid = (AcDb3dSolid*)GiDrawUtility::DrawLoft(pReg1, pReg2, NULL);
		pSolid1 = (AcDb3dSolid*)GiDrawUtility::DrawLoft(pReg11, pReg22, NULL);

		DELETE_PTR(pReg1);
		DELETE_PTR(pReg2);
		DELETE_PTR(pReg11);
		DELETE_PTR(pReg22);

		if (pSolid && pSolid1 && pSolid1->booleanOper(AcDb::kBoolSubtract, pSolid) == Acad::eOk)
			return pSolid1;

		DELETE_PTR(pSolid);
		DELETE_PTR(pSolid1);

		return NULL;
	}

	AcDb3dSolid* makeLookupHold(const AcGePoint3d &pt0
		, const AcGeVector3d &vt
		, const double &len
		, const double &D1
		, const double &D2
		, const double &T
		, const double &h
		, const double &b )
	{
		double dLong(len - b * .5 - T), dShort(len - b * .5);
		AcGeVector3d Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt1 = pt0 + vt * len;
		AcGePoint3d pt2 = pt1 + Z * T;
		AcGePoint3d pt3 = pt2 - vt * dShort;
		AcGePoint3d pt4 = pt3 + Z * (h - 2 * T);
		AcGePoint3d pt5 = pt4 - vt * b;
		AcGePoint3d pt6 = pt5 - Z * (h - 2 * T);
		AcGePoint3d pt7 = pt6 - vt * dShort;
		AcGePoint3d pt8 = pt7 - Z * T;
		AcGePoint3d pt9 = pt8 + vt * dLong;
		AcGePoint3d pt10 = pt9 + Z * h;
		AcGePoint3d pt11 = pt10 + vt * (b + 2 * T);
		AcGePoint3d pt12 = pt11 - Z * h;

		AcDbVoidPtrArray ar(0);
		ar.append(new AcDbLine(pt1, pt2));
		ar.append(new AcDbLine(pt2, pt3));
		ar.append(new AcDbLine(pt3, pt4));
		ar.append(new AcDbLine(pt4, pt5));
		ar.append(new AcDbLine(pt5, pt6));
		ar.append(new AcDbLine(pt6, pt7));
		ar.append(new AcDbLine(pt7, pt8));
		ar.append(new AcDbLine(pt8, pt9));
		ar.append(new AcDbLine(pt9, pt10));
		ar.append(new AcDbLine(pt10, pt11));
		ar.append(new AcDbLine(pt11, pt12));
		ar.append(new AcDbLine(pt12, pt1));

		AcDbRegion *pReg = CoreTools::createRegion(ar);

#ifndef NDEBUG
		if (!pReg)
		{
			for (int i = 0; i < ar.length(); ++i)
			{
				CoreTools::CloneAndAddToModelSpace((AcDbEntity*)ar[i], i+1);
			}
		}
#endif
		deleteArrayVoidPtrs< AcDbEntity>(ar);

		if (!pReg) return NULL;
		
		AcGeVector3d v(vt);
		v.rotateBy(-PI * .5, AcGeVector3d::kZAxis);
		v.normalize();
		v *= D1;

		AcDb3dSolid *p = new AcDb3dSolid();
		AcDbSweepOptions op;
		if (p->createExtrudedSolid(pReg, v, op) != Acad::eOk)
		{
			DELETE_PTR(p);
			DELETE_PTR(pReg);
			return NULL;
		}
		DELETE_PTR(pReg);

		// 开观察孔
		v.normalize();
		pt1 = pt0 + Z * h;
		pt1 += v * D1 * .5;
		AcDbCircle *pCir = new AcDbCircle(pt1, Z, D2 * .5);
		pReg = CoreTools::createRegion(pCir);
		DELETE_PTR(pCir);
		if (!pReg) return p;
		
		AcDb3dSolid *p2 = new AcDb3dSolid();
		if (p2->createExtrudedSolid(pReg, Z * T, op) != Acad::eOk)
		{
			DELETE_PTR(p2);
			DELETE_PTR(pReg);
			return p;
		}
		if (p->booleanOper(AcDb::kBoolSubtract, p2) != Acad::eOk)
		{
			DELETE_PTR(p2);
			DELETE_PTR(pReg);
			return p;
		}

		DELETE_PTR(pReg);
		return p;
	}

}

Adesk::UInt32 AecDbRiverGroove::kCurrentVersionNumber = 1;

IMP_XDATA_KEY(AecDbRiverGroove, _D_);
IMP_XDATA_KEY(AecDbRiverGroove, _N_);
IMP_XDATA_KEY(AecDbRiverGroove, _K_);
IMP_XDATA_KEY(AecDbRiverGroove, _L1_);
IMP_XDATA_KEY(AecDbRiverGroove, _L_);
IMP_XDATA_KEY(AecDbRiverGroove, _L2_);
IMP_XDATA_KEY(AecDbRiverGroove, _T_);
IMP_XDATA_KEY(AecDbRiverGroove, _j_);
IMP_XDATA_KEY(AecDbRiverGroove, _b_);
IMP_XDATA_KEY(AecDbRiverGroove, _B1_);
IMP_XDATA_KEY(AecDbRiverGroove, _B2_);
IMP_XDATA_KEY(AecDbRiverGroove, _La_);
IMP_XDATA_KEY(AecDbRiverGroove, _h_);
IMP_XDATA_KEY(AecDbRiverGroove, _D1_);
IMP_XDATA_KEY(AecDbRiverGroove, _D2_);
IMP_XDATA_KEY(AecDbRiverGroove, _X_);

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


AecDbRiverGroove::AecDbRiverGroove(void)
{
	m_pGripAppData = new AecGripData[GRIP_LENGTH];
	m_mapSpecXData.SetAt(KEY_NAME,_T("巴歇尔槽"));
}

AecDbRiverGroove::~AecDbRiverGroove(void)
{
	DELETE_ARR_(m_pGripAppData);
}

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

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	es = AecDbEwPipeBase::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 > AecDbRiverGroove::kCurrentVersionNumber)
		return Acad::eMakeMeProxy;

	return Acad::eOk;
}

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

	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	es = AecDbEwPipeBase::dwgOutFields(pFiler);
		if (es != Acad::eOk)
			return (es);

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

	return Acad::eOk;
}

Acad::ErrorStatus AecDbRiverGroove::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbRiverGroove::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbRiverGroove::subExplode(AcDbVoidPtrArray& entitySet) const
{
	return Acad::eOk;
}

void AecDbRiverGroove::subList() const
{}

Acad::ErrorStatus AecDbRiverGroove::subGetGripPoints(AcDbGripDataPtrArray& grips,
	const double curViewUnitSize,
	const int gripSize,
	const AcGeVector3d& curViewDir,
	const int bitflags) const
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbRiverGroove::subMoveGripPointsAt(const AcDbVoidPtrArray& appData, const AcGeVector3d& offset, const int bitflags)
{
	return Acad::eOk;
}

void AecDbRiverGroove::GetGripText(int nPos, CString& sText)
{
	return;
}

Acad::ErrorStatus AecDbRiverGroove::subIntersectWith(const AcDbEntity*	pEnt,
	AcDb::Intersect		intType,
	AcGePoint3dArray&	points,
	INT_PTR				thisGsMarker,
	INT_PTR				otherGsMarker) const
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbRiverGroove::subIntersectWith(const AcDbEntity*	pEnt,
	AcDb::Intersect		intType,
	const AcGePlane&	projPlane,
	AcGePoint3dArray&	points,
	INT_PTR				thisGsMarker,
	INT_PTR				otherGsMarker) const
{
	return Acad::eOk;
}

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

	int clr(256), oldclr;
	m_mapSpecXData.GetAt(_T("COLOR"), clr);
	oldclr = dc.GetColor();
	dc.SetColor(clr);

	if (Has2DBuffer())
	{
		Draw2DBuffers(dc);
		return Acad::eOk;
	}

	double D(GetD()), B1(GetB1()), B2(GetB2()), b(Getb()), N(GetN()), K(GetK());
	double L1(GetL1()), L(GetL()), L2(GetL2()), t(GetT());
	double La(GetLa()), D1(GetD1()), D2(GetD2()), h(Geth());

	AcDbCurve *pCurve = GetBaseCurve();
	AcGePoint3d ptS(AcGePoint3d::kOrigin), ptE(AcGePoint3d::kOrigin);
	pCurve->getStartPoint(ptS);
	pCurve->getEndPoint(ptE);
	ptS.z = ptE.z = .0;
	AcGeVector3d vt(ptE - ptS), vtN(ptE - ptS);
	vtN.rotateBy(PI * .5, AcGeVector3d::kZAxis);
	vt.normalize();
	vtN.normalize();
	DELETE_PTR(pCurve);

	AcGeVector2d vt2d(vtN.convert2d(AcGePlane::kXYPlane));
	vt2d.normalize();

	AcDbPolyline *pPoly = new AcDbPolyline();

	if (CoreTools::getFlume2DStyle() == 1)
	{
		B1 += 2 * t;
		b += 2 * t;
		B2 += 2 * t;
	}
	AcGePoint3d pt(ptS);
	AcGePoint3d pt0(pt + vtN * (B1 * .5));
	AcGePoint3d pt7(pt - vtN * (B1 * .5));
	pt += vt * L1;
	AcGePoint3d pt1(pt + vtN * (b * .5));
	AcGePoint3d pt6(pt - vtN * (b * .5));
	pt += vt * L;
	AcGePoint3d pt2(pt + vtN * (b * .5));
	AcGePoint3d pt5(pt - vtN * (b * .5));
	pt += vt * L2;
	AcGePoint3d pt3(pt + vtN * (B2 * .5));
	AcGePoint3d pt4(pt - vtN * (B2 * .5));

	pPoly->addVertexAt(0, pt0.convert2d(AcGePlane::kXYPlane));
	pPoly->addVertexAt(1, pt1.convert2d(AcGePlane::kXYPlane));
	pPoly->addVertexAt(2, pt2.convert2d(AcGePlane::kXYPlane));
	pPoly->addVertexAt(3, pt3.convert2d(AcGePlane::kXYPlane));
	pPoly->addVertexAt(4, pt4.convert2d(AcGePlane::kXYPlane));
	pPoly->addVertexAt(5, pt5.convert2d(AcGePlane::kXYPlane));
	pPoly->addVertexAt(6, pt6.convert2d(AcGePlane::kXYPlane));
	pPoly->addVertexAt(7, pt7.convert2d(AcGePlane::kXYPlane));
	pPoly->setClosed(true);

	Add2DBuffer(pPoly);

	Add2DBuffer(new AcDbLine(pt1, pt6));
	Add2DBuffer(new AcDbLine(pt2, pt5));

	if (!EQUAL_ZERO(La))
	{
		double tanA = ((B1 - b) * .5) / L1;
		double l1 = ((B1 * .5) / tanA - L1 + La + D1 * .5) * tanA;
		double l2 = ((B1 * .5) / tanA - L1 + La - D1 * .5) * tanA;
		pt = ptS + vt * (L1 - La - D1 * .5);
		Add2DBuffer(new AcDbLine(pt + vtN * l1, pt - vtN * l1));
		pt = ptS + vt * (L1 - La + D1 * .5);
		Add2DBuffer(new AcDbLine(pt + vtN * l2, pt - vtN * l2));
		pt = ptS + vt * (L1 - La);
		Add2DBuffer(new AcDbCircle(pt, AcGeVector3d::kZAxis, D2 * .5));
	}

	Draw2DBuffers(dc);
	
	dc.SetColor(oldclr);
	return Acad::eOk;
}

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

	int clr(256), oldclr;
	m_mapSpecXData.GetAt(_T("COLOR"), clr);
	oldclr = dc.GetColor();
	dc.SetColor(clr);

	if (Has3DBuffer())
	{
		Draw3DBuffers(dc);
		return Acad::eOk;
	}


	// 画四个主要部分，分别是 收缩段L1 喉道段L 扩散段L2 观察孔
	// 两个次要部分 前固定板 后固定板

	double D(GetD()), B1(GetB1()), B2(GetB2()), b(Getb()), N(GetN()), K(GetK());
	double L1(GetL1()), L(GetL()), L2(GetL2()), t(GetT()); 
	double La(GetLa()), D1(GetD1()), D2(GetD2()), h(Geth());

	AcDbCurve *pCurve = GetBaseCurve();
	AcGePoint3d ptS(AcGePoint3d::kOrigin), ptE(AcGePoint3d::kOrigin);
	pCurve->getStartPoint(ptS);
	pCurve->getEndPoint(ptE);
	AcGeVector3d vt(ptE - ptS);
	vt.normalize();
	AcGeVector3d vtN(AcGeVector3d::kIdentity);
	pCurve->getFirstDeriv(ptS, vtN);
	vtN.normalize();
	DELETE_PTR(pCurve);

	// 四个截面起点
	AcGeVector3d Z(AcGeVector3d::kZAxis);
	AcGePoint3d pt0(ptS), pt1(ptS + vt * L1), pt2(ptS + vt *(L1 + L)), pt3(ptS + vt *(L1 + L + L2));
	pt2 -= Z * N;
	pt3 -= Z * K;

	AcDbLine line(ptS, ptE);

	AcDb3dSolid *p = makeSolid(B1, D, pt0, b, D, pt1, t, vtN, &line);
	if (p)
	{
		p->setTransparency(transparency());
		Add3DBuffer(p);
	}

	p = makeSolid(b, D, pt1, b, D + N, pt2, t, vtN, &line);
	if (p)
	{
		p->setTransparency(transparency());
		Add3DBuffer(p);
	}

	p = makeSolid(b, D + N, pt2, B2, D + K, pt3, t, vtN, &line);
	if (p) 
	{
		p->setTransparency(transparency());
		Add3DBuffer(p);
	}

	// 观察孔
	// 通过 La 得到 宽度
	if (!EQUAL_ZERO(La))
	{
		double len = ((La + D1 * .5) * B1) / (2 * L1);
		ptS += Z * D;
		pt0 = ptS + vt * (L1 - (La + D1 * .5));
		vt.rotateBy(PI * .5, AcGeVector3d::kZAxis);
		p = makeLookupHold(pt0, vt, len, D1, D2, t, h, b);
		if (p)
		{
			p->setTransparency(transparency());
			Add3DBuffer(p);
		}
	}

	Draw3DBuffers(dc);
	dc.SetColor(oldclr);
	return Acad::eOk;
}

bool AecDbRiverGroove::TransformAssocInf(int nInf,const AcGeMatrix3d& xform)
{
	return false;
}

LPCTSTR	AecDbRiverGroove::GetGripCmd() const
{
	return NULL;
}

void AecDbRiverGroove::SetDashLayer(AcDbObjectId& idLayer)
{
}

AcDbObjectId AecDbRiverGroove::GetDashLayer() const
{
	return AcDbObjectId::kNull;
}

void AecDbRiverGroove::SetCenterLayer(AcDbObjectId& idLayer)
{

}

AcDbObjectId AecDbRiverGroove::GetCenterLayer() const
{
	return AcDbObjectId::kNull;
}

bool AecDbRiverGroove::GetSrcString(CString &src)
{
	assertReadEnabled();
	return m_mapSpecXData.GetAt(_T("_SRC_STRING_"), src) == 0 ? false : true;
}

void AecDbRiverGroove::SetSrcString(LPCTSTR src)
{
	assertWriteEnabled();
	if (src && !CString(src).IsEmpty())
		m_mapSpecXData.SetAt(_T("_SRC_STRING_"), src);
}

SHJson::WValue& AecDbRiverGroove::ToJson(bool bExprotGeo) const
{
	assertReadEnabled();
	return AecDbEwPipeBase::ToJson(bExprotGeo);
}

bool AecDbRiverGroove::ByJson(const SHJson::WValue &v)
{
	AssertWriteEnabled();
	return AecDbEwPipeBase::ByJson(v);
}

#include "HlrCutOption.h"
void AecDbRiverGroove::ProcessHlrResult(const AcArray<AcDbEntity *> &ar
	, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr
	, AcArray<AcDbEntity *> &output) const
{
	HlrCutOption::ProcessHlrResult(this
		, FALSE
		, .0
		, HlrCutOption::getHlrBLK_PARAEQU()
		, ar
		, preAr
		, output);
}