#include "StdAfx.h"
#include "EWCheckerData.h"
#include <sstream>
#include "aecdbearthworm.h"
#include "KTCADUtilityEx.h"
#include "BrowseForFolder.h"
#include "stakeoper.h"
#include <fstream>
#include "MakeDim.h"
#include "UITools.h"
#include "TJSZDlg.h"

int DLLIMPEXP GetConnectedWorms(const AcDbObjectId& idHit, AcDbObjectIdArray& arIds);
int DLLIMPEXP GetConnectedWorms(const AecDbEarthWorm* pEW, AcDbObjectIdArray& arIds);

extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb,bool bClose);

namespace
{
	using namespace MK_DIM;

	using namespace GLStatistics;

	struct Statistics
	{
		CString sStake;	// 桩号字符串
		CString sRoom;	// 舱室名称
		CString sType;	// 节点类型字符串
		NodeDim::ENodeType eType;	// 节点类型
		double dDist;	// 桩号距离
		double dVenNum;	// 换气次数，只有在 eType 为eVenDoghouse时有效
	};

	// 设置
	TJConfig g_config;

	// 集水井
	std::vector<Statistics> g_DrainWells;
	// 料口
	std::vector<Statistics> g_Doghouses;
	// 通风口
	std::vector<Statistics> g_VenDoghouses;
	// 防火墙
	std::vector<Statistics> g_Firewalls;
	// 逃生口
	std::vector<Statistics> g_EscapeHatchs;
	// 引出口
	std::vector<Statistics> g_Outlets;

	// 舱室列表
	std::vector<CString> g_Tanks;

	// 舱室长宽高信息 (舱名-(宽+高))
	std::map<CString, std::pair<double, double>> g_TankWHs;

	void initGlobalData(std::vector<NodeDim> &nodes)
	{
		g_DrainWells.clear();
		g_Doghouses.clear();
		g_VenDoghouses.clear();
		g_Firewalls.clear();
		g_EscapeHatchs.clear();
		g_Outlets.clear();

		Statistics stat;
		for (size_t i = 0; i < nodes.size(); ++i)
		{
			NodeDim &nd = nodes[i];

			//if (!GLTools::analyStakeString(nd.stake, stat.dDist)) continue;
			stat.sStake = nd.stake;
			stat.dDist = nd.distFromHead;

			NodeDim::RoomTypes::const_iterator itRT = nd.room_types.begin();
			for (; itRT != nd.room_types.end(); ++itRT)
			{
				if (itRT->second.empty()) continue;
				stat.sRoom = itRT->first;
				std::set<NodeDim::ENodeType>::const_iterator itType = itRT->second.begin();
				for (; itType != itRT->second.end(); ++itType)
				{
					stat.eType = *itType;
					stat.sType = getNodeName(*itType);
					switch (*itType)
					{
					case NodeDim::eDrainWell:
						g_DrainWells.push_back(stat);
						break;
					case NodeDim::eFireWall:
						g_Firewalls.push_back(stat);
						break;
					case NodeDim::eVenDoghouse:
						g_VenDoghouses.push_back(stat);
						break;
					case NodeDim::eEscapeHatch:
						g_EscapeHatchs.push_back(stat);
						break;
					case NodeDim::eDoghouse:
						g_Doghouses.push_back(stat);
						break;
					case NodeDim::eOutlet:
						g_Outlets.push_back(stat);
						break;
					default:
						break;
					}
				}
			}
		}
	}

}

namespace GLStatistics
{
	using namespace MK_DIM;

