// HidePipeDlg.cpp : implementation file
//

#include "stdafx.h"
//#include "twtkernal.h"
#include "HidePipeDlg.h"
#include "DbDoubleLinePipe.h"
#include "DbPipeValve.h"
#include "DbEquipment.h"
#include "PipeWireMonitor.h"

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


TValveReactor *pValveReactor = NULL;
std::vector<std::pair<IdGroup, int> > GetGroupIdConfig();
void SetGroupIdConfig(std::vector<std::pair<IdGroup, int> > vec);
/////////////////////////////////////////////////////////////////////////////
// CHidePipeDlg dialog

Entity GetHeightestPipe(Entity ent, XPoint pt)
{
	Entity entPipe = ent;
	RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE,ATS_DOUBLELINEPIPE"), NULL);
    PickSet ss(SS_FREE);
    XPoint ptUcs = Wcs2Ucs(pt);
    GetPointPickSet(ptUcs, ss, rbMaskPipe, 5);
    double len = ss.Length();
	if (len < 2)
	{
		return entPipe;
	}

	XPoint ptS, ptE, ptM;
	GetPipePoint(ent, ptS, ptE, ptM);
	ptS.z = 0;
	ptE.z = 0;
	AcGeVector3d vt = ptS - ptE;
	AcGeTol tol;
	tol.setEqualVector(0.001);
	double dEle = ptM.z;
	for (long l = 0; l < len; l++)
	{
		GetPipePoint(ss[l], ptS, ptE, ptM);
		ptS.z = 0;
		ptE.z = 0;
		AcGeVector3d vtFind = ptS - ptE;
		if (vtFind.isParallelTo(vt, tol) && ptM.z > dEle)
		{
			dEle = ptM.z;
			entPipe = ss[l];
		}
	}
	return entPipe;
}

// 管线遮挡
extern CString GetValveLayBySys(TPipeSys::SysType sys);
extern CString GetEquipLayBySys(TPipeSys::SysType sys);

AcDbObjectId InsBlkByName(const TCHAR* szName, XPoint pt, double nAng, const TCHAR* szLayer, AcGeScale3d sc)
{
	InitLayer(szLayer);
	AcDbObjectId recordId = GetBlkIdByName(szName);
	if(!recordId)
		return recordId;

	AcDbBlockReference *pRef = new AcDbBlockReference(pt, recordId);
	pRef->setScaleFactors(sc);
	pRef->setRotation(nAng);
	pRef->setLayer(InitLayer(szLayer));
	AcDbObjectId id = AddToCurrentSpace(pRef, Adesk::kTrue);
	return id;
}

