#include "stdafx.h"
#include "AcDbObjectPtr.h"
#include "globalFunc.h"
#include "WellModifyDlg.h"
#include "SelectBlkDlg.h"
#include "DbWell.h"
#include "Dbpipe.h"
#include "welldndlg.h"
#include "WellRepiarDlg.h"
#include "PickEntSet.h"

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



bool IsSameSys(CString sLayer1, CString sLayer2)
{
	int nIndex1 = sLayer1.Find(_T("_"));
	int nIndex2 = sLayer2.Find(_T("-"));
	CString sName1, sName2;
	if (nIndex1 > 0 && nIndex2 > 0)
	{
		sName1 = sLayer1.Right(sLayer1.GetLength() - nIndex1 - 1);
		sName2 = sLayer2.Right(sLayer2.GetLength() - nIndex2 - 1);
		if (sName2.Compare(sName1) == 0)
		{
			return true;
		}
	}
	return false;
}

void CheckRelation(AecXDbWell *pWell, PickSet &ss)
{
	if (pWell->GetInterfaceNum() < 1 || ss.Length() < 1)
	{
		return;
	}

	AcDbObjectId id, idPipe;
	int i = 0;
	for (; i < pWell->GetInterfaceNum(); i++)
	{
		CPipeInterface face;
		pWell->GetInterface(i, face);

		id = face.m_idPipe;
		for (long l = 0; l < ss.Length(); l++)
		{
			acdbGetObjectId(idPipe, ss[l]);
			if (id == idPipe)
			{
				break;
			}
		}
		if (l == ss.Length() && id.isValid())
		{
			ss += id;
		}
	}
}

bool NotConnect2Pipe(XPoint &ptLoc, const CString &sLayer, AecXDbWell *pWell)
{
	const double dDist = GlobalFunc::DocGetCurMeterUnitDraw() ? 0.001 : 10;
	AcGePoint3d ptGeLB ,ptGeLT, ptGeRB, ptGeRT;
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	AcGeVector3d vtY = AcGeVector3d::kYAxis;
	ptGeLB = ptLoc - vtX * dDist / 2;
	ptGeLB = ptGeLB - vtY * dDist / 2;
	ptGeLT = ptGeLB + vtY * dDist;
	ptGeRB = ptGeLB + vtX * dDist;
	ptGeRT = ptGeRB + vtY * dDist;
	
	PickSet ssSel(SS_FREE);
	RBList rbFilter(RTDXF0, _T("AEC_ZT_PIPE"), NULL);
	ADSGePoint3d _ptGeLB(GlobalFunc::Wcs2Ucs(ptGeLB))
		, _ptGeLT(GlobalFunc::Wcs2Ucs(ptGeLT))
		, _ptGeRT(GlobalFunc::Wcs2Ucs(ptGeRT))
		, _ptGeRB(GlobalFunc::Wcs2Ucs(ptGeRB));
	RBList rbPt = acutBuildList(RTPOINT,&_ptGeLB,RTPOINT,&_ptGeLT,RTPOINT,&_ptGeRT, RTPOINT,&_ptGeRB,NULL); 
	acedSSGet(_T("CP"), rbPt, NULL, rbFilter, ssSel);

	CheckRelation(pWell, ssSel);

	AcDbObjectId id;
	AcGePoint3d ptOnPipe;
	double dElev = 0.0;
	int nIndex = 0;
	for (long i = 0; i < ssSel.Length(); i++)
	{
		acdbGetObjectId(id, ssSel[i]);
		OPENOBJ_BEGIN(id, AcDb::kForWrite, CDbPipe, pPipe);

		if(pPipe != NULL && IsSameSys(sLayer, pPipe->layer()))
		{
			AcDbLine line;
			AcGePoint3d ptS, ptE;
			ptS = pPipe->StartPoint();
			ptE = pPipe->EndPoint();
			ptS.z = 0;
			ptE.z = 0;
			line.setStartPoint(ptS);
			line.setEndPoint(ptE);
			AcGePoint3d pt1 = ptLoc, pt2;
			line.getClosestPointTo(ptLoc, pt2);
			
			pt1.z = 0;
			pt2.z = 0;
			double dDist = pt1.distanceTo(pt2);

			AcDbLine lineZ;
			pt1.z = ptLoc.z + 10;
			lineZ.setStartPoint(ptLoc);
			lineZ.setEndPoint(pt1);

 			AcGePoint3dArray arryPts;
			if (dDist < 1e-6)
			{
				arryPts.setLogicalLength(0);
				lineZ.intersectWith(pPipe, AcDb::kExtendBoth, arryPts);
				if (arryPts.length() > 0)
				{
					ptOnPipe = arryPts[0];
				}
				else
				{
					pPipe->getClosestPointTo(ptLoc, ptOnPipe);
					ptLoc.z = ptOnPipe.z;
					pPipe->getClosestPointTo(ptLoc, ptOnPipe);
				}
				
				if (nIndex == 0)
				{
					dElev = ptOnPipe.z;
				}

				nIndex++;

				if (dElev > ptOnPipe.z && !(ptOnPipe.z > - 0.001 && ptOnPipe.z < 0.001) )
				{
					dElev = ptOnPipe.z;
				}
			}
		}
		OPENOBJ_END();
	}
	ptLoc.z = dElev;

	return true;
}

