#include "StdAfx.h"
#include "globalFunc.h"
#include "globalDefine.h"
#include "ElevationCalc.h"
#include "DbWell.h"
#include "Dbpipe.h"
#include "DbPool.h"
#include"TGAs.h"
#include <stack>
#include "LayDepthSetDlg.h"

SSearchPipeList* ElevationCalc::GetFarthestSWell(SSearchPipeList* pList)
{
	std::vector<SSearchPipeList*> data;
	GetStartWell(pList, data); 
	
	std::vector<SSearchPipeList*>::iterator it;
	double dCurLen = -1;
	SSearchPipeList *pTemp = NULL;
	for(it = data.begin(); it != data.end(); it++)
	{
		if (!(*it)->m_bNeedCale && (*it)->m_nLength > dCurLen)
		{
			dCurLen = (*it)->m_nLength;
			pTemp = *it; 
		}
	}
	
	return pTemp;
}

double ElevationCalc::GetWellEleUp(const AcDbObjectId &id)
{
	double dRet = 0.0;
	AecXDbWell *pWell = NULL;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		dRet = pWell->GetWellEleUp();
		pWell->close();
	}
	
	return dRet;
}

double ElevationCalc::GetWellEleDown(const AcDbObjectId &id)
{
	double dRet = 0.0;
	AecXDbWell *pWell = NULL;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		dRet = pWell->GetWellEleDown();
		pWell->close();
	}
	
	return dRet;
}

double ElevationCalc::GetPipeEleUp(const std::vector<CALCNODE> &data, const AcDbObjectId &idSWell)
{
	double dRet = 0.0;
	bool bFirst = true; 
	AcDbObjectId id;
	int nDn = 0.0;
	std::vector<CALCNODE>::const_iterator it;
	for (it = data.begin(); it != data.end(); it++)
	{
		if ((*it).idE == idSWell)
		{
			if (bFirst)
			{
				bFirst = false;
				dRet = (*it).dPipeEleE;
				id = (*it).idP;
				nDn = (int)(*it).dPipeDn;
			}
			else if (dRet > (*it).dPipeEleE)
			{
				dRet = (*it).dPipeEleE;
				id = (*it).idP;
				nDn = (int)(*it).dPipeDn;
			}
		}
	}
	
	if (!!id)
	{
		dRet += GetPipeDjById(id, nDn) * 0.001;
	}
	return dRet;
}

double ElevationCalc::GetPipeEleDown(const std::vector<CALCNODE> &data, const AcDbObjectId &idSWell)
{
	double dRet = 0.0;
	bool bFirst = true; 
	std::vector<CALCNODE>::const_iterator it;
	for (it = data.begin(); it != data.end(); it++)
	{
		if ((*it).idE == idSWell)
		{
			if (bFirst)
			{
				bFirst = false;
				dRet = (*it).dPipeEleE;
			}
			else if (dRet > (*it).dPipeEleE)
			{
				dRet = (*it).dPipeEleE;
			}
		}
	}
	return dRet;
}

double ElevationCalc::GetPoolDrop(const AcDbObjectId &id)
{
	double dRet = 0.0;
	CDbPool *pPool = NULL;
	acdbOpenObject(pPool, id, AcDb::kForRead);
	if (pPool != NULL)
	{
		dRet = pPool->GetSpare();
		pPool->close();
	}

	if (dRet < 0.01) // cet 2011.6.20 add 
	{
		dRet = 0.1;
	}

	return dRet;
}

double ElevationCalc::GetPoolGroundEle(const AcDbObjectId &id)
{
	double dRet = 0.0;
	CDbPool *pPool = NULL;
	acdbOpenObject(pPool, id, AcDb::kForRead);
	if (pPool != NULL)
	{
		dRet = pPool->GetGroundEle();
		pPool->close();
	}
	return dRet;
}

CString ElevationCalc::GetPoolName(const AcDbObjectId &id)
{
	CString strRet;
	CDbPool *pPool = NULL;
	acdbOpenObject(pPool, id, AcDb::kForRead);
	if (pPool != NULL)
	{
		strRet = pPool->GetLabel();
		pPool->close();
	}
	return strRet;
}

