#include "StdAfx.h"
#include "PipeCableData.h"
#include "coreTools.h"
#include "AecCableTool.h"
#include <algorithm>
#include "AecDb3dRoadAxisLine.h"
#include "KTsetting.h"
#include "AecDbShEarthWorm.h"
#include "AecDbEarthWorm.h"

namespace
{
	// 检查是否满足 <Flag: ... > 类型
	bool AnalyFlag(LPCTSTR psz, LPCTSTR pszFlag, std::vector<CString> &items) 
	{
		if (!psz || !pszFlag) return false;
		CString str(psz);

		int idx1 = str.Find(CString(_T("<")) + pszFlag +_T(":"));
		if (idx1 == -1) return false;
		idx1 += CString(pszFlag).GetLength() + 2;

		int idx2 = str.Find(_T(">"), idx1);
		if (idx2 == -1) return false;

		CString content = str.Mid(idx1, idx2 - idx1);
		CoreTools::SplitString(content, _T('|'), items);

		return !items.empty();
	}
}

namespace PIPECABLE
{
	HOLDER::HOLDER()
		: m_nRow(4)
		, m_dVSpace(0.5)
		, m_dDistFrTop(0.5)
		, m_dL(600.0)
		, m_dW(40.0)
		, m_dt(6.0)
		, m_sMaterial(_T("不锈钢板"))
		, m_sSpec(_T("通信"))
		, m_nPos(0)
		, m_dHSpace(2.0)
		, m_nNo(0)
		, m_id3DEqu(-1)
		, m_nRoomIdx(-1)
		, m_sOffset(_T(""))
	{
		m_cabling.initSubCabling(m_nRow);
	}

	HOLDER::HOLDER(const HOLDER & holder)
		: m_nRow(holder.m_nRow)
		, m_dVSpace(holder.m_dVSpace)
		, m_dDistFrTop(holder.m_dDistFrTop)
		, m_dL(holder.m_dL)
		, m_dW(holder.m_dW)
		, m_dt(holder.m_dt)
		, m_sMaterial(holder.m_sMaterial)
		, m_sSpec(holder.m_sSpec)
		, m_nPos(holder.m_nPos)
		, m_dHSpace(holder.m_dHSpace)
		, m_nNo(holder.m_nNo)
		, m_id3DEqu(holder.m_id3DEqu)
		, m_nRoomIdx(holder.m_nRoomIdx)
		, m_sOffset(holder.m_sOffset)
		, m_cabling(holder.m_cabling)
	{ }

	bool HOLDER::fromString(LPCTSTR psz)
	{
		std::vector<CString> items(0);
		if (!AnalyFlag(psz, HOLDER::flag(), items)) return false;

		if (items.size() < 13) return false;

		m_nRoomIdx		= TypeConvert::s2i(items.at(0));
		m_nPos			= TypeConvert::s2i(items.at(1));
		m_nRow			= TypeConvert::s2i(items.at(2));
		m_dVSpace		= TypeConvert::s2f(items.at(3));
		m_dHSpace		= TypeConvert::s2f(items.at(4));
		m_dDistFrTop	= TypeConvert::s2f(items.at(5));
		m_dL			= TypeConvert::s2f(items.at(6));
		m_dW			= TypeConvert::s2f(items.at(7));
		m_dt			= TypeConvert::s2f(items.at(8));
		m_sMaterial		= items.at(9);
		m_sSpec			= items.at(10);
		m_sOffset		= items.at(11);
		m_nNo			= TypeConvert::s2i(items.at(12));

		if (items.size() < 14)
			m_id3DEqu = -1;
		else
			m_id3DEqu = TypeConvert::s2i(items.at(13));

		m_cabling.initSubCabling(m_nRow);
		if (items.size() > 14)
		{
			// 这段代码主要为了兼容以前长度为13时候的脚本
			// 如果长度为13，m_cabling脚本默认为无效
			// 如果长度为14，m_cabling也不一定有效，要看 cabling内的m_bValid值
			m_cabling.fromString(items.at(14));
		}
		
		return true;
	}