void ModifyWellRelationWithPipe(const AcDbObjectId &id)
{
	XPoint ptLoc;
	CString sLayer;
	CPipeInterface face;
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecXDbWell, pWell);
	if(pWell != NULL)
	{
		ptLoc = pWell->GetLocation();
		sLayer = pWell->layer();
		if (NotConnect2Pipe(ptLoc, sLayer, pWell))
		{
			pWell->SetLocation(ptLoc);
		}
	}
	OPENOBJ_END();
}

bool IsLinkedWithWell(const CPipeInterface face, double &dPipeEle)
{
	XPoint pt = face.m_ptLocation;
	CDbPipe *pPipe = NULL;
	AcDbObjectId idNode;
	double dEle = 0.0;
	double dUnit = 0.001;
	if (GlobalFunc::DocGetMeterUnitDraw())
	{
		dUnit = 1.0;
	}

	acdbOpenObject(pPipe, face.m_idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		if (pt.Distance2d(pPipe->GetStartPoint()) < 0.001)
		{
			idNode = pPipe->GetNode(1);
			dEle = pPipe->GetStartPoint().z;
		}
		else
		{
			idNode = pPipe->GetNode(0);
			dEle = pPipe->GetEndPoint().z;
		}

		double dDn = pPipe->GetDnDiameter();
		int iMaterial = pPipe->GetMaterial();
		CString csMat = GlobalFunc::GetPipeMaterialByIdx(iMaterial);
		dDn  = GlobalFunc::GetPipeDjByDn(csMat, (int)dDn) / 2;
		
		dPipeEle = dEle * dUnit - dDn;
		pPipe->close();
	}

	if (idNode != NULL)
	{
		Entity entNode;
		ads_name name;
		acdbGetAdsName(name, idNode);
		entNode = name;
		if (entNode.Is(_T("AEC_ZT_WELL")) || entNode.Is(_T("AEC_ZT_POOL")))
		{
			return true;
		}
	}
	return false;
}

void ModifyWellEleE(const AcDbObjectId id, bool bModifyAllPipe = false)
{
	AecXDbWell *pWell = NULL;
	XPoint ptLoc;
	acdbOpenObject(pWell, id, AcDb::kForWrite);
	if (pWell != NULL)
	{
		CPipeInterface face;
		double dPipeEle = 0.0;
		for (int i = 0; i < pWell->GetInterfaceNum(); i++)
		{
			CString sLabel = pWell->GetISysLabel(i);
			if (!sLabel.IsEmpty())
			{
				continue;
			}

			face = pWell->GetInterface(i);
			if (!IsLinkedWithWell(face, dPipeEle) && !bModifyAllPipe)
			{
				continue;
			}

			pWell->SetPipeEndEle(face.m_idPipe, XString(_T("%.3f"), dPipeEle));
			ptLoc = pWell->GetLocation();
		}
		pWell->close();

		PickSet ss(SS_FREE);
		RBList rbMaskDim(RTDXF0, _T("AEC_ZT_WELLDIM"), NULL);
		XPoint ptUcs = GlobalFunc::Wcs2Ucs(ptLoc);
		GlobalFunc::GetPointPickSet(ptUcs, ss, rbMaskDim, 50);
		GlobalFunc::UpdateGraphic(ss);
	}
}

