#include "stdafx.h"
#include <random>
#include "SigmaView.h"
#include "..\GVision\FaultStatisticsLib\FaultStatisticsCreator.h"

extern "C" __declspec(dllexport)
bool XyCreateFaultStatistic(CXy* pXy, LPCTSTR statisticFile,
	LPCTSTR faultLayer, int markType)
{
	CFaultStatisticsCreator faCreator;
	faCreator.InsertLayer(faultLayer);

	CPtrList* pDataAll = pXy->GetValueList();
	POSITION pos = pDataAll->GetHeadPosition();

	// 设置网格
	COne *pOne;
	CMesh* pMesh = nullptr;
	bool bSuccess = false;
	while (pos)
	{
		pOne = (COne *)(pDataAll->GetNext(pos));
		int nEleType = pOne->GetType();
		// 网格
		if (nEleType == DOUBLEFOX_MESH)
		{
			pMesh = (CMesh*)pOne->value;
			CGrid* pGrid = pMesh->GetMesh();
			
			faCreator.CreateDfg(pGrid->xnum(), pGrid->ynum()
				, pGrid->xmin(), pGrid->ymin(), pGrid->dx(), pGrid->dy()
				, ((CDimension2D*)pGrid)->u);
			faCreator.SetZRange(pGrid->range[0], pGrid->range[1]);
			bSuccess = true;
			break;
		}
	}
	CPositionList lstFault;
	pXy->GetElement(faultLayer, lstFault, DOUBLEFOX_CURVE, true);

	POSITION pt;
	//COne* pOne;
	CCurveEx* pCurve;
	pos = lstFault.GetHeadPosition();
	while (pos)
	{
		pt = lstFault.GetNext(pos);
		pOne = pXy->GetAt(pt);
		if (pOne->GetType() != DOUBLEFOX_CURVE)
			continue;
		pCurve = (CCurveEx*)pOne->GetValue();

		GPline* pc = new GPline();
		pc->SetName(pCurve->GetName());
		NBase::dfPoint fpt;
		int i;
		for (i = 0; i < pCurve->num; i++)
		{
			pCurve->GetPoint(i, fpt);
			GPoint3D pt(fpt.x0, fpt.y0, 0);
			pc->AddPoint(pt);
		}
		uintptr_t number = (uintptr_t)pt;
		char buffer[65];
		//sprintf(buffer, "%lx", pt);
		//sscanf(buffer, "%lx", pt);
		_ui64toa(number, buffer, 10);
		pc->SetPosition(buffer);
		CString strLayerName = pOne->GetLayer()->GetName();
		//TRACE("%s\n", strLayerName);
		faCreator.InsertElement(pc, strLayerName.GetString());
	}

	faCreator.SetOutPaths("", statisticFile);

	faCreator.m_strFltLayer = "";
	//faCreator.m_pillarStep = (float)pillarStep;   // 
	faCreator.m_bLocalFltDirect = true;				//
	faCreator.m_clrMark = RGB(255,0,0);				//
	faCreator.m_iMarkType = markType;				// 
	//faCreator.m_TextHeight = textHeight;          // 

	faCreator.Execute();

	return true;
}

extern "C" __declspec(dllexport)
bool CreateFaultStatistic(CSigmaView* pView, LPCTSTR statisticFile,
	LPCTSTR faultLayer, int markType)
{
	if (pView == nullptr) {
		return false;
	}
	return XyCreateFaultStatistic(pView->m_pDoc->m_pXy, statisticFile, faultLayer, markType);
}
CLayer* FindFaultLayer(CXy* pXy, const CString& strLayer) {
	bool isNew = false;
	CLayer* pLayer = pXy->FindAddLayer(strLayer, &isNew);
	if (isNew == true) {
		if (pLayer->HowToViewCurve == NULL)
		{
			pLayer->HowToViewCurve = new CHowToViewCurve;
			CCurveProperties* pCurveProperty = new CCurveProperties();
			pCurveProperty->SetCurveType(PLINE_SOLID);
			// 定义均匀分布
			std::uniform_int_distribution<int> distribution(0, 255);
			std::uniform_int_distribution<int> distributionR(20, 255);

			// 生成随机数
			std::random_device rd;  // 随机设备，用于生成种子
			std::mt19937 gen(rd()); // 随机数生成器，使用随机设备生成种子
			int randR = distributionR(gen);
			int randG = distribution(gen);
			int randB = distribution(gen);
			pCurveProperty->color = RGB(randR, randG, randB);
			pLayer->HowToViewCurve->Add(pCurveProperty);
		}
	}
	return pLayer;
}