	CString HOLDER::toString(const int & iRoom, const CString & sOffset)
	{
		//HOLDER:房间|左右位置|层数|垂直间隙|水平间隙|距顶D|长度|宽度|厚度|材料|用途|偏移=(,,,)|编号|3D索引
		CString sScript(_T(""));
		sScript.Format(_T("<%s:%d|%d|%d|%.3f|%.3f|%.3f|%.3f|%.3f|%.3f|%s|%s|%s|%d|%d|%s>")
			, HOLDER::flag()
			, iRoom
			, m_nPos
			, m_nRow
			, m_dVSpace
			, m_dHSpace
			, m_dDistFrTop
			, m_dL
			, m_dW
			, m_dt
			, m_sMaterial
			, m_sSpec
			, sOffset
			, m_nNo
			, m_id3DEqu
			, m_cabling.toString());
		return sScript;
	}

	/////////////////////////////////////////////////////////

	HANGER::HANGER()
		: m_nRow(4)
		, m_dVSpace(0.2)
		, m_dHSpace(1.0)
		, m_dDistFrTop(0.2)
		, m_dL(600)
		, m_dW(30)
		, m_dt(5)
		, m_sMaterial(_T("普通镀锌钢板"))
		, m_sSpec(_T("预留"))
		, m_dX(1.0)
		, m_nNo(1)
		, m_id3DEqu(-1)
		, m_nRoomIdx(-1)
		, m_sOffset(_T(""))
	{
		m_cabling.initSubCabling(m_nRow);
	}

	HANGER::HANGER(const HANGER & hanger)
		: m_nRow(hanger.m_nRow)
		, m_dVSpace(hanger.m_dVSpace)
		, m_dHSpace(hanger.m_dHSpace)
		, m_dDistFrTop(hanger.m_dDistFrTop)
		, m_dL(hanger.m_dL)
		, m_dW(hanger.m_dW)
		, m_dt(hanger.m_dt)
		, m_sMaterial(hanger.m_sMaterial)
		, m_sSpec(hanger.m_sSpec)
		, m_dX(hanger.m_dX)
		, m_nNo(hanger.m_nNo)
		, m_id3DEqu(hanger.m_id3DEqu)
		, m_nRoomIdx(hanger.m_nRoomIdx)
		, m_sOffset(hanger.m_sOffset)
		, m_cabling(hanger.m_cabling)
	{ }

	bool HANGER::fromString(LPCTSTR psz)
	{
		std::vector<CString> items(0);
		if (!AnalyFlag(psz, HANGER::flag(), items)) return false;

		if (items.size() < 13) return false;

		m_nRoomIdx		= TypeConvert::s2i(items.at(0));
		m_nRow			= TypeConvert::s2i(items.at(1));
		m_dVSpace		= TypeConvert::s2f(items.at(2));
		m_dHSpace		= TypeConvert::s2f(items.at(3));
		m_dX			= TypeConvert::s2f(items.at(4));
		m_dDistFrTop	= TypeConvert::s2f(items.at(5));
		m_dL			= TypeConvert::s2f(items.at(6));
		m_dW			= TypeConvert::s2f(items.at(7));
		m_dt			= TypeConvert::s2f(items.at(8));
		m_sMaterial		= items.at(9);
		m_sSpec			= items.at(10);
		m_sOffset		= items.at(11);
		m_nNo			= TypeConvert::s2i(items.at(12));

		if (items.size() < 14)
			m_id3DEqu	= -1;
		else
			m_id3DEqu	= TypeConvert::s2i(items.at(13));

		m_cabling.initSubCabling(m_nRow);
		if (items.size() > 14)
		{
			// 这段代码主要为了兼容以前长度为13时候的脚本
			// 如果长度为13，m_cabling脚本默认为无效
			// 如果长度为14，m_cabling也不一定有效，要看 cabling内的m_bValid值
			m_cabling.fromString(items.at(14));
		}

		return true;
	}

	CString HANGER::toString(const int & iRoom, const CString & sOffset)
	{
		CString sScript(_T(""));

		//HANGER:房间|层数|垂直间隙|水平间隙|左侧距离|距顶D|长度|宽度|厚度|材料|用途|偏移(,,,)|编号|3d
		sScript.Format(_T("<%s:%d|%d|%.3f|%.3f|%.3f|%.3f|%.3f|%.3f|%.3f|%s|%s|%s|%d|%d|%s>")
			, HANGER::flag()
			, iRoom
			, m_nRow
			, m_dVSpace
			, m_dHSpace
			, m_dX
			, m_dDistFrTop
			, m_dL
			, m_dW
			, m_dt
			, m_sMaterial
			, m_sSpec
			, sOffset
			, m_nNo
			, m_id3DEqu
			, m_cabling.toString());
		return sScript;
	}