	bool init(bool includeFire)
	{
		// 选择管廊
		ads_point adsPnt;
		ads_name adsName;
		int nRes = acedEntSel(_T("\n请选择要校核的管廊。"), adsName, adsPnt);
		if (nRes != RTNORM) return false;
		AcDbObjectId idEw(AcDbObjectId::kNull);
		acdbGetObjectId(idEw, adsName);

		ERoom room;
		double w(.0), h(.0);
		OPENOBJ_BEGIN(idEw, AcDb::kForRead, AecDbEarthWorm, pEw)
			if (!pEw)
			{
				acutPrintf(_T("\n请选择一段管廊。"));
				return false;
			}
		g_Tanks.clear();
		g_TankWHs.clear();
		pEw->GetRoomCount();
		for (int i = 0; i < pEw->GetRoomCount(); ++i)
		{
			if (pEw->GetRoom(i, room))
			{
				w = room.ptGe[0].distanceTo(room.ptGe[1]);
				h = room.ptGe[1].distanceTo(room.ptGe[2]);
			}
			g_Tanks.push_back(pEw->GetRoomTypeByIdx(i));
			g_TankWHs.insert(std::make_pair(*g_Tanks.rbegin(), std::make_pair(w, h)));
			
		}
		OPENOBJ_END()

		std::vector<NodeDim> nodes(0);
		collectNodeInfo_Statistic(idEw, nodes, includeFire);

		if (nodes.empty()) return false;

		initGlobalData(nodes);

		return true;
	}

	std::vector<Statistics>& getGlobalData(const MK_DIM::NodeDim::ENodeType &type)
	{
		switch (type)
		{
		case MK_DIM::NodeDim::eFireWall:
			return g_Firewalls;
		case MK_DIM::NodeDim::eDoghouse:
			return g_Doghouses;
		case MK_DIM::NodeDim::eVenDoghouse:
			return g_VenDoghouses;
		case MK_DIM::NodeDim::eOutlet:
			return g_Outlets;
		case MK_DIM::NodeDim::eDrainWell:
			return g_DrainWells;
		case MK_DIM::NodeDim::eEscapeHatch:
			return g_EscapeHatchs;
		default:
			return g_Firewalls;
		}
		return g_Firewalls;
	}

	void statisticEarthworm(const MK_DIM::NodeDim::ENodeType &type)
	{
		if (!init(type == MK_DIM::NodeDim::eFireWall)) return;
		// 弹对话框
		CAcModuleResourceOverride myResources;
		CTJSZDlg dlg(type, g_Tanks);
		if (dlg.DoModal() != IDOK) return;

		readConfig(g_config);
		if (g_config.empty()) return;
		std::vector<Statistics> &ss = getGlobalData(type);

		GLReport::CEWGLReport report;
		GLReport::CEWTank tank;
		GLReport::EWNodeData data;
		for (size_t tk = 0; tk < g_Tanks.size(); ++tk)
		{
			tank.clear();

			CString &name(g_Tanks[tk]);
			tank.setName(name);
			tank.setWidth(g_TankWHs[name].first);
			tank.setHeight(g_TankWHs[name].second);
			tank.setOption(g_config[name]);
			for (size_t i = 0; i < ss.size(); ++i)
			{
				Statistics &st(ss[i]);
				if (st.sRoom == name)
				{
					data.m_stake = st.sStake;
					data.m_dDistance = st.dDist;
					tank.appendData(type, data);
				}
			}
			tank.calcData(type);
			report.appendTank(tank);
		}
		report.outputCADTable(type);
		return;
	}

	void statisticDrainWell()
	{
		statisticEarthworm(MK_DIM::NodeDim::eDrainWell);
	}

	void statisticDoghouse()
	{
		statisticEarthworm(MK_DIM::NodeDim::eDoghouse);
	}

	void statisticVenDoghouse()
	{
		statisticEarthworm(MK_DIM::NodeDim::eVenDoghouse);
	}

	void statisticFireWall()
	{
		statisticEarthworm(MK_DIM::NodeDim::eFireWall);
	}

	void statisticEscapeHatch()
	{
		statisticEarthworm(MK_DIM::NodeDim::eEscapeHatch);
	}

	void statisticOutlet()
	{
		statisticEarthworm(MK_DIM::NodeDim::eOutlet);
	}