void HidePipeByEquipment()
{
	CTemporaryResourceOverride vTemp;
	CHidePipeDlg dlg;
	dlg.Create(IDD_DIALOG_HIDEPIPE, acedGetAcadFrame());
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	Entity entPipe;
	XPoint ptPick;
	RBList rbMask(RTDXF0, _T("ATS_PIPE,ATS_DOUBLELINEPIPE"), NULL);
	while (true)
	{
		if (acedGetPoint(NULL, _T("\n请选择插入点:<退出>"), ptPick) != RTNORM)
		{
			dlg.DestroyWindow();
			return;
		}

		PickSet ss(SS_FREE);
		GetPointPickSet(ptPick, ss, rbMask, 1);
		ptPick = Ucs2Wcs(ptPick);
		if (ss.Length() == 0)
		{
			continue;
		}
		entPipe = ss[0l];
		entPipe = GetHeightestPipe(entPipe, ptPick);

		CString csDwb = g_csDwbPath + _T("TWTSYS");	
		XString sTmp, sTmp2;

		if(LoadDwbBlock(csDwb, _T("00000557"), sTmp) != RTNORM)  //断线
			return;
		if(LoadDwbBlock(csDwb, _T("00000558"), sTmp2) != RTNORM)  //双管断线
			return;	

		TCHAR szLayer[256];
		entPipe.GetData(8, szLayer);
		Entity entLast;
		OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe && !pPipe->IsVertical())
		{
			pPipe->getClosestPointTo(ptPick, ptPick);
			double nRotate = ads_angle(pPipe->GetStartPoint(), pPipe->GetEndPoint());
			double dDn = pPipe->GetDnDiameter() * 100;
			dDn = dDn / DocGetPScale();
			if (DocGetMeterUnitDraw())
			{
				dDn = dDn / 1000.0;
			}

			AcDbObjectId idBlk;
			double dScale = 0.0;
			double dWidth = 0.0;
			dlg.UpdateData(TRUE);
			dScale = dlg.m_dDst * 0.1;

			AcGePoint3d pt1, pt2;
			AcGeVector3d vt = pPipe->GetStartPoint() - pPipe->GetEndPoint();
			vt.normalize();

			double dUnt = DocGetPScale() / 100;
			CString csDwb = g_csDwbPath + _T("TwtSys");	
			XString xsTmp, xsTmp2;
			if(LoadDwbBlock(csDwb, _T("00000132"), xsTmp) != RTNORM)  //断线
				return;	
			if(LoadDwbBlock(csDwb, _T("00000478"), xsTmp2) != RTNORM) //双线管断线
				return;

			TDbPipeValve *pValve = new TDbPipeValve;
			AcDbObjectId idBlk1, idBlk2;
			if(pPipe->isKindOf(TDbDoubleLinePipe::desc()))
			{
				dWidth = 2;
				pt1 = ptPick + vt * dScale * dUnt * 500;
				pt2 = ptPick - vt * dScale * dUnt * 500;
				dDn *= dUnt;
				dUnt *= 500;
				dScale *= dUnt;
				AcGeScale3d sc(dDn);
				idBlk1 = InsBlkByName(xsTmp2, pt1, nRotate, pPipe->GetLayer(), sc);
				idBlk2 = InsBlkByName(xsTmp2, pt2, nRotate, pPipe->GetLayer(), sc);
				idBlk = GetBlkIdByName(sTmp2);
				pValve->setLayer(InitLayer(LAY_EQUIP_VALVE));
			}
			else
			{
				dWidth = 1000;
				pt1 = ptPick + vt * dScale * dWidth * dUnt / 2;
				pt2 = ptPick - vt * dScale * dWidth * dUnt / 2;
				AcGeScale3d sc(dUnt);
				idBlk1 = InsBlkByName(xsTmp, pt1, nRotate, GetEquipLayBySys(pPipe->GetSysType()), sc);
				idBlk2 = InsBlkByName(xsTmp, pt2, nRotate, GetEquipLayBySys(pPipe->GetSysType()), sc);
				idBlk = GetBlkIdByName(sTmp);
				pValve->setLayer(InitLayer(GetValveLayBySys(pPipe->GetSysType())));
			}

			pValve->SetBlock2d(idBlk);
			pValve->SetLocation(ptPick);
			pValve->SetWidth(dWidth);
			pValve->SetScale(dScale);
			pValve->setColor(AcCmColor()); //随层
			pValve->SetDirection(vt);
			pValve->SetSysType(pPipe->GetSysType());
			pValve->SetPipeId(pPipe->id());
			AcDbObjectId idNew = AddToCurrentSpace(pValve, Adesk::kTrue);
			// 绑定三个id，如果其中一个执行删除操作，三个实体全部删除
			IdGroup group;
			group.idBlk1 = idBlk1;
			group.idBlk2 = idBlk2;
			group.idValve = idNew;
			std::vector<std::pair<IdGroup, int> > vecId = GetGroupIdConfig();
			vecId.push_back(std::make_pair(group, 1));
			SetGroupIdConfig(vecId);
		}
		OPENOBJ_END();
		TPipePerDocData *pData = GetCurPipeDocData();
		pData->ApplyUpdates();
	}
	dlg.DestroyWindow();
}

int TValveReactor::m_nCount = 0;
// 建立命令的监测
void TValveReactor::Attach()
{ 
	AcDbDatabase *pDb = curDoc()->database();
	if(pValveReactor == NULL)
	{
		pValveReactor = new TValveReactor;
	}
	m_nCount++;
	pDb->addReactor(pValveReactor);
}

// 除去命令的监测
void TValveReactor::Detach()
{
	if(pValveReactor != NULL) 
	{
		AcDbDatabase *pDb = curDoc()->database();
		pDb->removeReactor(pValveReactor);
		m_nCount--;
	}

	if (m_nCount == 0 && pValveReactor != NULL)
	{
		delete pValveReactor; 
		pValveReactor=NULL;
	}
}

void TValveReactor::objectAppended(const AcDbDatabase* dwg, const AcDbObject* dbObj)
{
	AcDbDatabaseReactor::objectAppended(dwg, dbObj);
}