	/////////////////////////////////////////////////////////

	BOSS::BOSS()
		: m_sSpec(_T(""))
		, m_dD(0.5)
		, m_dX(2.0)
		, m_dW(500.0)
		, m_dH(500.0)
		, m_dL(500.0)
		, m_nPos(0)
		, m_dPD(500.0)
		, m_sMertial(_T(""))
		, m_sCurrSys(_T(""))
		, m_dDn(300.0)
		, m_dt(10.0)
		, m_dWeight(77.0)
		, m_nPipeColor(1)
		, m_linetypeString(_T("ByLayer"))
		, m_nNo(-1)
		, m_nKind(0)
		, m_nRows(2)
		, m_dh(600)
		, m_id3DEqu(-1)
		, m_nRoomIdx(-1)
		, m_sOffset(_T(""))
	{
	}

	BOSS::BOSS(const BOSS & boss)
		: m_sSpec(boss.m_sSpec)
		, m_dD(boss.m_dD)
		, m_dX(boss.m_dX)
		, m_dW(boss.m_dW)
		, m_dH(boss.m_dH)
		, m_dL(boss.m_dL)
		, m_nPos(boss.m_nPos)
		, m_dPD(boss.m_dPD)
		, m_sMertial(boss.m_sMertial)
		, m_sCurrSys(boss.m_sCurrSys)
		, m_dDn(boss.m_dDn)
		, m_dt(boss.m_dt)
		, m_dWeight(boss.m_dWeight)
		, m_nPipeColor(boss.m_nPipeColor)
		, m_linetypeString(boss.m_linetypeString)
		, m_nNo(boss.m_nNo)
		, m_nKind(boss.m_nKind)
		, m_nRows(boss.m_nRows)
		, m_dh(boss.m_dh)
		, m_id3DEqu(boss.m_id3DEqu)
		, m_nRoomIdx(boss.m_nRoomIdx)
		, m_sOffset(boss.m_sOffset)
	{ }

	bool BOSS::fromString(LPCTSTR psz)
	{
		std::vector<CString> items(0);
		if (!AnalyFlag(psz, BOSS::flag(), items)) return false;

		if (items.size() < 21) return false;

		m_nRoomIdx			= TypeConvert::s2i(items.at(0));
		m_nPos				= TypeConvert::s2i(items.at(1));
		m_dD				= TypeConvert::s2f(items.at(2));
		m_dX				= TypeConvert::s2f(items.at(3));
		m_dW				= TypeConvert::s2f(items.at(4));
		m_dH				= TypeConvert::s2f(items.at(5));
		m_dL				= TypeConvert::s2f(items.at(6));
		m_dPD				= TypeConvert::s2f(items.at(7));
		m_sSpec				= items.at(8);
		m_dDn				= TypeConvert::s2f(items.at(9));
		m_dt				= TypeConvert::s2f(items.at(10));
		m_dWeight			= TypeConvert::s2f(items.at(11));
		m_sMertial			= items.at(12);
		m_sCurrSys			= items.at(13);
		m_nPipeColor		= TypeConvert::s2i(items.at(14));
		m_linetypeString	= items.at(15);
		m_nNo				= TypeConvert::s2i(items.at(16));
		m_nKind				= TypeConvert::s2i(items.at(17));
		m_sOffset			= items.at(18);
		m_nRows				= TypeConvert::s2i(items.at(19));
		m_dh				= TypeConvert::s2f(items.at(20));


		if (items.size() < 22)
			m_id3DEqu		= -1;
		else
			m_id3DEqu		= TypeConvert::s2i(items.at(21));

		return true;
	}