bool XyCreateFaultClass(CXy* pXy,
	LPCTSTR faultLayer, double* classStart, double* classEnd, int classCount, int classType, CString& destLayer)
{
	CFaultStatisticsCreator faCreator;
	faCreator.InsertLayer(faultLayer);

	CPtrList* pDataAll = pXy->GetValueList();
	POSITION pos = pDataAll->GetHeadPosition();

	// 设置网格
	COne *pOne;
	CMesh* pMesh = nullptr;
	bool bSuccess = false;
	while (pos)
	{
		pOne = (COne *)(pDataAll->GetNext(pos));
		int nEleType = pOne->GetType();
		// 网格
		if (nEleType == DOUBLEFOX_MESH)
		{
			pMesh = (CMesh*)pOne->value;
			CGrid* pGrid = pMesh->GetMesh();

			faCreator.CreateDfg(pGrid->xnum(), pGrid->ynum()
				, pGrid->xmin(), pGrid->ymin(), pGrid->dx(), pGrid->dy()
				, ((CDimension2D*)pGrid)->u);
			faCreator.SetZRange(pGrid->range[0], pGrid->range[1]);
			bSuccess = true;
			break;
		}
	}
	CPositionList lstFault;
	pXy->GetElement(faultLayer, lstFault, DOUBLEFOX_CURVE, true);

	POSITION pt;
	//COne* pOne;
	CCurveEx* pCurve;
	pos = lstFault.GetHeadPosition();
	while (pos)
	{
		pt = lstFault.GetNext(pos);
		pOne = pXy->GetAt(pt);
		if (pOne->GetType() != DOUBLEFOX_CURVE) continue;
		pCurve = (CCurveEx*)pOne->GetValue();

		GPline* pc = new GPline();
		NBase::dfPoint fpt;
		int i;
		for (i = 0; i < pCurve->num; i++)
		{
			pCurve->GetPoint(i, fpt);
			GPoint3D pt(fpt.x0, fpt.y0, 0);
			pc->AddPoint(pt);
		}
		uintptr_t number = (uintptr_t)pt;
		char buffer[65];
		//sprintf(buffer, "%lx", pt);
		//sscanf(buffer, "%lx", pt);
		_ui64toa(number, buffer, 10);
		pc->SetPosition(buffer);
		faCreator.InsertElement(pc, faultLayer);
	}

	faCreator.SetOutPaths("", "");

	faCreator.m_strFltLayer = "";
	//faCreator.m_pillarStep = (float)pillarStep;   // 
	faCreator.m_bLocalFltDirect = true;				//
	faCreator.m_clrMark = RGB(255, 0, 0);				//
	//faCreator.m_iMarkType = markType;				// 
	//faCreator.m_TextHeight = textHeight;          // 
	faCreator.Execute();

	std::list<CFaultStatisticsCreator::FltInfo> infos = faCreator.GetFltInfo();
	list<CFaultStatisticsCreator::FltInfo>::iterator iter = infos.begin();
	for (; iter != infos.end(); iter++)
	{
		double dVDist = 0;
		if (classType == 0) {
			dVDist = iter->MaxVDist;
		}
		else if (classType == 1)
		{
			dVDist = iter->fltStrike;
		}
		else if (classType == 2) {
			dVDist = iter->fltLength;
		}
		std::string strPos = (LPCTSTR)iter->position;
		uintptr_t num = std::stoull(strPos);
		void* pVoid = reinterpret_cast<void*>(num);
		POSITION pt = (POSITION)pVoid;

		for (int i = 0; i < classCount; i++)
		{
			if (dVDist >= classStart[i] && dVDist < classEnd[i])
			{
				pOne = pXy->GetAt(pt);
				CString strLayer;
				//strLayer.Format("断裂划分\\%s-%s", strLayerStart, strLayerEnd);
				strLayer.Format("%s\\%g-%g", destLayer, classStart[i], classEnd[i]);
				CLayer* pLayer = FindFaultLayer(pXy, strLayer);
				//CLayer* pLayer = pXy->FindAddLayer(strLayer);
				CCurveEx* pCurve = (CCurveEx*)pOne->value;
				CCurveEx* pCurveNew = new CCurveEx;
				*pCurveNew = *pCurve;
				POSITION pos = pXy->AddElement(pCurveNew, DOUBLEFOX_CURVE);
				pOne = pXy->GetAt(pos);
				pOne->SetLayer(pLayer);
				break;
			}
		}
	}

	return true;
}

extern "C" __declspec(dllexport)
bool XyCreateFaultDelimit(CXy* pXy,
	LPCTSTR faultLayer, double* classStart, double* classEnd, int classCount)
{
	CString strLayerName(_T("断距"));
	return XyCreateFaultClass(pXy, faultLayer, classStart, classEnd, classCount, 0, strLayerName);
}

extern "C" __declspec(dllexport)
bool XyCreateFaultDelimitByAngle(CXy* pXy,
	LPCTSTR faultLayer, double* classStart, double* classEnd, int classCount)
{
	CString strLayerName(_T("断裂走向"));
	return XyCreateFaultClass(pXy, faultLayer, classStart, classEnd, classCount, 1, strLayerName);
}
extern "C" __declspec(dllexport)
bool XyCreateFaultDelimitByLength(CXy* pXy,
	LPCTSTR faultLayer, double* classStart, double* classEnd, int classCount)
{
	CString strLayerName(_T("断裂长度"));
	return XyCreateFaultClass(pXy, faultLayer, classStart, classEnd, classCount, 2, strLayerName);
}