#include "stdafx.h"
#include "XDBDlg.h"
#include "AecDbSlab.h"
#include "KTCadUtility.h"
#include "coretools.h"
#include "KTSetting.h"
#include "GiDrawUtility.h"

DLLIMPEXP CString IDCreate();

#define XDB_FLAG_PTS _T("_XDB_FLAG_PTS_")
#define XDB_FLAG_PTE _T("_XDB_FLAG_PTE_")
#define XDB_FLAG_DIST _T("_XDB_FLAG_DIST_")
#define XDB_FLAG_ELEV _T("_XDB_FLAG_ELEV_")
#define XDB_FLAG_PROFILE _T("_XDB_FLAG_PROFILE_")

namespace
{
	// pline投影到平面pln上，投影方向dir
	AcDbPolyline* makeProject(const AcDbPolyline *pSrc
		, const AcGePlane &pln
		, const AcGeVector3d &dir)
	{
	#if ARX > 18
		{
			// 如果 _pln 和 pln 共面，则不投影
			AcDb::Planarity pa;
			AcGePlane _pln;
			pSrc->getPlane(_pln, pa);
			if (_pln.isCoplanarTo(pln, AcGeContext::gTol))
				return (AcDbPolyline *)pSrc->clone();
		}

		AcGeCurve3d *pGeCrv(NULL);
		pSrc->getAcGeCurve(pGeCrv);
		if (!pGeCrv) return NULL;

		pGeCrv->transformBy(AcGeMatrix3d::projection(pln, dir));

		AcDbPolyline *pNew(NULL);
	#ifndef ZWCAD
		if (AcDbCurve::createFromAcGeCurve(*pGeCrv, (AcDbCurve *&)pNew) != Acad::eOk)
		#else
		if (AcDbCurve::createFromZcGeCurve(*pGeCrv, (AcDbCurve *&)pNew) != Acad::eOk)
	#endif
		{
			acutPrintf(_T("GeCurve 转换 DbCurve 失败。"));
			DELETE_PTR(pNew);
		}

		DELETE_PTR(pGeCrv);
		return pNew;
	#else
		return NULL;
	#endif
	}
}

IMPLEMENT_DYNAMIC(CXDBDlg, CDialog)

CXDBDlg::CXDBDlg(CWnd *pParent /*=NULL*/)
	: CDialog(CXDBDlg::IDD, pParent)
	, m_dBomThick(400.0)
	, m_dHZ(0)
	, m_dHZ2(0)
	, m_sZFlag(_T(""))
	, m_sNO(_T(""))
	, m_bAddHatch(TRUE)
	, m_sHatch(HATCH_DEFAULT)
	, m_dIDist(-10.)
	, m_dElev(-1.)
{
	m_sMaterial = _T("钢筋混凝土");
	m_sPurpose = _T("过滤池");

	GET_CACHE(CXDBDlg
		, %f%f%f%s%s%s%s%f%f
		, &m_dBomThick
		, &m_dHZ
		, &m_dHZ2
		, &m_sMaterial
		, &m_sPurpose
		, &m_sZFlag
		, &m_sHatch
		, &m_dIDist
		, &m_dElev
	);
	m_sNO = IDCreate();
}

CXDBDlg::~CXDBDlg()
{
}

bool CXDBDlg::isXDB(const AcDbObjectId &id)
{
	AcDbObjectPointer<AecDbXSlab> pSlab(id, AcDb::kForRead);
	if (pSlab.openStatus() == Acad::eOk)
	{
		BOOL bXDB(FALSE);
		pSlab->GetAt(AecDbXSlab::KEY_XDB_Flag, bXDB);
		pSlab->close();
		return bXDB == FALSE ? false : true;
	}
	return false;
}

void CXDBDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDIT_THICK, m_dBomThick);
	DDX_Text(pDX, IDC_EDIT_HENGZAI, m_dHZ);
	DDX_Text(pDX, IDC_EDIT_HUOZAI, m_dHZ2);
	DDX_Text(pDX, IDC_EDIT_MATERIAL, m_sMaterial);
	DDX_Text(pDX, IDC_EDIT_APP, m_sPurpose);
	DDX_Text(pDX, IDC_EDIT_LOAD_TYPE, m_sZFlag);
	DDX_Control(pDX, IDC_BTN_FILL, m_wndBtHatch);
	DDX_Check(pDX, IDC_CHECK_HATCH, m_bAddHatch);
	DDX_Text(pDX, IDC_BTN_FILL, m_sHatch);
	DDX_Text(pDX, IDC_EDIT_I, m_dIDist);
	DDX_Text(pDX, IDC_EDIT_ELEV, m_dElev);
}