	CString getConfigFilePath()
	{
		CString path = FilePath::getProgramDataFolder();
		path += _T("\\tjsz.dat");
		return path;
	}

	void readConfig(TJConfig &config)
	{
		config.clear();

		CString str(_T(""));

		CString path = getConfigFilePath();

		if (_taccess(path, 0x0) != 0x0) return;

		std::vector<CString> sections(0);
		INITools::getSections(path, sections);
		std::map<CString, CString> mapV;
		for (size_t i = 0; i < sections.size(); ++i)
		{
			const CString &sec(sections[i]);
			INITools::getSectionContent(path, sec, mapV);
			if (mapV.empty()) continue;

			config.insert(std::make_pair(sec, std::map<CString, double>()));
			for (std::map<CString, CString>::const_iterator it = mapV.begin(); it != mapV.end(); ++it)
			{
				config[sec].insert(std::make_pair(it->first, _ttof(it->second)));
			}
		}
		return;
	}
}

namespace
{
	AcDbObjectId getTableStyleID(LPCTSTR psz)
	{
		AcDbObjectId idTblStyle(AcDbObjectId::kNull);
		if (!psz) return idTblStyle;

		AcDbDictionary *pDict(NULL);
		acdbHostApplicationServices()->workingDatabase()->getTableStyleDictionary(pDict, AcDb::kForRead);
		pDict->getAt(psz, idTblStyle);
		pDict->close();

		return idTblStyle;
	}

	AcDbObjectId getTextStyleID(LPCTSTR psz)
	{
		AcDbObjectId idTxtStyle(AcDbObjectId::kNull);
		if (!psz) return idTxtStyle;

		AcDbTextStyleTable *pTextStyle(NULL);
		acdbHostApplicationServices()->workingDatabase()->getTextStyleTable(pTextStyle, AcDb::kForRead);
		pTextStyle->getAt(psz, idTxtStyle);
		pTextStyle->close();

		return idTxtStyle;
	}
}