// 井修复 zxl 2012.08.06 add
void RepiarWell()
{
	RBList rbMask(RTDXF0, _T("AEC_ZT_WELL"), NULL);
    PickSet ss(SS_FREE);
	if (GlobalFunc::SelectEntities(_T("\n请选择要修复的井:<退出>"), ss, rbMask) != RTNORM)
	{
		return;
	}
	CWellRepiarDlg *pDlg = new CWellRepiarDlg;
	CTemporaryResourceOverride vTemp;
	pDlg->Create(IDD_WELL_REPIAR, acedGetAcadFrame());
	pDlg->ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();
	TCHAR szTmp[32];
	ads_getstring(NULL, _T("\n按任意键退出:"), szTmp);
	if (pDlg != NULL && pDlg->m_bRepiar)
	{
		pDlg->UpdateData(TRUE);
		if (pDlg->m_bRepiarLink)
		{
			AcDbObjectId id;
			for (long i = 0; i < ss.Length(); i++)
			{
				acdbGetObjectId(id, ss[i]);
				ModifyWellRelationWithPipe(id);
			}
			
			//TPipePerDocData *pData = GetCurPipeDocData();
			//pData->ApplyUpdates();
		}

		if (pDlg->m_bRepiarWellDim1 || pDlg->m_bRepiarWellDim2)
		{
			bool bModifyAll = false;
			if (pDlg->m_bRepiarWellDim2)
			{
				bModifyAll = true;
			}
			AcDbObjectId id;
			for (long i = 0; i < ss.Length(); i++)
			{
				acdbGetObjectId(id, ss[i]);
				ModifyWellEleE(id, bModifyAll);
			}
		}
	}

	if (pDlg != NULL)
	{
		pDlg->DestroyWindow();
		delete pDlg;
		pDlg = NULL;
	}
}

void ModifyWell()
{
	RBList rbMask(RTDXF0, _T("AEC_ZT_WELL"), NULL);
    PickSet ss(SS_FREE);
	if(GlobalFunc::SelectEntities(_T("\n请选择要修改的井:<退出>"), ss, rbMask) != RTNORM)
	{
        return;
	}
	CTemporaryResourceOverride vTemp;
	CWellModifyDlg dlg;
	dlg.GetWells(ss);
	dlg.DoModal();
}


CWellModifyDlg::CWellModifyDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CWellModifyDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CWellModify)
	m_bDim = TRUE;
	m_bDn = FALSE;
	m_bElev1 = FALSE;
	m_bGroundEle = FALSE;
	m_dDn = 0.0;
	m_dElev1 = 0.0;
	m_dGroundEle = 0.0;
	m_bWellRadius = FALSE;
	m_bStyle = FALSE;
	//}}AFX_DATA_INIT

	m_csBlkName = _T("$TWTSYS$00000187");
}


void CWellModifyDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CWellModify)
	DDX_Check(pDX, IDC_CHECK_DIM, m_bDim);
	DDX_Check(pDX, IDC_CHECK_DN, m_bDn);
	DDX_Check(pDX, IDC_CHECK_ELEV, m_bElev1);
	DDX_Check(pDX, IDC_CHECK_GROUNDELE, m_bGroundEle);
	DDX_Text(pDX, IDC_EDIT_DN, m_dDn);
//	DDV_MinMaxDouble(pDX, m_dDn, 0., 1000.);  zxl 2012.06.25 del  取消井径限制
	DDX_Text(pDX, IDC_EDIT_ELEV, m_dElev1);
	DDX_Text(pDX, IDC_EDIT_GROUNDELE, m_dGroundEle);
	DDX_Check(pDX, IDC_CHECK_WELLRADIUS, m_bWellRadius);
	DDX_Check(pDX, IDC_CHECK_STYLE, m_bStyle);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CWellModifyDlg, CDialog)
	//{{AFX_MSG_MAP(CWellModify)
	ON_BN_CLICKED(IDC_PREVIEW_WELL, OnPreviewWell)
	ON_WM_PAINT()
	ON_BN_CLICKED(IDC_BUTTON_WELLRADIUS, OnButtonWellradius)
	ON_BN_CLICKED(IDC_CHECK_DN, OnCheckDn)
	ON_BN_CLICKED(IDC_CHECK_ELEV, OnCheckElev)
	ON_BN_CLICKED(IDC_CHECK_GROUNDELE, OnCheckGroundele)
	ON_BN_CLICKED(IDC_CHECK_WELLRADIUS, OnCheckWellradius)
	ON_BN_CLICKED(IDC_CHECK_STYLE, OnCheckStyle)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BOOL CWellModifyDlg::OnInitDialog() 
{
	CDialog::OnInitDialog();

	OpenSlide();

	OnCheckDn();
	OnCheckElev();
	OnCheckGroundele();
	OnCheckWellradius();
	OnCheckStyle();

	InitWellDn();

	return TRUE;
}