double ElevationCalc::GetWellLayDepth(const AcDbObjectId &id)
{
	double dLayingDepth = m_dLayingDepth;
	std::map<AcDbObjectId, double>::iterator it;
	it = m_mapLayingDepth.find(id);
	if (it != m_mapLayingDepth.end())
	{
		dLayingDepth = (*it).second;
	}
	else
	{
		double dWellDownEle = GetWellEleDown(id);
		if (fabs(dWellDownEle) > 0.001)
		{
			dLayingDepth = GetWellEleUp(id) - dWellDownEle;
			m_mapLayingDepth.insert(std::make_pair(id, dLayingDepth));
		}
	}
		
	return dLayingDepth;
}

BOOL ElevationCalc::IsDropWell(AcDbObjectId &id)
{
	BOOL bDropWell = FALSE;
	AecXDbWell *pWell = NULL;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		bDropWell = pWell->IsDropWell();
		pWell->close();
	}
	
	return bDropWell;
}

void ElevationCalc::GetStartWell(SSearchPipeList *pList, std::vector<SSearchPipeList*> &data)
{
	std::stack<SSearchPipeList *> dataSt;
	dataSt.push(pList);
	while(!dataSt.empty())
	{
		SSearchPipeList *pTemp = dataSt.top();
		dataSt.pop();
		if (pTemp->m_iType == 3 && pTemp->m_lstNode.Length() == 0) //起点井
		{
			data.push_back(pTemp);
			continue;
		}
		
		for(int i = 0; i < pTemp->m_lstNode.Length(); i++)
		{
			dataSt.push(pTemp->m_lstNode[i]);
		}
	}
}

void ElevationCalc::GetSWellByShow(std::vector<SSearchPipeList*> &data)
{
	SSearchPipeList *pTemp = NULL;
	pTemp = GetFarthestSWell(m_pAllList);
	while(pTemp != NULL)
	{
		data.push_back(pTemp);
		pTemp->m_bNeedCale = TRUE;
		if (pTemp->m_lstNode.Length() >1)
		{
			GetSWellByShow(data);
		}
		
		pTemp = pTemp->m_pPrevious;
	}
}

void ElevationCalc::SetPipeSys(SSearchPipeList *pList)
{
	m_pAllList = pList;
	InitPipeInfo();
}

void ElevationCalc::InitPipeInfo()
{
/*  cet 2011.6.16 del 不考虑管材
	m_mapPipeDj.clear();
	m_mapPipeThick.clear();

	// 获得管网中管道管材
	CString strMat; // 管材
	SSearchPipeList *pList = m_pAllList;
	while(pList != NULL)
	{
		if (pList->m_iType == 0)
		{
			CDbPipe *pPipe = NULL;
			acdbOpenObject(pPipe, pList->m_ID, AcDb::kForRead);
			if (pPipe != NULL)
			{
				int nMat = pPipe->GetMaterial();
				strMat = GetPipeMaterialByIdx(nMat);
				pPipe->close();
			}
			break;
		}

		if (pList->m_lstNode.Length() > 0)
		{
			pList = pList->m_lstNode[0];
		}
		else
		{
		  return;
		}
	}

	// 获取管径信息
	if (!strMat.IsEmpty())
	{
		CodeBase db;
		XString fullFile;
		if(!FindFile(_T("pipe.dbf"), fullFile)) 
		{
			AfxMessageBox(_T("对不起，没有发现pipe.dbf文件！"));
			return;
		}

		XDbfTable *pTable = db.Open(fullFile);
		if(!pTable)
		{
			return;
		}
			
		CString strMaterial;
		double dDn = 0.0, dDj = 0.0, dDn2 = 0.0;
		for(pTable->MoveFirst();!pTable->IsEOF();pTable->MoveNext())
		{
			GET_FIELD(pTable, _T("GC"), strMaterial);
			GET_FIELD(pTable, _T("DN"), dDn);
			if(strMaterial.CompareNoCase(strMat) == 0)
			{
				GET_FIELD(pTable, _T("D"), dDn2); // 外径
				GET_FIELD(pTable, _T("DJ"), dDj); // 内径

				m_mapPipeDj.insert(std::make_pair(dDn, dDj));
				m_mapPipeThick.insert(std::make_pair(dDn, (dDn2 - dDj) * 0.5));
			}
		}
		pTable->Close();
	}
*/
}

void ElevationCalc::SetLayingDepth(double dLayingDepth)
{
	m_dLayingDepth = dLayingDepth;
}