	CString BOSS::toString(const int & iRoom, const CString & sOffset)
	{
		CString sScript(_T(""));
		//BOSS: 房间|左右位置|侧间隙|水平间隙|宽|高|长|直径|用途|公称直径｜壁厚｜重量｜管道材质｜管道系统｜颜色｜线形｜编号|支墩类型|偏移|行|间隙|3D索引
		sScript.Format(_T("<%s:%d|%d|%.3f|%.3f|%.3f|%.3f|%.3f|%.3f|%s|%.3f|%.3f|%.3f|%s|%s|%d|%s|%d|%d|%s|%d|%.3f|%d>")
			, BOSS::flag()
			, iRoom
			, m_nPos
			, m_dD
			, m_dX
			, m_dW
			, m_dH
			, m_dL
			, m_dPD
			, m_sSpec
			, m_dDn
			, m_dt
			, m_dWeight
			, m_sMertial
			, m_sCurrSys
			, m_nPipeColor
			, m_linetypeString
			, m_nNo
			, m_nKind
			, sOffset
			, m_nRows
			, m_dh
			, m_id3DEqu);
		return sScript;
	}

	SubCabling::SubCabling()
		: m_nFloor(1)
		, m_nCount(1)
		, m_nClr(4)
		, m_dDn(.0)
		, m_dSpace(10.)
		, m_dD(.0)
		, m_linetype(_T(""))
		, m_sModel(_T(""))
		, m_sFactory(_T(""))
		, m_bValid(false)
	{ }

	SubCabling::SubCabling(const SubCabling & cab)
		: m_nFloor(cab.m_nFloor)
		, m_nCount(cab.m_nCount)
		, m_nClr(cab.m_nClr)
		, m_dDn(cab.m_dDn)
		, m_dSpace(cab.m_dSpace)
		, m_dD(cab.m_dD)
		, m_linetype(cab.m_linetype)
		, m_sModel(cab.m_sModel)
		, m_sFactory(cab.m_sFactory)
		, m_bValid(cab.m_bValid)
	{ }

	SubCabling::SubCabling(const int & floor
		, const int & count
		, const int & clr
		, const int & no
		, const double & Dn
		, const double & space
		, const double & D
		, LPCTSTR linetype
		, LPCTSTR model
		, LPCTSTR factory)
		: m_nFloor(floor)
		, m_nCount(count)
		, m_nClr(clr)
		, m_dDn(Dn)
		, m_dSpace(space)
		, m_dD(D)
		, m_linetype(linetype)
		, m_sModel(model)
		, m_sFactory(factory)
		, m_bValid(true)
	{ }

	CString SubCabling::toString()
	{
		CString str(flag() + _T(":"));
		if (!m_bValid) return str;

		str += CoreTools::merageString(gSplitCHAR
			, _T("%d%d%d%f%f%f%s%s%s")
			, 3
			, m_nFloor
			, m_nCount
			, m_nClr
			, m_dDn
			, m_dSpace
			, m_dD
			, m_linetype
			, m_sModel
			, m_sFactory);

		return str;
	}

	bool SubCabling::fromString(LPCTSTR psz)
	{
		m_bValid = false;

		if (!psz) return false;

		CString _flag(flag() + _T(":"));

		CString str(psz);
		if (str.Compare(_flag) == 0) return false;	// 不存在线缆

		// 去掉 "Sub:"
		str = str.TrimLeft(_flag);

		std::vector<CString> items(0);
		CoreTools::SplitString(str, gSplitCHAR, items);
		if (items.size() < 9) return false;

		m_nFloor	= TypeConvert::s2i(items.at(0));
		m_nCount	= TypeConvert::s2i(items.at(1));
		m_nClr		= TypeConvert::s2i(items.at(2));
		m_dDn		= TypeConvert::s2f(items.at(3));
		m_dSpace	= TypeConvert::s2f(items.at(4));
		m_dD		= TypeConvert::s2f(items.at(5));
		m_linetype	= items.at(6);
		m_sModel	= items.at(7);
		m_sFactory	= items.at(8);

		m_bValid = true;
		return true;
	}

	CString SubCabling::flag()
	{
		return _T("sub");
	}

	Cabling::Cabling()
		: m_cables(0)
	{ }

	Cabling::Cabling(const Cabling & cabling)
		: m_cables(cabling.m_cables)
	{ }

