#include "stdafx.h"
#include "ZDSZDlg.h"
#include "UITools.h"
#include <map>
#include <vector>
#include "zdoutput.h"
#include "KTModelLayoutXData.h"

namespace
{
#define FILE_ _T("\\zdtbsz.dat")

	typedef std::vector<std::pair<CString, CString>> StateVec;

	void split(LPCTSTR pszSrc, TCHAR sp, std::vector<CString> &vec)
	{
		if (!pszSrc) return;

		vec.clear();

		CString src(pszSrc);

		CString oneString(_T(""));
		TCHAR ch;
		for (int i = 0; i < src.GetLength(); ++i)
		{
			ch = src[i];
			if (ch == sp)
			{
				if (oneString.IsEmpty())
					continue;
				else
				{
					vec.push_back(oneString);
					oneString.Empty();
				}
			}
			else
				oneString += ch;
		}
		if (!oneString.IsEmpty())
			vec.push_back(oneString);
	}

	void writeValue(CStdioFile &file, LPCTSTR key, LPCTSTR value)
	{
		file.WriteString(CString(key) + _T("=") + value + _T("\n"));
	}

	void writeValue(CStdioFile &file, LPCTSTR key, const float &value)
	{
		int prec(2);
		writeValue(file, key, TypeConvert::f2s(value, &prec));
	}
}

IMPLEMENT_DYNAMIC(CZDSZDlg, CDialog)

CZDSZDlg::CZDSZDlg(CWnd* pParent /*=NULL*/)
	: CDialog(IDD_ZDSZ_DLG, pParent)
	, m_iWG_GRID_Interval(2)
	, m_fJD_NODE_Scale(1.f)
	, m_iWG_GRID_Prec(1)
	, m_fSJ_HEAD_H(0)
	, m_iDimJoin(1)
	, m_iByStake(1)
	, m_sS2(_T("1:200"))
	, m_fQT_LC_Interval(20)
{

}

CZDSZDlg::~CZDSZDlg()
{
}

void CZDSZDlg::start()
{
	CAcModuleResourceOverride myResources;
	CZDSZDlg dlg;
	dlg.DoModal();
}

void CZDSZDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST1, m_ctrList);

	DDX_Text(pDX, IDC_EDIT1, m_iWG_GRID_Interval);
	DDV_MinMaxInt(pDX, m_iWG_GRID_Interval, 1, 99);

	DDX_Text(pDX, IDC_EDIT3, m_fJD_NODE_Scale);
	DDV_MinMaxFloat(pDX, m_fJD_NODE_Scale, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT4, m_iWG_GRID_Prec);
	DDV_MinMaxInt(pDX, m_iWG_GRID_Prec, 0, 6);

	DDX_Text(pDX, IDC_EDIT5, m_fSJ_HEAD_H);
	DDV_MinMaxFloat(pDX, m_fSJ_HEAD_H, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT7, m_fSJ_HEAD_W);
	DDV_MinMaxFloat(pDX, m_fSJ_HEAD_W, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT8, m_fSJ_DATA_H);
	DDV_MinMaxFloat(pDX, m_fSJ_DATA_H, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT28, m_fSJ_DATA_W);
	DDV_MinMaxFloat(pDX, m_fSJ_DATA_W, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT14, m_fWG_RATIO_H);
	DDV_MinMaxFloat(pDX, m_fWG_RATIO_H, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT16, m_fWG_RATIO_W);
	DDV_MinMaxFloat(pDX, m_fWG_RATIO_W, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT17, m_fWG_GRID_H);
	DDV_MinMaxFloat(pDX, m_fWG_GRID_H, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT40, m_fWG_GRID_W);
	DDV_MinMaxFloat(pDX, m_fWG_GRID_W, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT22, m_fWG_GRID_TEXT_Interval);
	DDV_MinMaxFloat(pDX, m_fWG_GRID_TEXT_Interval, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT21, m_fWG_GRID_WH);
	DDV_MinMaxFloat(pDX, m_fWG_GRID_WH, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT13, m_fWG_ARROW_W);
	DDV_MinMaxFloat(pDX, m_fWG_ARROW_W, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT23, m_fBZ_H);
	DDV_MinMaxFloat(pDX, m_fBZ_H, 0.1f, 99.f);

	DDX_Text(pDX, IDC_EDIT43, m_sGLStartStakeNo);

	DDX_Control(pDX, IDC_COMBO4, m_cmbSJ_HEAD_S);
	DDX_CBString(pDX, IDC_COMBO4, m_sSJ_HEAD_S);

	DDX_Control(pDX, IDC_COMBO7, m_cmbSJ_DATA_S);
	DDX_CBString(pDX, IDC_COMBO7, m_sSJ_DATA_S);

	DDX_Control(pDX, IDC_COMBO5, m_cmbWG_RATIO_S);
	DDX_CBString(pDX, IDC_COMBO5, m_sWG_RATIO_S);

	DDX_Control(pDX, IDC_COMBO8, m_cmbWG_GRID_S);
	DDX_CBString(pDX, IDC_COMBO8, m_sWG_GRID_S);

	DDX_Control(pDX, IDC_COMBO9, m_cmbBZ_S);
	DDX_CBString(pDX, IDC_COMBO9, m_sBZ_S);

	DDX_Check(pDX, IDC_CHECK1, m_iDimJoin);

	DDX_Check(pDX, IDC_CHECK2, m_iByStake);

	DDX_CBString(pDX, IDC_COMBO11, m_sS2);

	DDX_Text(pDX, IDC_EDIT24, m_fQT_LC_Interval);
	DDV_MinMaxFloat(pDX, m_fQT_LC_Interval, .001f, 99999.f);
}


BOOL CZDSZDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	m_ctrList.SetCheckStyle(BS_AUTOCHECKBOX);

	ZD_OUT::readConfiguration();

	ZD_OUT::getConfiguration(m_data);
	refreshCtrlList();

	m_cmbSJ_HEAD_S.init();
	m_cmbSJ_DATA_S.init();
	m_cmbWG_RATIO_S.init();
	m_cmbWG_GRID_S.init();
	m_cmbBZ_S.init();

	m_iWG_GRID_Interval = TypeConvert::s2i(ZD_OUT::getConfiguration(ZD_OUT::KEY_GRID_INTERVAL));
	m_iWG_GRID_Prec = TypeConvert::s2i(ZD_OUT::getConfiguration(ZD_OUT::KEY_GRID_PREC));
	m_fJD_NODE_Scale = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_NODE_SCALE));

	m_fSJ_HEAD_H = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_HEAD_H));
	m_sSJ_HEAD_S = ZD_OUT::getConfiguration(ZD_OUT::KEY_HEAD_S);
	m_fSJ_HEAD_W = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_HEAD_W));

	m_fSJ_DATA_H = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_DATA_H));
	m_sSJ_DATA_S = ZD_OUT::getConfiguration(ZD_OUT::KEY_DATA_S);
	m_fSJ_DATA_W = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_DATA_W));
	m_sGLStartStakeNo = ZD_OUT::getConfiguration(ZD_OUT::KEY_DATA_GL_STAKENO);

	m_fWG_RATIO_H = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_RATIO_H));
	m_sWG_RATIO_S = ZD_OUT::getConfiguration(ZD_OUT::KEY_RATIO_S);
	m_fWG_RATIO_W = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_RATIO_W));

	m_fWG_GRID_H = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_GRID_H));
	m_sWG_GRID_S = ZD_OUT::getConfiguration(ZD_OUT::KEY_GRID_S);
	m_fWG_GRID_W = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_GRID_W));

	m_fWG_ARROW_W = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_ARROW_W));
	m_fWG_GRID_WH = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_GRID_WH));
	m_fWG_GRID_TEXT_Interval = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_GRID_TEXT_INTERVAL));

	m_fBZ_H = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_YCBZ_H));
	m_sBZ_S = ZD_OUT::getConfiguration(ZD_OUT::KEY_YCBZ_S);

	m_iDimJoin = TypeConvert::s2i(ZD_OUT::getConfiguration(ZD_OUT::KEY_BXFBZ_S));
	m_iByStake = TypeConvert::s2i(ZD_OUT::getConfiguration(ZD_OUT::KEY_NODE_DIMTYPE));

	m_fQT_LC_Interval = TypeConvert::s2f(ZD_OUT::getConfiguration(ZD_OUT::KEY_QTSZ_LCJG));

	AecDbObjXDataMap xDataMap;
	xDataMap.SetAt(_T("S2"), _T("1:200"));
	KTModelLayoutXData::ReadModelXData(EW_EARTHWORMINIT, xDataMap);
	xDataMap.GetAt(_T("S2"), m_sS2);

	UpdateData(FALSE);
	return TRUE;
}