void CWellModifyDlg::OpenSlide()
{
    UpdateData(TRUE);
    CWnd *pImageBox1 = GetDlgItem(IDC_PREVIEW_WELL);
    CString csSldName;
    CString csTK, csRecord;
    GlobalFunc::SplitBlkStr(m_csBlkName, csTK, csRecord);
    csSldName.Format(_T("TWTSYS(%s)"), csRecord);
    GlobalFunc::DrawSlide((const TCHAR*)csSldName, pImageBox1);
}


void CWellModifyDlg::OnPreviewWell() 
{
	CString csSldName;
    CString csTK, csRecord;
    GlobalFunc::SplitBlkStr(m_csBlkName, csTK, csRecord);
    csSldName.Format(_T("TWTSYS(%s)"), csRecord);
    
    CTemporaryResourceOverride vTemp;
    CSelectBlkDlg dlg;  
    dlg.m_csTkName = _T("TWTSYS");
    dlg.m_csType = _T("室外\\井");	
    CWnd *pWnd = GetDlgItem(IDC_PREVIEW_WELL);
    CRect rect;
    dlg.m_staticSlide.m_csCurRecord = csSldName;
    pWnd->GetWindowRect(&rect);
    dlg.m_ptBase = rect.TopLeft();
    if(dlg.DoModal() == IDOK)
	{
        CString csRet = dlg.m_staticSlide.m_csCurRecord;
        XString xsTKName, xsRocord, xsTmp;
        GlobalFunc::SplitSlbName(csRet, xsTKName, xsRocord);
        AcDbDatabase *dwg=acdbCurDwg();
        AcAxDocLock docLock(dwg);
        VERIFY(docLock.lockStatus() == Acad::eOk);
        if(GlobalFunc::LoadDwbBlock((const TCHAR*)xsTKName, (const TCHAR*)xsRocord, xsTmp) != RTNORM) 
		{
            return;
		}
        m_csBlkName = (const TCHAR*)xsTmp;
        OpenSlide();
    } 
}

void CWellModifyDlg::InitWellDn()
{
	std::vector<AcDbObjectId>::iterator it = m_vecWell.begin();
	AcDbObjectId id;
	CString sWellRadius;
	ads_name ent;
	double dRadius = 0.0;
	m_mapWellDn.clear();
	for (; it != m_vecWell.end(); it ++)
	{
		id = *it;
		acdbGetAdsName(ent, id);

		sWellRadius = GlobalFunc::ReadXdata(ent, _T("TG-WELL-RADIUS"));
		dRadius = _tstof(sWellRadius);
		m_mapWellDn.insert(std::make_pair(id, dRadius));
	}
	m_mapLstWellDn = m_mapWellDn;
}

void CWellModifyDlg::SetWellDn()
{

	std::map<AcDbObjectId, double>::iterator it = m_mapWellDn.begin();
	AcDbObjectId id;
	ads_name ent;
	for (; it != m_mapWellDn.end(); it ++)
	{
		id = it->first;
		acdbGetAdsName(ent, id);

		GlobalFunc::WriteXdata(ent, _T("TG-WELL-RADIUS"), XString(_T("%.2f"), it->second));
	}
}

void CWellModifyDlg::RecoverWellDn()
{
	std::map<AcDbObjectId, double>::iterator it = m_mapLstWellDn.begin();
	AcDbObjectId id;
	ads_name ent;
	for (; it != m_mapLstWellDn.end(); it ++)
	{
		id = it->first;
		acdbGetAdsName(ent, id);
		
		GlobalFunc::WriteXdata(ent, _T("TG-WELL-RADIUS"), XString(_T("%.2f"), it->second));
	}
}


void CWellModifyDlg::GetWellDn(std::map<AcDbObjectId, double> &mapWellDn)
{
	m_mapWellDn = mapWellDn;
}

void CWellModifyDlg::OnPaint() 
{
	CPaintDC dc(this);
	OpenSlide();
}

void CWellModifyDlg::OnButtonWellradius() 
{
	CWellDnDlg dlg;
	dlg.SetWells(m_mapWellDn);
	if(dlg.DoModal() == IDOK)
	{
		GetWellDn(dlg.m_mapWell);
		SetWellDn();
	}
}