namespace GLReport
{
	AcDbTable* CEWGLReport::outputDataCAD(const MK_DIM::NodeDim::ENodeType &type)
	{
		AcDbTable *pTbl = new AcDbTable;

		AcDbObjectId idTblStyle(getTableStyleID(_T("Standard")));
		if (!idTblStyle.isValid()) return NULL;
		pTbl->setTableStyle(idTblStyle);

		AcDbObjectId idTextStyle(getTextStyleID(_T("Standard")));
		if (!idTextStyle.isValid()) return NULL;
		pTbl->setTextStyle(idTextStyle);

		// 总列数 (舱室名称｜桩号范围｜长度)
		int cols((int)m_tanks.size() * 2 + 1);
		// 设置列数
		pTbl->setNumColumns(cols);

		pTbl->setNumRows(3);

		// 合并第0行
		pTbl->mergeCells(0, 0, 0, cols - 1);
		// 为第0行打上文字
		pTbl->setTextString(0, 0, MK_DIM::getNodeName(type) + _T("统计"));

		// 合并第1行
		for (int i = 0; i < m_tanks.size(); ++i)
		{
			pTbl->mergeCells(1, 1, i * 2 + 1, i * 2 + 2);
			pTbl->setTextString(1, i * 2 + 1, m_tanks[i].getName());
		}
		
		pTbl->setTextString(2, 0, _T("序号"));
		for (int i = 0; i < m_tanks.size(); ++i)
		{
			pTbl->setTextString(2, i * 2 + 1, _T("桩号范围"));
			pTbl->setTextString(2, i * 2 + 2, _T("长度（m）"));
		}

		pTbl->setColumnWidth(30);
		
		const EWNodeDatas *pDatas(NULL);
		EWNodeDatas datas(0);
		AcCmColor clr;
		clr.setColorIndex(1);
		// 总行数
		int rows(3);
		int col1(0), col2(0);
		for (size_t tk = 0; tk < m_tanks.size(); ++tk)
		{
			pDatas = NULL;
			const CEWTank &tank = m_tanks[tk];
			std::map<CString, double> &conf = g_config[tank.getName()];
			switch (type)
			{
			case MK_DIM::NodeDim::eFireWall: pDatas = &tank.getFireZoneData(); break;
			case MK_DIM::NodeDim::eEscapeHatch: pDatas = &tank.getEscapeData(); break;
			case MK_DIM::NodeDim::eDoghouse: pDatas = &tank.getDoghouseData(); break;
			case MK_DIM::NodeDim::eOutlet: pDatas = &tank.getOutletData(); break;
			case MK_DIM::NodeDim::eDrainWell: pDatas = &tank.getWellData(); break;
			default: break;
			}
			col1 = (int)tk * 2 + 1;
			col2 = (int)tk * 2 + 2;
			rows = 3;
			if (pDatas)
			{
				for (size_t i = 0; i < pDatas->size(); ++i)
				{
					const EWNodeData &da = pDatas->at(i);
					if (pTbl->numRows() <= rows)
						pTbl->insertRows(rows, 5);

					pTbl->setTextString(rows, col1, da.m_stake.c_str());
					pTbl->setTextString(rows, col2, _convert_<std::wstring , double>(da.m_dDistance).c_str());
					if (da.m_dDistance > conf[MK_DIM::getNodeName(type)])
					{
						pTbl->setContentColor(rows, col1, clr);
						pTbl->setContentColor(rows, col2, clr);
					}
					++rows;
				}
			}
		}

		CString str(_T(""));
		for (size_t i= 3; i < pTbl->numRows(); ++i)
		{
			str.Format(_T("%d"), i - 2);
			pTbl->setTextString((int)i, 0, str);
		}

		int tblHeight(3);
		pTbl->setTextHeight(tblHeight);
		pTbl->setRowHeight(5);

		pTbl->generateLayout();
		return pTbl;
	}