void CZDSZDlg::refreshCtrlList()
{
	// [0-9) 个数据为“纵断数据”数据
	int countOfHead = sizeof(ZD_OUT::g_TableHead) / sizeof(LPCTSTR);
	if (m_data.size() < countOfHead - 1) return;
	m_ctrList.ResetContent();
	for (size_t i = 0; i < countOfHead; ++i)
	{
		m_ctrList.AddString(m_data[i].first);
		m_ctrList.SetCheck(i,(m_data[i].second.CompareNoCase(_T("0")) == 0) ? false : true);
	}
}

BEGIN_MESSAGE_MAP(CZDSZDlg, CDialog)
	ON_BN_CLICKED(IDC_BUTTON1, &CZDSZDlg::OnBnClickedButton1)
	ON_BN_CLICKED(IDC_BUTTON4, &CZDSZDlg::OnBnClickedButton4)
	ON_BN_CLICKED(IDOK, &CZDSZDlg::OnBnClickedOk)
	ON_CLBN_CHKCHANGE(IDC_LIST1, &CZDSZDlg::OnCheckchangeList)
END_MESSAGE_MAP()

void CZDSZDlg::OnBnClickedButton1()
{
	int idx = m_ctrList.GetCurSel();
	if (idx >= m_data.size()) return;
	if (idx - 1 < 0) return;


	std::pair<CString, CString> pr = m_data[idx];
	StateVec::iterator itOld(m_data.begin()), itNew(m_data.begin());
	std::advance(itOld, idx);
	std::advance(itNew, idx - 1);

	m_data.erase(itOld);
	m_data.insert(itNew, pr);

	refreshCtrlList();
	m_ctrList.SetCurSel(idx - 1);
}


