#include "StdAfx.h"
#include "ent2db.h"
#include <map>
#include "TSQLite.h"
#include "shjson.h"
#include "KTCADUtilityEx.h"
#include "KTCadUtility.h"
#include "geometry2json.h"
#include "CoreTools.h"
#include "AecDbWall.h"
#include "AecDbBeam.h"
#include "AecDbSlab.h"
#include "AecDbColumn.h"
#include "AecDbEwEquipment.h"
#include "AecDbParamEquipment.h"
#include "AecDbFlume.h"
#include "AecDbRiverGroove.h"
#include "AecDbEwPipe.h"
#include "aecdbewfitting.h"
#include "AecDbHvacDuct.h"
#include "AecDbHvacFitting.h"
#include "AecDbECableTray.h"
#include "aecdbecfitting.h"
#include "AecDbX3dPartEntity.h"
#include "AecDbOpening.h"
#include "AecDbHolder.h"
#include "AecDbBossHolder.h"
#include "AecDbhanger.h"
#include "AecDbXEquipment.h"
#include "AecDbClimbStair.h"
#include "AecDbZLineStair.h"
#include "AecDbMRPLineStair.h"
#include "AecDbCornerStair.h"
#include "AecDbCrossStair.h"
#include "AecDbDoubleMulStair.h"
#include "AecDbLineSegStair.h"
#include "AecDbParaLlelStair.h"
#include "AecDbRectCornerStair.h"
#include "AecDbScissorsStair.h"
#include "AecDbTriangleStair.h"

using namespace SHJson;

namespace ENT2DB
{
	const CString g_dbName(_T("\\sh_export.db"));

	const CString g_sqlTable =
		_T("create table 'AEC_ENTITIES' (\n")\
		_T("'ID' integer primary key autoincrement not null,\n")\
		_T("'CLASS' text not null,\n")\
		_T("'SELF' integer not null,\n")\
		_T("'OWNER' integer not null,\n")\
		_T("'DATA' text not null);\n");

	struct SimpleInterface
	{
		AcDbObjectId pid;
		AcGePoint3d ptPos;
		SimpleInterface() {};
		SimpleInterface(const AcDbObjectId &id, const AcGePoint3d &pt): pid(id), ptPos(pt) {};
		bool operator < (SimpleInterface s1) const { return pid < s1.pid; }
	};

	bool isSameInterface(const AecInterface &inf1, const AecInterface &inf2)
	{
		if (EQUAL_ZERO(inf1.ptPos.distanceTo(inf2.ptPos))) return true;

		AcGeVector3d vt1(inf1.vtDir), vt2(inf2.vtDir);
		
		if (vt1.normalize().negate() == vt2.normalize())
		{
			if (inf1.ptPos.distanceTo(inf2.ptPos) < (inf1.dSize1 + inf2.dSize1) * .5)
				return true;
		}
		return false;
	}