	AcDbTable* CEWGLReport::outputVentilateCAD()
	{
		CString str(_T(""));

		AcDbTable *pTbl = new AcDbTable;

		AcDbObjectId idTblStyle(getTableStyleID(_T("Standard")));
		if (!idTblStyle.isValid()) return NULL;
		pTbl->setTableStyle(idTblStyle);

		AcDbObjectId idTextStyle(getTextStyleID(_T("Standard")));
		if (!idTextStyle.isValid()) return NULL;
		pTbl->setTextStyle(idTextStyle);

		// 总列数 (舱室名称｜桩号范围｜长度)
		int cols((int)m_tanks.size() * 5 + 1);
		// 设置列数
		pTbl->setNumColumns(cols);

		pTbl->setNumRows(3);

		// 合并第0行
		pTbl->mergeCells(0, 0, 0, cols - 1);
		// 为第0行打上文字
		pTbl->setTextString(0, 0, _T("通风计算"));

		// 合并第1行
		for (int i = 0; i < m_tanks.size(); ++i)
		{
			str.Format(_T("%s（%.1fmX%.1fm）"), m_tanks[i].getName(), m_tanks[i].getLength(), m_tanks[i].getWidth());
			pTbl->mergeCells(1, 1, i * 5 + 1, i * 5 + 5);
			pTbl->setTextString(1, i * 5 + 1, str);
		}

		pTbl->setTextString(2, 0, _T("序号"));
		for (int i = 0; i < m_tanks.size(); ++i)
		{
			pTbl->setTextString(2, i * 5 + 1, _T("桩号范围"));
			pTbl->setTextString(2, i * 5 + 2, _T("长度（m）"));
			pTbl->setTextString(2, i * 5 + 3, _T("体积（m3）"));
			pTbl->setTextString(2, i * 5 + 4, _T("通风次数（次/h）"));
			pTbl->setTextString(2, i * 5 + 5, _T("通风量（m3/h）"));
		}

		pTbl->setColumnWidth(30);

		// 总行数
		AcCmColor clr;
		clr.setColorIndex(1);
		int rows(3);
		int col1(0), col2(0), col3(0), col4(0), col5(0);
		for (size_t tk = 0; tk < m_tanks.size(); ++tk)
		{
			const CEWTank &tank = m_tanks[tk];
			std::map<CString, double> &conf = g_config[tank.getName()];
			const EWVentilates &datas(tank.getVentilateData());
			col1 = (int)tk * 5 + 1;
			col2 = (int)tk * 5 + 2;
			col3 = (int)tk * 5 + 3;
			col4 = (int)tk * 5 + 4;
			col5 = (int)tk * 5 + 5;
			rows = 3;
			for (size_t i = 0; i < datas.size(); ++i)
			{
				const EWVentilate &da = datas[i];
				if (pTbl->numRows() <= rows)
					pTbl->insertRows(rows, 5);
				pTbl->setTextString(rows, col1, da.m_stake.c_str());

				pTbl->setTextString(rows, col2, _convert_<std::wstring, double>(da.m_dDistance).c_str());
				if (da.m_dDistance > conf[MK_DIM::getNodeName(MK_DIM::NodeDim::eVenDoghouse)])
				{
					pTbl->setContentColor(rows, col2, clr);
				}

				pTbl->setTextString(rows, col3, _convert_<std::wstring, double>(da.m_dVolum).c_str());
				pTbl->setTextString(rows, col4, _convert_<std::wstring, double>(da.m_dNumVentilate).c_str());
				pTbl->setTextString(rows, col5, _convert_<std::wstring, double>(da.m_dAirHr).c_str());
				++rows;
			}
		}

		for (size_t i = 3; i < pTbl->numRows(); ++i)
		{
			str.Format(_T("%d"), i - 2);
			pTbl->setTextString((int)i, 0, str);
		}

		int tblHeight(3);
		pTbl->setTextHeight(tblHeight);
		pTbl->setRowHeight(5);

		pTbl->generateLayout();
		return pTbl;
	}

	void CEWGLReport::outputCADTable(const MK_DIM::NodeDim::ENodeType &type)
	{
		AcDbTable *pTbl(NULL);
		if (type == MK_DIM::NodeDim::eVenDoghouse)
			pTbl = outputVentilateCAD();
		else
			pTbl = outputDataCAD(type);

		if (!pTbl) return;

		AcGeVector3d vtx = acdbCurDwg()->ucsxdir();
		double angle = AcGeVector3d::kXAxis.angleTo(vtx, AcGeVector3d::kZAxis);
		pTbl->setDirection(vtx);
		pTbl->recomputeTableBlock(true);
		pTbl->generateLayout();

		TableJig jig(pTbl, _T("\n请确定表格位置<退出>: "));
		if (jig.doIt() != AcEdJig::kNormal)
		{
			DELETE_PTR(pTbl);
			return;
		}

		AddToModelSpace(pTbl, NULL, true);
	}

	//////////////////////////////////////////////////////////////////////////
	void CEWTank::setOption(const std::map<CString, double> &op)
	{
		m_options.insert(op.begin(), op.end());
	}

	void CEWTank::appendData(const MK_DIM::NodeDim::ENodeType &type, const EWNodeData &data)
	{
		switch (type)
		{
		case MK_DIM::NodeDim::eFireWall:
			m_fireWall.push_back(data);
			break;
		case MK_DIM::NodeDim::eEscapeHatch:
			m_escape.push_back(data);
			break;
		case MK_DIM::NodeDim::eVenDoghouse:
			m_Ventilate.push_back(data);
			break;
		case MK_DIM::NodeDim::eDoghouse:
			m_doghouse.push_back(data);
			break;
		case MK_DIM::NodeDim::eDrainWell:
			m_wells.push_back(data);
			break;
		case MK_DIM::NodeDim::eOutlet:
			m_outlets.push_back(data);
			break;
		default: break;
		}
	}