void TValveReactor::objectErased(const AcDbDatabase* dwg, const AcDbObject* dbObj, Adesk::Boolean pErased)
{
	XString sCmdNames;
	xg_getvar(_T("CMDNAMES"), sCmdNames);
    if(	_tcsicmp(sCmdNames, _T("EXPLODE")) == 0)
		return;
	AcDbObjectId id = dbObj->id();
	std::vector<std::pair<IdGroup, int> > vecId = GetGroupIdConfig();
	std::vector<std::pair<IdGroup, int> >::iterator it = vecId.begin();
	AcDbObjectId idBlk1, idBlk2, idValve;
	for (; it != vecId.end(); it++)
	{
		if (it->second == 0 && pErased == 1)
		{
			continue;
		}
		idBlk1 = it->first.idBlk1;
		idBlk2 = it->first.idBlk2;
		idValve = it->first.idValve;
		if (id == idBlk1 || id == idBlk2 || id == idValve)
		{
			if (pErased == 1 && it->second == 1)
			{
				it->second = 0;
				SetGroupIdConfig(vecId);
				if (!idBlk1.isErased())
				{
					Entity ent;
					ads_name name;
					acdbGetAdsName(name, idBlk1);
					ent = name;
					ent.Erase();
				}
				
				if (!idBlk2.isErased())
				{
					Entity ent;
					ads_name name;
					acdbGetAdsName(name, idBlk2);
					ent = name;
					ent.Erase();
				}
				
				if (!idValve.isErased())
				{
					Entity ent;
					ads_name name;
					acdbGetAdsName(name, idValve);
					ent = name;
					ent.Erase();
				}
			}
			else
			{
				it->second = 1;
				SetGroupIdConfig(vecId);
			}
			
			break;
		}
	}
}

ACRX_DXF_DEFINE_MEMBERS(TDbGroupIdConfig, AcDbObject,AcDb::kDHL_CURRENT,
						AcDb::kMReleaseCurrent,1, TCH_GROUPIDCONFIG,TWT_KERNAL);

Acad::ErrorStatus TDbGroupIdConfig::dwgInFields (AcDbDwgFiler *pFiler)
{
	Acad::ErrorStatus es=Acad::eOk;
	es = AcDbObject::dwgInFields(pFiler);
	if(es != Acad::eOk)
		return es;
	
	Adesk::UInt16 nNum;
	pFiler->readItem(&nNum);
	m_vecIdGroup.clear();
	for (int i = 0; i < nNum; i++)
	{
		IdGroup group;
		AcDbSoftPointerId id1, id2, id3;
		pFiler->readItem(&id1);
		pFiler->readItem(&id2);
		pFiler->readItem(&id3);
		group.idBlk1 = id1;
		group.idBlk2 = id2;
		group.idValve = id3;
		m_vecIdGroup.push_back(std::make_pair(group, 1));
	}
	return es;
}

int GetVectorSize(std::vector<std::pair<IdGroup, int> > vec)
{
	int nNum = 0;
	std::vector<std::pair<IdGroup, int> >::const_iterator it = vec.begin();
	for (; it != vec.end(); it++)
	{
		if (it->second == 0)
		{
			continue;
		}
		nNum++;
	}
	return nNum;
}

Acad::ErrorStatus TDbGroupIdConfig::dwgOutFields (AcDbDwgFiler *pFiler) const
{
    Acad::ErrorStatus es=Acad::eOk;
	es = AcDbObject::dwgOutFields(pFiler);
    if(es != Acad::eOk) 
		return es;
	
	Adesk::UInt16 nNum = GetVectorSize(m_vecIdGroup);
    pFiler->writeItem(nNum);
	std::vector<std::pair<IdGroup, int> >::const_iterator it = m_vecIdGroup.begin();
	for (; it != m_vecIdGroup.end(); it++)
	{
		if (it->second == 0)
		{
			continue;
		}
		pFiler->writeItem((AcDbSoftPointerId)it->first.idBlk1);
		pFiler->writeItem((AcDbSoftPointerId)it->first.idBlk2);
		pFiler->writeItem((AcDbSoftPointerId)it->first.idValve);
	}
	return es;
}

void InitGroupIdConfig(BOOL bTrue)
{
    if(bTrue) 
	{
        TDbGroupIdConfig::rxInit();
    }
	else 
	{
		deleteAcRxClass(TDbGroupIdConfig::desc());
    }
}