BEGIN_MESSAGE_MAP(CXDBDlg, CDialog)
	ON_BN_CLICKED(IDOK, &CXDBDlg::OnBnClickedOk)
	ON_BN_CLICKED(IDC_BTN_FILL, &CXDBDlg::OnBnClickedBtnFill)
	ON_BN_CLICKED(IDC_CHECK_HATCH, &CXDBDlg::OnBnClickedCheckHatch)
END_MESSAGE_MAP()


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

	m_wndBtHatch.EnableWindow(m_bAddHatch);
	UpdateData(FALSE);

	return TRUE;
}

void CXDBDlg::OnBnClickedOk()
{
	UpdateData(TRUE);

	SET_CACHE(CXDBDlg
		, %f%f%f%s%s%s%s%f%f
		, m_dBomThick
		, m_dHZ
		, m_dHZ2
		, m_sMaterial
		, m_sPurpose
		, m_sZFlag
		, m_sHatch
		, m_dIDist
		, m_dElev
	);

	OnOK();
}

extern bool __cdecl acedHatchPalletteDialog(wchar_t const* , bool , wchar_t *&); 
void CXDBDlg::OnBnClickedBtnFill()
{
	UpdateData();
	TCHAR *psz = new TCHAR[1024];
	::memset(psz, 0, sizeof(TCHAR) * 1024);

	CString sHatch(m_sMaterial);
	if (!m_sHatch.IsEmpty())
		sHatch = m_sHatch;

	if (acedHatchPalletteDialog(sHatch, false, psz))
	{
		m_sHatch = psz;
		m_wndBtHatch.SetWindowText(m_sHatch);
	}

	delete[] psz;
}


void CXDBDlg::OnBnClickedCheckHatch()
{
	UpdateData();
	m_wndBtHatch.EnableWindow(m_bAddHatch);
	if (!m_bAddHatch)
		m_sHatch = HATCH_NO_NEED;
	else
		m_sHatch = HATCH_DEFAULT;

	UpdateData(FALSE);
}

void CXDBDlg::dbl_xdb(const AcDbObjectId &id)
{
	CAcModuleResourceOverride myResources;
	CXDBDlg dlg;
	AcDbObjectPointer<AecDbXSlab> pSlab(id, AcDb::kForRead);
	if (pSlab.openStatus() != Acad::eOk) return;
	pSlab->close();

	pSlab->GetAt(KEY_HZ, dlg.m_dHZ);
	pSlab->GetAt(KEY_HZ2, dlg.m_dHZ2);
	pSlab->GetAt(KEY_ZHFS, dlg.m_sZFlag);
	pSlab->GetAt(KEY_MATERIAL, dlg.m_sMaterial);
	pSlab->GetAt(KEY_PURPOSE, dlg.m_sPurpose);
	pSlab->GetAt(KEY_BOMTHICK, dlg.m_dBomThick);
	pSlab->GetAt(KEY_SECTION_HATCH, dlg.m_sHatch);

	pSlab->GetAt(XDB_FLAG_PTS, dlg.m_ptS);
	pSlab->GetAt(XDB_FLAG_PTE, dlg.m_ptE);
	pSlab->GetAt(XDB_FLAG_PROFILE, dlg.m_sProfile);
	pSlab->GetAt(XDB_FLAG_DIST, dlg.m_dIDist);
	pSlab->GetAt(XDB_FLAG_ELEV, dlg.m_dElev);

	if (dlg.m_sHatch == HATCH_NO_NEED)
		dlg.m_bAddHatch = FALSE;
	else
		dlg.m_bAddHatch = TRUE;


	if (dlg.DoModal() != IDOK) return;

	dlg.makeSlab(id);
}