	// 得到 实体 接口
	bool getInterfaces(AcDbObjectId id, AcArray<AecInterface> &ar)
	{
		OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbEwPipe, pEnt)
		if (pEnt)
		{
			pEnt->GetInterface(ar);
		}
		OPENOBJ_END()
		OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbEwEquipment, pEnt)
		if (pEnt)
		{
			pEnt->GetInterface(ar);
		}
		OPENOBJ_END()
		OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbEwFitting, pEnt)
		if (pEnt)
		{
			pEnt->GetInterface(ar);
		}
		OPENOBJ_END()

		OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbECableTray, pEnt)
		if (pEnt)
		{
			pEnt->GetInterface(ar);
		}
		OPENOBJ_END()
		OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbHvacDuct, pEnt)
		if (pEnt)
		{
			pEnt->GetInterface(ar);
		}
		OPENOBJ_END()
		OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbEcFitting, pEnt)
		if (pEnt)
		{
			pEnt->GetInterface(ar);
		}
		OPENOBJ_END()
		OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbHvacFitting, pEnt)
		if (pEnt)
		{
			pEnt->GetInterface(ar);
		}
		OPENOBJ_END()

		return !ar.isEmpty();
	}

	int getMEPType(AcDbObjectId id)
	{
		if (ENT2DB::isEntity<AecDbEwFitting>(id)
			||ENT2DB::isEntity<AecDbEwPipe>(id))
			return 0;
		else if (ENT2DB::isEntity<AecDbHvacFitting>(id)
			||ENT2DB::isEntity<AecDbHvacFitting>(id))
			return 1;
		else if (ENT2DB::isEntity<AecDbEcFitting>(id)
			||ENT2DB::isEntity<AecDbECableTray>(id))
			return 2;
		else if (ENT2DB::isEntity<AecDbEwEquipment>(id))
		{
			AcArray<AecInterface> ar;
			getInterfaces(id, ar);
			if (ar.isEmpty()) return -1;
			AecInterface &inf = ar.first();
			if (inf.nType == 0) return 0;
			else if (inf.nType == 1) return 1;
			return 2;
		}
		return -1;
	}

	// 判断接口 inf 是否已经被实体记录
	// 如果被记录，反回true
	bool hasRecord(AecInterface inf
		, AcDbObjectId id
		, const std::multimap<AcDbObjectId, AecInterface> &ss)
	{
		typedef std::multimap<AcDbObjectId, AecInterface>::const_iterator _IT;
		std::pair<_IT, _IT> pr = ss.equal_range(id);
		for (_IT it = pr.first; it != pr.second; ++it)
		{
			if (it->second.ptPos == inf.ptPos) return true;
		}
		return false;
	}

	// 判断 id1 和 id2 有没有相连的接口
	// 如果找到，将关联信息写到两个实体中
	// 找到返回true
	void findInterface(AcDbObjectId id1
		, AcDbObjectId id2
		, std::multimap<AcDbObjectId, AecInterface> &ss)
	{
		AcArray<AecInterface> ar1(0), ar2(0);
		if (!getInterfaces(id1, ar1)) return;
		if (!getInterfaces(id2, ar2)) return;

		int nType1(-1), nType2(-1);

		for (int i = 0; i < ar1.length(); ++i)
		{
			AecInterface &inf1 = ar1[i];
			if (hasRecord(inf1, id1, ss)) continue;
			nType1 = getMEPType(id1);

			for (int j = 0; j < ar2.length(); ++j)
			{
				AecInterface &inf2 = ar2[j];
				if (hasRecord(inf2, id2, ss)) continue;
				nType2 = getMEPType(id2);

				if (isSameInterface(inf1, inf2))
				{
					AecInterface inf = inf1;
					inf.nType = nType1;
					inf.idOwner = id2;	// 在这里 idOwner 代表所连接的实体ID
					ss.insert(std::make_pair(id1, inf));
					inf = inf2;
					inf.nType = nType2;
					inf.idOwner = id1;
					ss.insert(std::make_pair(id2, inf));
				}
			}
		}
	}

	// 收集 管道，管件，管道附件 的接口信息
	void collectInterfaceInfo(AcDbObjectIdArray ar
		, std::multimap<AcDbObjectId, AecInterface> &ss)
	{
		for (int i = 0; i < ar.length(); ++i)
		{
			// id 与 其它实体都比较一次
			for (int j = i + 1; j < ar.length(); ++j)
			{
				findInterface(ar[i], ar[j], ss);
			}
		}

		// 以上代码可以处理互相连接的接口，但是没有连接的接口也需要记录。
		AcArray<AecInterface> infs(0);
		AecInterface inf;
		for (int i = 0; i < ar.length(); ++i)
		{
			infs.removeAll();
			getInterfaces(ar[i], infs);
			if (infs.isEmpty()) continue;
			typedef std::multimap<AcDbObjectId, AecInterface>::const_iterator _IT;
			std::pair<_IT, _IT> pr = ss.equal_range(ar[i]);
			// 如果不在 pr 范围内存在，则说明是空接口，需要记录
			int count = (int)std::distance(pr.first, pr.second);
			// 如果查找出记录的数量与实体本身的数量一致，说明都记录上了
			if (count == infs.length()) continue;

			for (int j = 0; j < infs.length(); ++j)
			{
				bool isHas(false);
				for (_IT it = pr.first; it != pr.second; ++it)
				{
					if (isSameInterface(it->second, infs[j]))
					{
						isHas = true;
						break;
					}
				}
				if (!isHas)
				{
					inf = infs[j];
					inf.idOwner = AcDbObjectId::kNull;
					inf.nType = getMEPType(ar[i]);
					ss.insert(std::make_pair(ar[i], inf));
				}
			}
		}
	}

	template <class Fi, class Pi>
	void getConnectorForFitting(AcDbObjectId fitID
		, AcDbObjectIdArray pipes
		, std::set<SimpleInterface> &connectors)
	{
		AcArray<AecInterface> aifs;
		AecInterface aif;
		SimpleInterface sinf;
		OPENOBJ_BEGIN(fitID, AcDb::kForRead, Fi, pFit)
		{
			if (!pFit) return;

			for (int f = 0; f < pFit->GetInterfaceCount(); ++f)
			{
				if (!pFit->GetInterface(f, aif)) continue;
				for (int i = 0; i < pipes.length(); ++i)
				{
					OPENOBJ_BEGIN(pipes[i], AcDb::kForRead, Pi, pPipe)
					{
						aifs.removeAll();
						if (!pPipe) continue;
						if (!pPipe->GetInterface(aifs)) continue;
						if (aifs.length() < 2) continue;

						if (isSameInterface(aifs[0], aif))
						{
							sinf.pid = pPipe->objectId();
							sinf.ptPos = aifs[0].ptPos;
							connectors.insert(sinf);
							break;
						}
						else if (isSameInterface(aifs[1], aif))
						{
							sinf.pid = pPipe->objectId();
							sinf.ptPos = aifs[1].ptPos;
							connectors.insert(sinf);
							break;
						}
					}
					OPENOBJ_END()
				}
			}
		}
		OPENOBJ_END()
	}

	template <class Fi, class Pi>
	void writeConnector2Fitting(AcDbObjectIdArray fids, AcDbObjectIdArray pids)
	{
		std::set<SimpleInterface> connectors;
		CString sName(_T(""));
		for (int i = 0; i < fids.length(); ++i)
		{
			connectors.clear();
			getConnectorForFitting<Fi, Pi>(fids[i], pids, connectors);
			OPENOBJ_BEGIN(fids[i], AcDb::kForWrite, Fi, pFit)
			{
				AecDbObjXDataMap *pMap = pFit->GetSpecialtyData(AcDb::kForWrite);
				if (!pMap) continue;

				if (ENT2DB::isEntity<AecDbEwFitting>(pFit))
					pMap->SetAt(_T("MEP_TYPE"), 0);
				else if (ENT2DB::isEntity<AecDbEcFitting>(pFit))
					pMap->SetAt(_T("MEP_TYPE"), 1);
				else if (ENT2DB::isEntity<AecDbHvacFitting>(pFit))
					pMap->SetAt(_T("MEP_TYPE"), 2);

				pMap->SetAt(_T("CONNECTOR_COUNT"), (int)connectors.size());
				int idx(0);
				for (std::set<SimpleInterface>::const_iterator it = connectors.begin()
					; it != connectors.end()
					; ++it, ++idx)
				{
					sName.Format(_T("CONNECTOR_Id_%d"), idx);
					pMap->SetAt(sName, it->pid);
					sName.Format(_T("CONNECTOR_Pos_%d"), idx);
					pMap->SetAt(sName, it->ptPos);
				}
			}
			OPENOBJ_END()
		}

	}

	bool getSHObjects(LPCTSTR dxf
		, AcDbObjectIdArray &ids
		, AcDbObjectIdArray &idsRepeat
		, std::multimap<AcDbObjectId, AecInterface> &infs)
	{
		resbuf *pRb = acutBuildList(RTDXF0, dxf, 0);
		ads_name ss, ent;

		if (CKTCadUtility::SelectEntities(_T("\n请选择要导出的上华实体："), ss, pRb) != RTNORM) return false;
		//int nRes = acedSSGet(_T("A"), NULL, NULL, pRb, ss);
		acutRelRb(pRb);

		AcDbObjectId id;
		Adesk::Int32 lLen(0L);
		acedSSLength(ss, &lLen);

		ids.removeAll();

		AcDbObjectIdArray arPipes, arDucts, arCabletray
			, arEwFits, arHvacFits, arEcFits, arEquis, allEw, allEc, allHv;
		for (long i = 0; i < lLen; ++i)
		{
			if (acedSSName(ss, i, ent) != RTNORM) continue;
			if (acdbGetObjectId(id, ent) != Acad::eOk) continue;

			OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
			{
				if (pEnt)
				{
					// 把在revit中可以做族文件的实体都挑出来
					if (AecDbXOpening::cast(pEnt)
						|| AecDbHolder::cast(pEnt)
						|| AecDbHanger::cast(pEnt)
						|| AecDbBossHolder::cast(pEnt)
						|| AecDbClimbStair::cast(pEnt)
						|| AecDbZLineStair::cast(pEnt)
						|| AecDbMRPLineStair::cast(pEnt)
						|| AecDbXEquipment::cast(pEnt)
						|| AecDbCornerStair::cast(pEnt)
						|| AecDbCrossStair::cast(pEnt)
						|| AecDbDoubleMulStair::cast(pEnt)
						|| AecDbLineSegStair::cast(pEnt)
						|| AecDbParaLlelStair::cast(pEnt)
						|| AecDbRectCornerStair::cast(pEnt)
						|| AecDbScissorsStair::cast(pEnt)
						|| AecDbTriangleStair::cast(pEnt)
						)
						idsRepeat.append(id);
					else
						ids.append(id);


					// 找出所有的 管实体（管线，风管，桥架）及 管件实体（管件，风管件，电气管件）
					if (AecDbEwPipe::cast(pEnt)) arPipes.append(id);
					else if (AecDbECableTray::cast(pEnt)) arCabletray.append(id);
					else if (AecDbHvacDuct::cast(pEnt)) arDucts.append(id);
					else if (AecDbEwFitting::cast(pEnt)) arEwFits.append(id);
					else if (AecDbEcFitting::cast(pEnt)) arEcFits.append(id);
					else if (AecDbHvacFitting::cast(pEnt)) arHvacFits.append(id);
					else if (AecDbEwEquipment::cast(pEnt)) arEquis.append(id);
				}
			}
			OPENOBJ_END()
		}
		acedSSFree(ss);

		allEw.append(arPipes);
		allEw.append(arEwFits);

		allEc.append(arCabletray);
		allEc.append(arEcFits);

		allHv.append(arDucts);
		allHv.append(arHvacFits);

		// 设备可能对应着 风管，桥架，管道，所以都放进去
		allEw.append(arEquis);
		allHv.append(arEquis);
		allEc.append(arEquis);

		collectInterfaceInfo(allEw, infs);
		collectInterfaceInfo(allEc, infs);
		collectInterfaceInfo(allHv, infs);

		return !(ids.isEmpty() && idsRepeat.isEmpty());
	}

	CString getTableName(const AcDbEntity *pEnt)
	{
		return _T("AEC_ENTITIES");
		const AecDbXWall *pWall(AecDbXWall::cast(pEnt));
		if (pWall) return _T("AEC_WALL");

		const AecDbBeam *pBeam(AecDbBeam::cast(pEnt));
		if (pBeam) return _T("AEC_BEAM");

		const AecDbXSlab *pSlab(AecDbXSlab::cast(pEnt));
		if (pSlab) return _T("AEC_SLAB");

		const AecDbColumn *pColumn(AecDbColumn::cast(pEnt));
		if (pColumn) return _T("AEC_COLUMN");

		const AecDbEwEquipment *pEqu(AecDbEwEquipment::cast(pEnt));
		if (pEqu) return _T("AEC_EQU");

		const AecDbParamEquipment *pParamEqu(AecDbParamEquipment::cast(pEnt));
		if (pParamEqu) return _T("AEC_PARAMEQU");

		const AecDbFlume *pFlume(AecDbFlume::cast(pEnt));
		if (pFlume) return _T("AEC_FLUME");

		const AecDbRiverGroove *pGroove(AecDbRiverGroove::cast(pEnt));
		if (pGroove) return _T("AEC_GROOVE");

		const AecDbEwPipe *pPipe(AecDbEwPipe::cast(pEnt));
		if (pPipe) return _T("AEC_PIPE");

		const AecDbX3dPartEntity *p3d(AecDbX3dPartEntity::cast(pEnt));
		if (p3d) return _T("AEC_X3DPART");

		return _T("");
	}

	CString getUniqueName(AcDbObjectId id)
	{
		CString str(_T(""));
		OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
		{
			if (pEnt)
			{
				AecDbEntityBase *pBase(AecDbEntityBase::cast(pEnt));
				AecDbCurveBase *pCurve(AecDbCurveBase::cast(pEnt));
				if (pBase)
					return pBase->getUniqueName();
				if (pCurve)
					return pCurve->getUniqueName();
			}
		}
		OPENOBJ_END()
		return str;
	}

	bool _export(TSQLite &dbSql, const WValue &v, LPCTSTR pszTable, WValue &debug)
	{
		if (!pszTable) return false;

		WValue vClone;
		vClone.CopyFrom(v, getJsonAllocator());

		CString  sql(_T(""));
		std::wstring self, owner;

		MCIt itSelf = v.FindMember(_T("__self__"));
		MCIt itOwner = v.FindMember(_T("__owner__"));
		MCIt itClass = v.FindMember(_T("__class__"));

		Adesk::IntDbId idSelf(0), idOwner(0);
		CString sClass(_T(""));
		if (itSelf != v.MemberEnd()) idSelf = itSelf->value.GetInt64();
		if (itOwner != v.MemberEnd()) idOwner = itOwner->value.GetInt64();
		if (itClass != v.MemberEnd()) sClass = itClass->value.GetString();

		self = TypeConvert::convert<std::wstring, __int64>(idSelf);
		owner = TypeConvert::convert<std::wstring, __int64>(idOwner);

		sql.Format(_T("insert into %s ('CLASS','SELF','OWNER','DATA') values('%s','%s','%s','%s')")
			, pszTable
			, sClass
			, self.c_str()
			, owner.c_str()
			, write2Json(v).c_str());
		if (!dbSql.exec(sql)) return false;

#ifndef NDEBUG
		if (!debug.IsNull())
		{
			pushBack(debug, vClone);
		}
#endif
		return true;
	}

	void Export(TSQLite &dbSql
		, AcDbObjectIdArray &ar
		, const AcDbObjectIdArray &arRepeat
		, const std::multimap<AcDbObjectId, AecInterface> &infs
		, WValue &jsonFile)
	{
		/*
		实体的 ToJson()函数返回的 json 结构必须有 __self__,__owner__,两个字段
		如果存在 __attachment__ 结构，则说明存在附着体（目前只有 构筑物上的单体）
		{
			"__self__": AcDbObjectId.asOldId(),			必有
			"__owner__": AcDbObjectId.asOldId(),		必有
			"__xdata__": 实体的AecDbObjXDataMap,			可选
			"__attachment__":{}							可选
		}
		*/
		if (ar.isEmpty() && arRepeat.isEmpty()) return;

		// 处理一下重复实体
		std::map<CString, AcDbObjectIdArray> mmRepeats;
		std::map<CString, Adesk::IntDbId> mmIds;	// 保存了绘制几何信息的实体的id
		CString name;
		AcDbObjectIdArray arids;
		AcDbObjectId idRepeat;
		for (int i(0); i < arRepeat.length(); ++i)
		{
			idRepeat = arRepeat[i];
			name = getUniqueName(idRepeat);
			if (name.IsEmpty())
			{	// 没有直接放到ar里面处理
				ar.append(idRepeat);
				continue;
			}
			else
			{	// 判断名字在不在mm里面
				std::map<CString, AcDbObjectIdArray>::iterator it(mmRepeats.end());
				it = mmRepeats.find(name);
				if (it == mmRepeats.end()) // 不在
				{
					arids.removeAll();
					arids.append(idRepeat);
					mmRepeats.insert(std::make_pair(name, arids));
					// idRepeat 是 这个重复实体中得第一个，放到ar里面处理
					ar.append(idRepeat);
					mmIds.insert(std::make_pair(name, idRepeat.asOldId()));
				}
				else
				{
					it->second.append(idRepeat);
				}
			}
		}
		
		AcDbObjectId id;
		WValue v;
		CString table(_T("")), uniqueName(_T(""));
		for (int i = 0; i < ar.length(); ++i)
		{
			v.SetNull();
			id = ar[i];
			OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
			{
				if (!pEnt) continue;

				table = getTableName(pEnt);
				if (table.IsEmpty()) continue;

				AecDbEntityBase *pBase(AecDbEntityBase::cast(pEnt));
				AecDbCurveBase *pCurve(AecDbCurveBase::cast(pEnt));
				if (pBase)
				{
					v.Swap(pBase->ToJson(true));
					uniqueName = pBase->getUniqueName();
				}
				else if (pCurve)
				{
					v.Swap(pCurve->ToJson(true));
					uniqueName = pCurve->getUniqueName();
				}
				else
					continue;

				addMember(v, _T("_unique_name_"), uniqueName);

				// 处理一下接口,为v加入接口信息
				typedef std::multimap<AcDbObjectId, AecInterface>::const_iterator _IT;
				std::pair<_IT, _IT> pr = infs.equal_range(id);
				if (pr.first != infs.end())
				{
					WValue jArInf;
					jArInf.SetArray();
					for (_IT it = pr.first; it != pr.second; ++it)
					{
						WValue jInf;
						jInf.SetObject();
						addMember(jInf, _T("__ptPos__"), GEO2JSON::point(it->second.ptPos).ToJson());
						addMember(jInf, _T("__vtDir__"), GEO2JSON::vector(it->second.vtDir).ToJson());
						addMember(jInf, _T("__dSize1__"), it->second.dSize1);
						addMember(jInf, _T("__dSize2__"), it->second.dSize2);
						addMember(jInf, _T("__nSectType__"), (int)it->second.nSectType);
						addMember(jInf, _T("__idConnect__"), it->second.idOwner.asOldId());
						addMember(jInf, _T("__nMEPType__"), (int)it->second.nType);
						pushBack(jArInf, jInf);
					}
					addMember(v, _T("__interfaces__"), jArInf);
				}
			}
			OPENOBJ_END()

			if (!_export(dbSql, v, table, jsonFile)) continue;
		}

		std::map<CString, AcDbObjectIdArray>::const_iterator it(mmRepeats.begin());
		for (; it != mmRepeats.end(); ++it)
		{
			// 每种类型得第一个都在 ar 里面处理了
			for (int i(1); i < it->second.length(); ++i)
			{

				v.SetNull();
				id = it->second[i];
				OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
				{
					if (!pEnt) continue;

					table = getTableName(pEnt);
					if (table.IsEmpty()) continue;

					AecDbEntityBase *pBase(AecDbEntityBase::cast(pEnt));
					AecDbCurveBase *pCurve(AecDbCurveBase::cast(pEnt));
					if (pBase)
					{
						v.Swap(pBase->ToJson(false));
						uniqueName = pBase->getUniqueName();
					}
					else if (pCurve)
					{
						v.Swap(pCurve->ToJson(false));
						uniqueName = pCurve->getUniqueName();
					}
					else
						continue;

					addMember(v, _T("_unique_name_"), uniqueName);
					// 通过 uniqueName 找到 有几何信息的实体id
					std::map<CString, Adesk::IntDbId>::const_iterator _it = mmIds.find(uniqueName);
					if (_it != mmIds.end())
					{
						addMember(v, _T("_geo_ent_id_"), _it->second);
					}
				}
				OPENOBJ_END()

				if (!_export(dbSql, v, table, jsonFile)) continue;
			}
		}
	}

	void export2Db()
	{
		CFileDialog dlg(FALSE, _T("*.she"), NULL, OFN_HIDEREADONLY, _T("导出数据 (*.she)|*.she||"), acedGetAcadFrame());
		if (dlg.DoModal() != IDOK) return;
		CString dbPath = dlg.GetPathName();
		CString jsonPath = dbPath;
		jsonPath.Replace(_T(".she"), _T(".json"));

		CString dbFile = FilePath::GetSysDir() + g_dbName;
		if (_taccess(dbFile, 0x0) != 0x0)
		{
			AfxMessageBox(_T("未找到导出模板！"));
			return;
		}

		if (!::CopyFile(dbFile, dbPath, FALSE))
		{
			AfxMessageBox(_T("复制模板文件失败！"));
			return;
		}

		TSQLite dbSql;
		if (!dbSql.open(dbPath))
		{
			AfxMessageBox(_T("打开数据库失败！"));
			return;
		}

		if (!dbSql.exec(g_sqlTable))
		{
			AfxMessageBox(_T("初始化表格失败！"));
			return;
		}

		AcDbObjectIdArray ids, idsRepeat;
		CString psz(_T("AEC_DBWALL")\
			_T(",AEC_DBBEAM")\
			_T(",AEC_DBSLAB")\
			_T(",AEC_DBCOLMN")\
			_T(",AEC_DBWEQUIPMENT")\
			_T(",AEC_DBPARAEQUI")\
			_T(",AEC_DBFLUME")\
			_T(",AEC_RIVERGROOVE")\
			_T(",AEC_EWPIPE")\
			_T(",AEC_DBEWFIT")\
			_T(",AEC_GUARDBAR")\
			_T(",AEC_DBLSTAIR")\
			_T(",AEC_DBASTAIR")\
			_T(",AEC_CLMSTAIR")\
			_T(",AEC_DBHVACFIT")\
			_T(",AEC_DBECFIT")\
			_T(",AEC_DBCABTRY")\
			_T(",AEC_DBDUCT")\
			_T(",AEC_MULTIPARTENT")\
			_T(",AEC_DBWEIR")\
			_T(",AEC_DBEXTENDENT")\
			_T(",AEC_DBXEQUIPMENT")\
			_T(",AEC_DBOPENING")\
			_T(",AEC_DBEWPIPEBASE")\
			_T(",AEC_DBMRPSTAIR")\
			_T(",AEC_DBZSTAIR")\
			_T(",AEC_DBXROOF")\
			_T(",AEC_DBBOSSHOLDER")\
			_T(",AEC_DBHANGER")\
			_T(",AEC_DBHOLDER")\
			_T(",AEC_EWCABLE")\
			_T(",AEC_DBCNRSTAIR")\
			_T(",AEC_CROSSSTAIR")\
			_T(",AEC_DOUBLEMULSTAIR")\
			_T(",AEC_DBLNSTAIR")\
			_T(",AEC_PARALLELSTAIR")\
			_T(",AEC_RECTCORNERSTAIR")\
			_T(",AEC_SCISSORSSTAIR")\
			_T(",AEC_TRIANGLESTAIR")\
			_T(",AEC_X3DPART"));
		WValue jsonFile;
	#ifndef NDEBUG
		jsonFile.SetArray();
		// 此版本后(包括版本2),所有自定义设备(包括revit导入),全部由代码生成,不需要额外rfa文件
		WValue ver;
		SHJson::addMember(ver, _T("_version_"), 2);
		SHJson::pushBack(jsonFile, ver);
	#endif
		std::multimap<AcDbObjectId, AecInterface> ss;
		if (getSHObjects(psz, ids, idsRepeat, ss))
		{
			dbSql.beginTrans();
			// 放入版本
			CString sql;
			sql.Format(_T("insert into AEC_ENTITIES ('CLASS','SELF','OWNER','DATA') values('_version_','0','0','2')"));
			dbSql.exec(sql);
			Export(dbSql, ids, idsRepeat, ss, jsonFile);
			dbSql.commitTrans();
		}

	#ifndef NDEBUG
		if (!jsonFile.IsNull())
		{
			SHJson::json2File(jsonPath, jsonFile, true);
		}
	#endif
	}


	void extractSection()
	{
		AcDbObjectIdArray ids;
		CString psz(_T("AEC_DBWALL")\
			_T(",AEC_DBBEAM")\
			_T(",AEC_DBSLAB")\
			_T(",AEC_DBCOLMN"));
		resbuf *pRb = acutBuildList(RTDXF0, psz, 0);
		ads_name ss, ent;
		if (CKTCadUtility::SelectEntities(_T("\n请选择要导出的上华实体："), ss, pRb) != RTNORM) return;
		acutRelRb(pRb);

		AcDbObjectId id;
		Adesk::Int32 lLen(0L);
		acedSSLength(ss, &lLen);

		ids.removeAll();
		for (long i = 0; i < lLen; ++i)
		{
			if (acedSSName(ss, i, ent) != RTNORM) continue;
			if (acdbGetObjectId(id, ent) != Acad::eOk) continue;
			ids.append(id);
		}
		acedSSFree(ss);

		WValue ar, v;
		ar.SetArray();
		for (int i = 0; i < ids.length(); ++i)
		{
			OPENOBJ_BEGIN(ids[i], AcDb::kForRead, AecDbBDPipeBase, pEnt)
			{
				if (!pEnt) continue;
				v.SetObject();
				AcDbRegion *pReg = pEnt->GetSection();
				AcDbCurve *pCurve = pEnt->GetBaseCurve();
				if (pReg)
				{
					SHJson::addMember(v, _T("section"), GEO2JSON::region(*pReg).ToJson());
					CoreTools::CloneAndAddToModelSpace(pReg);
					DELETE_PTR(pReg);
				}
				if (pCurve)
				{
					SHJson::addMember(v, _T("path"), GEO2JSON::region(*pCurve).ToJson());
					CoreTools::CloneAndAddToModelSpace(pCurve);
					DELETE_PTR(pCurve);
				}
				SHJson::pushBack(ar, v);
			}
			OPENOBJ_END()
		}
		//SHJson::json2File(jsonPath, ar, true);
	}
}




namespace
{
	void polygon_boolean(const int &type
		, const AcDbPolyline *p1
		, const AcDbPolyline *p2
		, AcDbPolyline &pRes)
	{

	}
}