std::vector<std::pair<IdGroup, int> > GetGroupIdConfig()
{
	std::vector<std::pair<IdGroup, int> > vec;
	Acad::ErrorStatus es=Acad::eOk;
	AcDbDatabase *pDb = curDoc()->database();
	
	AcDbDictionary* pRootDict=NULL;
	es=pDb->getNamedObjectsDictionary(pRootDict,AcDb::kForRead);
	assert(es==Acad::eOk);
	
	AcDbObject* pObj;
	es=pRootDict->getAt(_T("TWT_GROUPIDCONFIG"),pObj,AcDb::kForRead);
	if (es==Acad::eOk) 
	{
		TDbGroupIdConfig *pGroup = (TDbGroupIdConfig *)pObj;
		if (pGroup != NULL)
		{
			vec = pGroup->GetGroup();
		}
		pObj->close();
	} 
	else 
	{
		if (pRootDict->upgradeOpen() == Acad::eOk) 
		{
			TDbGroupIdConfig *pConfig = new TDbGroupIdConfig;
			if (pConfig!=NULL) 
			{
				AcDbObjectId idConfig;
				es=pRootDict->setAt(_T("TWT_GROUPIDCONFIG"),pConfig,idConfig);
				if (es==Acad::eOk) 
				{
					pConfig->close();
				} 
				else
				{
					delete pConfig;
				}
			}
			pRootDict->downgradeOpen();
		}
	}
	pRootDict->close();
	return vec;
}

void SetGroupIdConfig(std::vector<std::pair<IdGroup, int> > vec)
{
	TDbGroupIdConfig *pConfig=NULL;
	//当前数据库
	AcDbDatabase *pDb = curDoc()->database(); 
	AcDb::OpenMode opMode = AcDb::kForWrite;
	
	if (pDb!=NULL) 
	{
		Acad::ErrorStatus es=Acad::eOk;
		AcDbDictionary* pRootDict=NULL;
		es=pDb->getNamedObjectsDictionary(pRootDict,AcDb::kForRead);
		if (es==Acad::eOk) 
		{
            AcDbObjectId idExist;
			es=pRootDict->getAt(_T("TWT_GROUPIDCONFIG"), idExist);
			if (es==Acad::eOk && !!idExist) 
			{
                es=acdbOpenObject(pConfig, idExist, opMode);
				if (pConfig != NULL)
				{
					pConfig->SetGroup(vec);
					pConfig->close();
				}
			}
            else if(opMode==AcDb::kForWrite) 
			{
                if ((es = pRootDict->upgradeOpen()) == Acad::eOk) 
				{
                    pRootDict->assertWriteEnabled();
                    pConfig = new TDbGroupIdConfig;
                    if (pConfig!=NULL) 
					{
						pConfig->SetGroup(vec);
                        AcDbObjectId idConfig;
                        es=pRootDict->setAt(_T("TWT_GROUPIDCONFIG"),pConfig,idConfig);
                        pConfig->close();
                    }
                    pRootDict->downgradeOpen();
                }
            }
			pRootDict->close();
		}
	}
}

CHidePipeDlg::CHidePipeDlg(CWnd* pParent /*=NULL*/)
	: CModelessDialog(CHidePipeDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CHidePipeDlg)
	m_dDst = 20.0;
	//}}AFX_DATA_INIT
}

void CHidePipeDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CHidePipeDlg)
	DDX_Control(pDX, IDC_EDIT_DST, m_edtDst);
	DDX_Text(pDX, IDC_EDIT_DST, m_dDst);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CHidePipeDlg, CModelessDialog)
	//{{AFX_MSG_MAP(CHidePipeDlg)
	ON_WM_DESTROY()
	ON_EN_KILLFOCUS(IDC_EDIT_DST, OnKillfocusEditDst)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CHidePipeDlg message handlers

BOOL CHidePipeDlg::OnInitDialog() 
{
	CModelessDialog::OnInitDialog();
	CRegProperty reg(GetRegLocation(), _T("中冶焦耐"));    
	reg.SetTopRootKey(HKEY_CURRENT_USER);
	if(!reg.GetValue(_T("BreakDst"), m_dDst))
	{
		m_dDst = 20;
	}
	UpdateData(FALSE);
	return TRUE;
}

void CHidePipeDlg::OnDestroy() 
{
	CModelessDialog::OnDestroy();
	
	UpdateData(TRUE);
	CRegProperty reg(GetRegLocation(), _T("中冶焦耐"));    
	reg.SetTopRootKey(HKEY_CURRENT_USER);
	reg.SetValue(_T("BreakDst"), m_dDst);
}

void CHidePipeDlg::OnKillfocusEditDst() 
{
	double dDist = m_dDst;
	CString sText;
	m_edtDst.GetWindowText(sText);
	m_dDst = _tstof(sText);
	if (m_dDst <= 0.0)
	{
		m_dDst = dDist;
		UpdateData(FALSE);
		m_edtDst.SetFocus();
		m_edtDst.SetSel(0, -1);
	}
}