	bool Cabling::hasCabling() const
	{
		for (size_t i = 0; i < m_cables.size(); ++i)
		{
			if (m_cables[i].m_bValid)
				return true;
		}
		return false;
	}

	CString Cabling::toString()
	{
		CString str(flag() + _T(":"));

		for (size_t i = 0; i < m_cables.size(); ++i)
		{
			str += m_cables[i].toString();
			str += gSubSplitCHAR;
		}

		return str.Left(str.GetLength() - 1);
	}

	bool Cabling::fromString(LPCTSTR psz)
	{
		if (!psz) return false;

		const CString _flag(flag() + _T(":"));

		CString str(psz);
		if (str.Compare(_flag) == 0) return false;	// 不存在线缆

		// 去掉 "Cab:"
		str = str.TrimLeft(_flag);

		std::vector<CString> items(0);
		if (!CoreTools::SplitString(str, gSubSplitCHAR, items)) return false;

		if (m_cables.size() != items.size()) return false;

		SubCabling subcab;
		for (size_t i = 0; i < items.size(); ++i)
		{
			m_cables[i].fromString(items[i]);
		}
		
		return true;
	}

	void Cabling::sort()
	{
		std::sort(m_cables.begin(), m_cables.end(), SubCabling::_comp());
	}

	void Cabling::initSubCabling(const int &row)
	{
		m_cables.clear();
		m_cables.resize(row);
		for (size_t i = 0; i < m_cables.size(); ++i)
		{
			m_cables[i].m_bValid = false;
			m_cables[i].m_nFloor = i + 1;
		}
	}

	CString Cabling::flag()
	{
		return _T("cab");
	}

}

namespace PIPECABLE
{
	bool analyEwScript(LPCTSTR psz, LPCTSTR flag, std::vector<CString>& items)
	{
		if (!psz || !flag) return false;

		CString str(psz), strFlag(CString(_T("<")) + flag + _T(":"));

		int idx1 = str.Find(strFlag, 0), idx2(-1);
		while (idx1 != -1)
		{
			idx2 = str.Find(_T(">"), idx1);
			if (idx2 == -1) return false;
			items.push_back(str.Mid(idx1, idx2 - idx1 + 1));
			idx1 = str.Find(strFlag, idx2);
		}

		return !items.empty();
	}

	void connectPipeCable(std::map<CString, AcDbObjectIdArray*>& mapPosNoToIds)
	{
		AcDbObjectId id1, id2, id3;
		AecDbEwCable * pPipe1 = NULL;
		AecDbEwCable * pPipe2 = NULL;
		AecDbEwCable* pElbow = NULL;
		AcDbVoidPtrArray arFittingPtrs;
		typedef std::map<CString, AcDbObjectIdArray*>::iterator mIT;
		AcDbObjectIdArray *pArIds(NULL);

		for (mIT it = mapPosNoToIds.begin(); it != mapPosNoToIds.end(); it++)
		{
			pArIds = it->second;

			for (int ii = 0; ii < pArIds->length() - 1; ii++)
			{
				id1 = pArIds->at(ii);
				id2 = pArIds->at(ii + 1);

				if (Acad::eOk == acdbOpenAcDbEntity((AcDbEntity*&)pPipe1, id1, AcDb::kForWrite))
				{
					if (Acad::eOk == acdbOpenAcDbEntity((AcDbEntity*&)pPipe2, id2, AcDb::kForWrite))
					{
						pElbow = AecCableTool::MakeConnect(pPipe1, pPipe2);
						if (pElbow != NULL)
						{
							pPipe1->GetSpecialtyData()->GetAt(KEY_IDASS, id3);
							pElbow->GetSpecialtyData()->SetAt(KEY_IDASS, id3);

							pElbow->GetSpecialtyData()->SetAt(_T("COLOR"), pPipe1->colorIndex());

							pElbow->SetSingleLayer(pPipe1->GetSingleLayer());
							pElbow->SetDoubleLayer(pPipe1->GetDoubleLayer());

							pElbow->SetSingleLineType(pPipe1->GetSingleLineType());
							pElbow->SetDoubleLineType(pPipe1->GetDoubleLineType());

							pElbow->setLayer(pPipe1->layerId());
							pElbow->setLinetype(pPipe1->linetypeId());

							arFittingPtrs.append(pElbow);
						}
						pPipe2->close();
					}
					pPipe1->close();
				}
			}
		}

		AcDbObjectId id;
		AecDbEarthWorm* pEw = NULL;
		AecDbShEarthWorm* pShEw = NULL;

		for (int n = 0; n < arFittingPtrs.length(); n++)
		{
			pElbow = (AecDbEwCable*)arFittingPtrs.at(n);
			pElbow->GetSpecialtyData()->GetAt(KEY_IDASS, id3);

			CoreTools::AddToModelSpace(pElbow);
			id = pElbow->objectId();

			AcDbEntity* pEwEnt = NULL;
			if (Acad::eOk == acdbOpenAcDbEntity(pEwEnt, id3, AcDb::kForWrite))
			{
				pEw = AecDbEarthWorm::cast(pEwEnt);
				if (pEw != NULL)
				{
					pEw->AddAddtion(id);
				}
				
				pShEw = AecDbShEarthWorm::cast(pEwEnt);
				if (pShEw != NULL)
				{
					pShEw->AddAddtion(id);
				}
				pEwEnt->close();
			}
		}
	}