void CZDSZDlg::OnBnClickedButton4()
{
	int idx = m_ctrList.GetCurSel();
	if (idx >= m_data.size()) return;
	if (idx + 1 >= m_data.size()) return;

	std::pair<CString, CString> pr = m_data[idx];
	StateVec::iterator itOld(m_data.begin()), itNew(m_data.begin());
	std::advance(itOld, idx);
	std::advance(itNew, idx + 1);

	m_data.erase(itOld);
	m_data.insert(itNew, pr);

	refreshCtrlList();

	m_ctrList.SetCurSel(idx + 1);
}


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

	double dDist(.0);
	if (!StakeTools::analyStakeString(m_sGLStartStakeNo, dDist))
	{
		AfxMessageBox(_T("%s 不符合标准（例：K0+123），请重新输入！"));
		return;
	}

	CString str(_T(""));
	CStdioFile file(FilePath::getProgramDataFolder() + FILE_, CFile::modeCreate|CFile::modeReadWrite);
	if (!file.m_hFile) return;

	file.WriteString(CString(ZD_OUT::SECTION_ZDSJ) + _T("\n"));

	for (int i = 0; i < m_ctrList.GetCount(); ++i)
	{
		m_ctrList.GetText(i, str);
		str += _T("=");
		str += m_ctrList.GetCheck(i) == 1 ? _T("1") : _T("0");
		str += _T("\n");
		file.WriteString(str);
	}

	writeValue(file, ZD_OUT::KEY_HEAD_H, m_fSJ_HEAD_H);
	writeValue(file, ZD_OUT::KEY_HEAD_S, m_sSJ_HEAD_S);
	writeValue(file, ZD_OUT::KEY_HEAD_W, m_fSJ_HEAD_W);

	writeValue(file, ZD_OUT::KEY_DATA_H, m_fSJ_DATA_H);
	writeValue(file, ZD_OUT::KEY_DATA_S, m_sSJ_DATA_S);
	writeValue(file, ZD_OUT::KEY_DATA_W, m_fSJ_DATA_W);

	writeValue(file, ZD_OUT::KEY_DATA_GL_STAKENO, m_sGLStartStakeNo);

	file.WriteString(CString(ZD_OUT::SECTION_ZDWG) + _T("\n"));
	writeValue(file, ZD_OUT::KEY_GRID_INTERVAL, m_iWG_GRID_Interval);
	writeValue(file, ZD_OUT::KEY_GRID_PREC, m_iWG_GRID_Prec);
	writeValue(file, ZD_OUT::KEY_RATIO_H, m_fWG_RATIO_H);
	writeValue(file, ZD_OUT::KEY_RATIO_S, m_sWG_RATIO_S);
	writeValue(file, ZD_OUT::KEY_RATIO_W, m_fWG_RATIO_W);
	writeValue(file, ZD_OUT::KEY_GRID_H, m_fWG_GRID_H);
	writeValue(file, ZD_OUT::KEY_GRID_S, m_sWG_GRID_S);
	writeValue(file, ZD_OUT::KEY_GRID_W, m_fWG_GRID_W);
	writeValue(file, ZD_OUT::KEY_ARROW_W, m_fWG_ARROW_W);
	writeValue(file, ZD_OUT::KEY_GRID_WH, m_fWG_GRID_WH);
	writeValue(file, ZD_OUT::KEY_GRID_TEXT_INTERVAL, m_fWG_GRID_TEXT_Interval);

	file.WriteString(CString(ZD_OUT::SECTION_ZDJD) + _T("\n"));
	writeValue(file, ZD_OUT::KEY_NODE_SCALE, m_fJD_NODE_Scale);
	writeValue(file, ZD_OUT::KEY_BXFBZ_S, m_iDimJoin);
	writeValue(file, ZD_OUT::KEY_NODE_DIMTYPE, m_iByStake);

	file.WriteString(CString(ZD_OUT::SECTION_YCBZ) + _T("\n"));
	writeValue(file, ZD_OUT::KEY_YCBZ_H, m_fBZ_H);
	writeValue(file, ZD_OUT::KEY_YCBZ_S, m_sBZ_S);

	file.WriteString(CString(ZD_OUT::SECTION_QTSZ) + _T("\n"));
	writeValue(file, ZD_OUT::KEY_QTSZ_LCJG, m_fQT_LC_Interval);

	file.Close();

	ZD_OUT::readConfiguration();


	AecDbObjXDataMap xDataMap;
	KTModelLayoutXData::ReadModelXData(EW_EARTHWORMINIT, xDataMap);
	xDataMap.SetAt(_T("S2"), m_sS2);
	KTModelLayoutXData::WriteModelXData(EW_EARTHWORMINIT, xDataMap);

	CDialog::OnOK();
}

void CZDSZDlg::OnCheckchangeList()
{
	int idx = m_ctrList.GetCurSel();
	if (idx >= m_data.size()) return;

	std::pair<CString, CString> &pr = m_data[idx];
	if (pr.second.Compare(_T("0")) == 0)
		pr.second = _T("1");
	else
		pr.second = _T("0");

	return;
}