void ElevationCalc::SetMinThick(double dMinThick)
{
	m_dMinThick = dMinThick;
}

void ElevationCalc::Sort(std::vector<CALCNODE> &info)
{
	std::vector<SSearchPipeList*>::iterator it1;
	for(it1 = m_vecWell.begin(); it1 != m_vecWell.end(); it1++)
	{
		(*it1)->m_bNeedCale = FALSE;
	}
	
	std::vector<SSearchPipeList*> data;
	GetSWellByShow(data);
	
	// 按显示顺序排列表格信息
	std::vector<CALCNODE> vec;
	for(it1 = data.begin(); it1 != data.end(); it1++)
	{
		SSearchPipeList *pTemp = *it1;
		while(pTemp != NULL)
		{
			if (pTemp->m_iType == 3 || pTemp->m_iType == 4)
			{
				bool bExist = false;
				std::vector<CALCNODE>::iterator it;
				for(it = vec.begin(); it != vec.end(); it++)
				{
					if ((*it).idS == pTemp->m_ID)
					{
						bExist = true;
						break;
					}
				}
				
				if (bExist)
				{
					break;
				}
				
				for(it = m_vecLstData.begin(); it != m_vecLstData.end(); it++)
				{
					if ((*it).idS == pTemp->m_ID)
					{
						vec.push_back(*it);
						break;
					}
				}
			}
			
			pTemp = pTemp->m_pPrevious;
		}
	}
	
    info = vec;
}

void ElevationCalc::UpDatePipeSys()
{
	std::stack<SSearchPipeList *> data;
	data.push(m_pAllList);
	while(!data.empty())
	{
		SSearchPipeList *plist = data.top();
		data.pop();
		if (plist->m_iType == 0)
		{
			CDbPipe *pPipe = NULL;
			acdbOpenObject(pPipe, plist->m_ID, AcDb::kForRead);
			if (pPipe != NULL)
			{
				XPoint ptS, ptE;
				ptS = pPipe->StartPoint();
				ptE = pPipe->EndPoint();
				ptS.z = 0;
				ptE.z = 0;
				plist->m_nLength = ptS.Distance(ptE);
				if (!GlobalFunc::DocGetMeterUnitDraw())
				{
					plist->m_nLength /= 1000.0;
				}
				plist->m_iDn = pPipe->GetDnDiameter();
				pPipe->close();
			}
		}
		
		plist->m_iSpare = 0;
		plist->m_bNeedCale = FALSE;
		for(int i = 0; i < plist->m_lstNode.Length(); i++)
		{
			data.push(plist->m_lstNode[i]);
		}
	}
}

void ElevationCalc::CalcLenStartWellToEnd(SSearchPipeList *pList, double dCurLen)
{
	if (pList->m_iType == 0)
	{
		dCurLen += pList->m_nLength;
	}
	else if (pList->m_iType == 3 && pList->m_lstNode.Length() == 0)
	{
		pList->m_nLength = dCurLen;
		m_vecWell.push_back(pList);
		return;
	}
	
	for (int i = 0; i < pList->m_lstNode.Length(); i++)
	{
		CalcLenStartWellToEnd(pList->m_lstNode[i], dCurLen);
	}
}

void ElevationCalc::ModifyWellInfo(const AcDbObjectId &id, double dEleUp, double dEleDown, BOOL bDrop)
{
	std::vector<CALCNODE>::iterator it;
	for(it = m_vecLstData.begin(); it != m_vecLstData.end(); it++)
	{
		if ((*it).idS == id) 
		{
			(*it).dWellEleUpS = dEleUp;
			if (bDrop)
			{
				(*it).dWellEleDownS = dEleDown;
			}
			(*it).bIsDropWell = bDrop;
		}
		else if ((*it).idE == id)
		{
			(*it).dWellEleUpE = dEleUp;
		}
	}
}

void ElevationCalc::ModifyWellLayingDepth(const AcDbObjectId &id, double dLayingDepth)
{
	m_mapLayingDepth.erase(id);
	m_mapLayingDepth.insert(std::make_pair(id, dLayingDepth));
}

std::vector<CALCNODE>& ElevationCalc::GetLstData()
{
	return m_vecLstData;
}

std::vector<SSearchPipeList*>& ElevationCalc::GetStartWell()
{
	return m_vecWell;
}