	void generateCable(AcArray<LineSeg>& arLnSegs
		, AcGePoint3dArray &arPtsBk
		, const SubCabling &sb
		, AcDbVoidPtrArray &ar)
	{
		if (arLnSegs.isEmpty()) return;

		AcDbLine ln;
		AcGePoint3d pt, ptOn;
		AcGeVector3d vtMove;
		AcGeMatrix3d xfMove;
		AcGePoint3dArray arPts;

		for (int k = 0; k < arLnSegs.length(); k++)//标准铺设条数
		{
			LineSeg& lg = arLnSegs.at(k);
			ln.setStartPoint(lg.ptFr);
			ln.setEndPoint(lg.ptTo);

			if (!arPtsBk.isEmpty())
			{
				pt = arPtsBk.first();
				ln.getClosestPointTo(pt, ptOn);

				vtMove = ptOn - pt;
				xfMove.setToTranslation(vtMove);
			}

			//每条轨迹按标准铺设路径铺设
			for (int n = 0; n < arPtsBk.length(); n++)
			{
				AcGePoint3d& ptIn = arPtsBk.at(n);
				ptIn.transformBy(xfMove);
				ptIn.z += AS_MUNITF(sb.m_dD) *.5;
			}

			AecDb3dRoadAxisLine* pALine = new AecDb3dRoadAxisLine;
			if (arPtsBk.isEmpty())//盾构的情况
			{
				arPts.removeAll();

				ptOn = lg.ptFr;
				ptOn.z += AS_MUNITF(sb.m_dD) *.5;
				arPts.append(ptOn);

				ptOn = lg.ptTo;
				ptOn.z += AS_MUNITF(sb.m_dD) *.5;
				arPts.append(ptOn);
				pALine->Create3dRoadAxisLine(lg.dD, sb.m_dDn, arPts);
			}
			else
			{
				pALine->Create3dRoadAxisLine(lg.dD, sb.m_dDn, arPtsBk);
			}

			if (pALine->GetCurveSegCount() <= 0)
			{
				DELETE_PTR(pALine);
				return;
			}

			AecDbEwCable* pCable = new AecDbEwCable;
			pCable->GetSpecialtyData()->SetAt(CABLE_D, AS_MUNITF(sb.m_dD));
			pCable->GetSpecialtyData()->SetAt(CABLE_MODEL, sb.m_sModel);
			pCable->GetSpecialtyData()->SetAt(CABLE_FACTORY, sb.m_sFactory);
			pCable->GetSpecialtyData()->SetAt(CABLE_RATIO, sb.m_dDn);
			pCable->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 1);
			pCable->SetBaseCurve(pALine);

			pCable->SetSection(AS_MUNITF(sb.m_dD), 0.0);
			pCable->GetSpecialtyData()->SetAt(_T("COLOR"), sb.m_nClr);

			pCable->SetSingleLineType(KTSetting::InitLineStyle(lg.szLntype));
			pCable->SetDoubleLineType(KTSetting::InitLineStyle(lg.szLntype));
			DELETE_PTR(pALine);

			ar.append(pCable);
		}
	}
}