	void CEWTank::calcData(const MK_DIM::NodeDim::ENodeType &type)
	{
		switch (type)
		{
		case MK_DIM::NodeDim::eFireWall:
			calcFireZone();
			break;
		case MK_DIM::NodeDim::eEscapeHatch:
			calcEscape();
			break;
		case MK_DIM::NodeDim::eVenDoghouse:
			calcVentilateZone();
			calcVentilate();
			break;
		case MK_DIM::NodeDim::eDoghouse:
			calcDoghouse();
			break;
		case MK_DIM::NodeDim::eDrainWell:
			calcWell();
			break;
		case MK_DIM::NodeDim::eOutlet:
			calcOutlet();
			break;
		default: break;
		}
	}

	void CEWTank::calcFireZone()
	{
		calc(m_calcFireZone, m_fireWall);
	}

	void CEWTank::calcVentilateZone()
	{
		EWVentilate v;
		for (size_t i = 0; i < m_Ventilate.size(); ++i)
		{
			if (i + 1 < m_Ventilate.size())
			{
				const EWNodeData d1 = m_Ventilate[i];
				const EWNodeData d2 = m_Ventilate[i + 1];
				v.m_stake = d1.m_dDistance > d2.m_dDistance ? d2.m_stake + _T("~") + d1.m_stake : d1.m_stake + _T("~") + d2.m_stake;
				v.m_dDistance = abs(d1.m_dDistance - d2.m_dDistance);
				v.m_dNumVentilate = m_options[VEN_NUM];
				v.m_dArea = getSectionArea();
				m_calcVentilate.push_back(v);
			}
		}
	}

	void CEWTank::calcVentilate()
	{
		// 进行本次计算前，应该先计算出通风分区 calcVentilateZone()
		for (size_t i = 0; i < m_calcVentilate.size(); ++i)
		{
			EWVentilate &v = m_calcVentilate[i];
			v.m_dVolum = v.m_dDistance * v.m_dArea;
			v.m_dAirHr = v.m_dVolum * v.m_dNumVentilate;
		}
	}

	void CEWTank::calcEscape()
	{
		calc(m_calcEscape, m_escape);
	}

	void CEWTank::calcDoghouse()
	{
		calc(m_calcDoghouse, m_doghouse);
	}

	void CEWTank::calcWell()
	{
		calc(m_calcWell, m_wells);
	}

	void CEWTank::calcOutlet()
	{
		calc(m_calcOutlet, m_outlets);
	}

	void CEWTank::calc(EWNodeDatas &out, const EWNodeDatas &data)
	{
		out.clear();
		for (size_t i = 0; i < data.size(); ++i)
		{
			if (i + 1 < data.size())
			{
				const EWNodeData &d1 = data[i];
				const EWNodeData &d2 = data[i + 1];
				out.push_back(
					EWNodeData(
						d1.m_dDistance > d2.m_dDistance ? d2.m_stake + _T("~") + d1.m_stake : d1.m_stake + _T("~") + d2.m_stake
						, abs(d1.m_dDistance - d2.m_dDistance))
				);
			}
		}
	}

	void SetRoomTypeByIdx()
	{
		return;
	}
//////////////////////////////////////////////////////////////////////////
	AcEdJig::DragStatus TableJig::doIt()
	{
		setDispPrompt(m_Prompt);
		AcEdJig::DragStatus st = drag();
		return st;
	}

	AcEdJig::DragStatus TableJig::sampler()
	{
		AcEdJig::DragStatus st = acquirePoint(m_ptPos);
		return st;
	}

	Adesk::Boolean TableJig::update()
	{
		if (!m_pTbl) return Adesk::kFalse;
		m_pTbl->setPosition(m_ptPos);
		m_pTbl->generateLayout();
		return Adesk::kTrue;
	}

}