// 管段壁厚
double ElevationCalc::GetPipeThickById(const AcDbObjectId &id, double dDn)
{
    double dThick(0);
	std::map<double,double>::iterator it;
	it = m_mapPipeThick.find(dDn);
	if (it != m_mapPipeThick.end())
	{
		dThick = (*it).second * 0.001;
	}
    return dThick;
}

void ElevationCalc::UpdateDropWell(const std::map<AcDbObjectId,double> &data)
{
	m_mapDropWell = data;
}

void ElevationCalc::SetPipeEleDown(double dEle)
{
	m_dPipeEleDown = dEle;
}

int ElevationCalc::Compare(double dVal1, double dVal2)
{
	if (fabs(dVal1 - dVal2) < 1e-3)
	{
		return 0;
	}
	else if (dVal1 > dVal2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}

void ElevationCalc::ModifyPipe(const AcDbObjectId &idPipe, double dVal, BOOL bDn)
{
	std::vector<CALCNODE>::iterator it;
	for (it = m_vecLstData.begin(); it != m_vecLstData.end(); it++)
	{
		if ((*it).idP == idPipe)
		{
			if (bDn)
			{
				(*it).dPipeDn = dVal;
			} 
			else
			{
				(*it).dGradient = dVal * 0.001;
			}
			break;	
		}
	}
}

void ElevationCalc::GetCheckInfoforPipe(std::vector<AcDbObjectId> &data) 
{
	data = m_vecCheckforPipe;
}

double ElevationCalc::GetPipeDjById(const AcDbObjectId &id, double dDn)
{
	// 使用nDn作为外径
	double dPipeDn(0.0);
	dPipeDn = dDn; // cet 2011.6.16 add 未找到时使用dDn
	std::map<double,double>::iterator it;
	it = m_mapPipeDj.find(dDn);
	if (it != m_mapPipeDj.end())
	{
		dPipeDn = (*it).second;
	}
    return dPipeDn;
}

void ElevationCalc::EnableSetLayDepth( bool bVal )
{
	m_bShowTip = bVal;
}

void ElevationCalc::SetLayDepthData( std::map<AcDbObjectId,LayingDepthNode> *pMapData )
{
	m_pMapSWellLayDepth = pMapData;
}

void ElevationCalc::UpdateSWellLayDepth()
{
	if (m_bShowTip)
	{
		int nSel = 0;
		if (!m_bOnlySWell)
		{
			CLayDepthSetDlg dlg;
			if (dlg.DoModal() != IDOK)
			{
				return;
			}
			
		    nSel = dlg.GetSel();
		}
		else
		{
			nSel = 0;
		}

		switch (nSel)
		{
		case 0:
			{
				UpdateSWellLayDepth(eUserSet);
				UpdateSWellLayDepth(eCalc);
				UpdateSWellLayDepth(eUserModify);
				UpdateSWellLayDepth(eLayingDepth);
				break;
			}
		case 1:
			{
				break;
			}
		case 2:
			{
				UpdateSWellLayDepth(eCalc);
				UpdateSWellLayDepth(eLayingDepth);
				break;
			}
		}
	}
	else
	{
		UpdateSWellLayDepth(eLayingDepth);
	}
}

void ElevationCalc::UpdateSWellLayDepth( LayingDepthType type )
{
	if (m_pMapSWellLayDepth != NULL)
	{
		std::map<AcDbObjectId,LayingDepthNode>::iterator itM;
		std::map<AcDbObjectId, double>::iterator it;
		for (itM = m_pMapSWellLayDepth->begin(); itM != m_pMapSWellLayDepth->end(); itM++)
		{
			if (itM->second.type != type)
			{
				continue;
			}
			itM->second.type = eLayingDepth;
			it = m_mapLayingDepth.find(itM->first);
			if (it != m_mapLayingDepth.end())
			{
				it->second = m_dLayingDepth;
				itM->second.dLayingDepth = m_dLayingDepth;
			} 
			else
			{
				m_mapLayingDepth.insert(std::make_pair(itM->first, m_dLayingDepth));
				itM->second.dLayingDepth = m_dLayingDepth;
			}
		}
	}
}

void ElevationCalc::SetOnlySWell( bool bOnly )
{
	m_bOnlySWell = bOnly;
}