void CWellModifyDlg::OnCheckDn() 
{
	UpdateData();
	CWnd *pWnd = GetDlgItem(IDC_EDIT_DN);
	if (m_bDn)
	{
		pWnd->EnableWindow(TRUE);
	}
	else
	{
		pWnd->EnableWindow(FALSE);
	}
}

void CWellModifyDlg::OnCheckWellradius() 
{
	UpdateData();
	CWnd *pWnd = GetDlgItem(IDC_BUTTON_WELLRADIUS);
	if (m_bWellRadius)
	{
		pWnd->EnableWindow(TRUE);
	}
	else
	{
		pWnd->EnableWindow(FALSE);
	}
}


void CWellModifyDlg::OnCheckElev()
{
	UpdateData();
	CWnd *pWnd = GetDlgItem(IDC_EDIT_ELEV);
	if (m_bElev1)
	{
		pWnd->EnableWindow(TRUE);
	}
	else
	{
		pWnd->EnableWindow(FALSE);
	}
}

void CWellModifyDlg::OnCheckStyle() 
{
	UpdateData();
	CWnd *pWnd = GetDlgItem(IDC_PREVIEW_WELL);
	if (m_bStyle)
	{
		pWnd->EnableWindow(TRUE);
	}
	else
	{
		pWnd->EnableWindow(FALSE);
	}
}

void CWellModifyDlg::OnCheckGroundele() 
{
	UpdateData();
	CWnd *pWnd = GetDlgItem(IDC_EDIT_GROUNDELE);
	if (m_bGroundEle)
	{
		pWnd->EnableWindow(TRUE);
	}
	else
	{
		pWnd->EnableWindow(FALSE);
	}
}

void CWellModifyDlg::GetWells(PickSet &ss)
{
	m_vecWell.clear();
	AcDbObjectId id;
	for (long i = 0; i < ss.Length(); i++)
	{
		acdbGetObjectId(id, ss[i]);
		if (id)
		{
			m_vecWell.push_back(id);
		}
	}
}

void CWellModifyDlg::OnOK() 
{
	UpdateData();
	std::vector<AcDbObjectId>::iterator it = m_vecWell.begin();
	AcDbObjectId id;
	for (; it != m_vecWell.end(); it ++)
	{
		id = *it;
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecXDbWell, pEquip);
		if(pEquip)
		{
			
			if (m_bDn)
			{
				pEquip->SetScale(m_dDn);
				pEquip->SetWellModify();
			}

			if (m_bElev1)
			{
				pEquip->SetWellEleUp(m_dElev1);
			}
			
			pEquip->EnableDrawLabel(m_bDim);

			if (m_bStyle)
			{
				CString csTK, csRecord;
				GlobalFunc::SplitBlkStr(m_csBlkName, csTK, csRecord);
				XString xsTmp;
				if(GlobalFunc::LoadDwbBlock((const TCHAR*)csTK, (const TCHAR*)csRecord, xsTmp) != RTNORM)
				{
					return;
				}
				pEquip->SetBlock2d(GlobalFunc::GetBlkIdByName(m_csBlkName));

				if(_tcsicmp(_T("$TwtSys$00000389"), m_csBlkName) == 0 )
				{
					pEquip->SetHidePipe(FALSE);
				}
				else if(_tcsicmp(_T("$TwtSys$00000414"), m_csBlkName) == 0 || _tcsicmp(_T("$TwtSys$00000336"), m_csBlkName) == 0)
				{
					pEquip->SetHidePipe(TRUE);
				}
				else
				{
					pEquip->SetHidePipe(TRUE);
				}
				if(_tcsicmp(_T("$TwtSys$00000336"), m_csBlkName) != 0  
					&& _tcsicmp(_T("$TwtSys$00000395"), m_csBlkName) != 0
					&& _tcsicmp(_T("$TwtSys$00000414"), m_csBlkName) != 0)
				{
					pEquip->SetNumber(_T("CIRCLE-0.5"));
				}
				else
				{
					pEquip->SetNumber(_T(""));
				}
			}
	
		}
		OPENOBJ_END();

		if (m_bGroundEle)
		{
			ads_name ent;
			acdbGetAdsName(ent, id);
			GlobalFunc::WriteXdata(ent, _T("TG-WELL-GroundEle"), XString(_T("%.2f"), m_dGroundEle));
		}
	}

	if (m_bWellRadius)
	{
		SetWellDn();
	}
	else
	{
		RecoverWellDn();
	}

	CDialog::OnOK();
}



void CWellModifyDlg::OnCancel() 
{
	RecoverWellDn();
	CDialog::OnCancel();
}