void CXDBDlg::start()
{
#if ARX > 18

	ads_name ent;
	struct resbuf *pRb = acutBuildList(RTDXF0, _T("LWPOLYLINE"), 0);
	int nRes = CKTCadUtility::SelectEntity(_T("\n请拾取闭合且水平的多段线来确定板轮廓:"), ent, pRb);
	acutRelRb(pRb);
	if (nRes != RTNORM) return;

	AcDbObjectId id;
	acdbGetObjectId(id, ent);
	if (!id.isValid()) return;

	AcDbObjectPointer<AcDbPolyline> entPtr(id, AcDb::kForRead);
	if (entPtr.openStatus() != Acad::eOk) return;

	AcDbPolyline *pLine = (AcDbPolyline*)entPtr->clone();

	if (CoreTools::isPolylineSelfCollinear(pLine))
	{
		AfxMessageBox(_T("多段线不符合条件！"));
		DELETE_PTR(pLine);
		return;
	}

	// 检查是否闭合
	if (!pLine->isClosed())
	{
		if (pLine->numVerts() > 2)
			pLine->setClosed(Adesk::kTrue);
		else
		{
			DELETE_PTR(pLine);
			return;
		}
	}

	// 检查是否水平
	if (!pLine->normal().isParallelTo(AcGeVector3d::kZAxis))
	{
		AfxMessageBox(_T("多段线不水平。"));
		DELETE_PTR(pLine);
		return;
	}

	CString srcXYPlanStr;
	bool bSucess = CoreTools::PolylineToString(pLine, srcXYPlanStr);
	DELETE_PTR(pLine);
	if (!bSucess)
	{
		acutPrintf(_T("轮廓转换失败。"));
		return;
	}

	ads_point adspt1, adspt2;
	if (acedGetPoint(NULL, _T("\n输入第一个点(这个点将作为倾斜的起点)："), adspt1) != RTNORM) return;
	if (acedGetPoint(adspt1, _T("\n输入第二个点："), adspt2) != RTNORM) return;

	CAcModuleResourceOverride myResources;
	CXDBDlg dlg;

	dlg.m_ptS = asPnt3d(adspt1);
	dlg.m_ptE = asPnt3d(adspt2);
	CoreTools::UCS2WCS(dlg.m_ptS, dlg.m_ptS);
	CoreTools::UCS2WCS(dlg.m_ptE, dlg.m_ptE);
	dlg.m_sProfile = srcXYPlanStr;

	if (dlg.DoModal() != IDOK) return;

	dlg.makeSlab(AcDbObjectId::kNull);
#else
	return;
#endif
}

bool CXDBDlg::makeSlab(AcDbObjectId id)
{
#if ARX > 18
	AcDbPolyline *pXYPoly = CoreTools::StringToPolyline(m_sProfile);
	if (!pXYPoly)
	{
		acutPrintf(_T("\n还原水平多段线失败。"));
		return false;
	}

	AcGePoint3d ptCen;
	pXYPoly->getPointAt(0, ptCen);

	AcDbObjectId idLay = KTSetting::InitLayer(_T("LAY_SLAB_DIBAN"), true);

	AecDbXSlab *pSlab(NULL);
	AcDbObjectPointer<AecDbXSlab> entSlab(id, AcDb::kForWrite);
	if (entSlab.openStatus() != Acad::eOk)
	{
		pSlab = new AecDbXSlab;
		pSlab->setLayer(idLay);
		pSlab->SetAt(KEY_NO, m_sNO);
		pSlab->SetAt(KEY_USEPICKWALLS, FALSE);
		pSlab->SetAt(KEY_GRADX, _T("0"));
		pSlab->SetAt(KEY_GRADY, _T("0"));
		pSlab->SetAt(AecDbXSlab::KEY_XDB_Flag, TRUE);
		pSlab->SetAt(XDB_FLAG_PTS, m_ptS);
		pSlab->SetAt(XDB_FLAG_PTE, m_ptE);
		pSlab->SetAt(XDB_FLAG_PROFILE, m_sProfile);
		pSlab->SetAt(KEY_ORGPT, ptCen);
		pSlab->SetAt(KEY_POINTS, m_sProfile);
		pSlab->SetAt(KEY_SHAPE, eUserDef);
		CoreTools::AddToModelSpace(pSlab, false);
	}
	else
	{
		pSlab = entSlab;
	}

	if (pSlab)
	{
		AcDbLine _L(ptCen, ptCen - AcGeVector3d::kZAxis * m_dBomThick);
		pSlab->SetBaseCurve(&_L);
		pSlab->SetSection(pXYPoly, ptCen);

		pSlab->SetAt(KEY_BOMTHICK, m_dBomThick);
		pSlab->SetAt(KEY_HZ, m_dHZ);
		pSlab->SetAt(KEY_HZ2, m_dHZ2);
		pSlab->SetAt(KEY_ZHFS, m_sZFlag);
		pSlab->SetAt(KEY_MATERIAL, m_sMaterial);
		pSlab->SetAt(KEY_PURPOSE, m_sPurpose);
		pSlab->SetAt(KEY_SECTION_HATCH, m_sHatch);


		pSlab->SetAt(XDB_FLAG_DIST, m_dIDist);
		pSlab->SetAt(XDB_FLAG_ELEV, m_dElev);

		pSlab->close();
	}

	DELETE_PTR(pXYPoly);
	return true;
#else
	return false;
#endif
}