// AxisSettingsDlg.cpp: 实现文件
//

#include "stdafx.h"
#include "BondEq.h"
#include "afxdialogex.h"
#include "AxisSettingsDlg.h"
#include "ToolUnits.h"
#include <cctype>
#include <algorithm>

#define TIMER_INIT				1
#define TIMER_READ_PLC_DATA		2
#define TIMER_JOG_ADD           3
#define TIMER_JOG_SUB           4

// CAxisSettingsDlg 对话框

IMPLEMENT_DYNAMIC(CAxisSettingsDlg, CDialogEx)

CAxisSettingsDlg::CAxisSettingsDlg(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_DIALOG_AXIS_SETTINGS, pParent)
{
	m_nInitialWidth = 0;
	m_nInitialHeight = 0;
	m_pPLC = nullptr;
}

CAxisSettingsDlg::~CAxisSettingsDlg()
{
	for (auto& pair : m_mapFonts) {
		if (pair.second) {
			pair.second->DeleteObject();
			delete pair.second;
		}
	}
	m_mapFonts.clear();
}

void CAxisSettingsDlg::SetPLC(CPLC* pPLC)
{
	ASSERT(pPLC);
	m_pPLC = pPLC;
}

void CAxisSettingsDlg::SetRecipeName(const CString& strRecipeName)
{
	m_strRecipeName = strRecipeName;
}

void CAxisSettingsDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_STATIC_AXIS_TEST_FLS, m_staticFLS);
	DDX_Control(pDX, IDC_STATIC_AXIS_TEST_DOG, m_staticDOG);
	DDX_Control(pDX, IDC_STATIC_AXIS_TEST_RLS, m_staticRLS);
	DDX_Control(pDX, IDC_STATIC_AXIS_TEST_READY, m_staticReady);
	DDX_Control(pDX, IDC_STATIC_AXIS_TEST_BUSY, m_staticBusy);
	DDX_Control(pDX, IDC_STATIC_AXIS_TEST_ERR, m_staticErr);
	DDX_Control(pDX, IDC_COMBO_AXIS_NAME, m_comboAxisNO);
	DDX_Control(pDX, IDC_STATIC_AXIS_NUMBER, m_staticAxisNO);
	DDX_Control(pDX, IDC_STATIC_AXIS_DESCRIP, m_staticAxisDescription);
	DDX_Control(pDX, IDC_STATIC_START_ADDRESS, m_staticStartAddress);
	DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_POS, m_editManualSpeed);
	DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_AUTO_SPEED, m_editAutoSpeed);
	DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_ACCE_TIME, m_editAccelerationTime);
	DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_DECE_TIME, m_editDecelerationTime);
	DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_MICROMENTUM, m_editJogDistance);
	DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP1, m_pageButtons[0]);
	DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP2, m_pageButtons[1]);
	DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP3, m_pageButtons[2]);
	DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP4, m_pageButtons[3]);
	DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP5, m_pageButtons[4]);
}

UINT CAxisSettingsDlg::FindIDByName(const CString& strControlID)
{
	// 将资源文件中定义的控件名称和 ID 加载到一个映射中
	static const std::map<CString, UINT> controlIdMap = {
		{"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP1", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP1},
		{"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP2", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP2},
		{"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP3", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP3},
		{"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP4", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP4},
		{"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP5", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP5},
		{"IDC_EDIT_AXIS_ANCHOR_POINT1", IDC_EDIT_AXIS_ANCHOR_POINT1},
		{"IDC_EDIT_AXIS_ANCHOR_POINT2", IDC_EDIT_AXIS_ANCHOR_POINT2},
		{"IDC_EDIT_AXIS_ANCHOR_POINT3", IDC_EDIT_AXIS_ANCHOR_POINT3},
		{"IDC_EDIT_AXIS_ANCHOR_POINT4", IDC_EDIT_AXIS_ANCHOR_POINT4},
		{"IDC_EDIT_AXIS_ANCHOR_POINT5", IDC_EDIT_AXIS_ANCHOR_POINT5}
		// 可以继续添加其他控件名称和 ID
	};

	// 查找控件名称是否在映射中
	auto it = controlIdMap.find(strControlID);
	if (it != controlIdMap.end()) {
		return it->second;
	}

	return 0;
}

CFont* CAxisSettingsDlg::GetOrCreateFont(int nFontSize)
{
	auto it = m_mapFonts.find(nFontSize);
	if (it != m_mapFonts.end()) {
		return it->second;
	}

	CFont* font = new CFont();
	LOGFONT logFont = { 0 };
	_tcscpy_s(logFont.lfFaceName, _T("Segoe UI"));
	logFont.lfHeight = -nFontSize;
	logFont.lfQuality = CLEARTYPE_QUALITY;
	font->CreateFontIndirect(&logFont);
	m_mapFonts[nFontSize] = font;

	return font;
}

void CAxisSettingsDlg::SetDefaultFont()
{
	CFont* defaultFont = GetOrCreateFont(12);

	// 遍历所有控件，应用默认字体
	CWnd* pWnd = GetWindow(GW_CHILD);
	while (pWnd) {
		pWnd->SetFont(defaultFont, TRUE);
		pWnd = pWnd->GetNextWindow();
	}
}

void CAxisSettingsDlg::AdjustControls(float dScaleX, float dScaleY)
{
	CWnd* pWnd = GetWindow(GW_CHILD);
	while (pWnd) {
		int nCtrlID = pWnd->GetDlgCtrlID();
		if (nCtrlID != -1 && m_mapCtrlLayouts.find(nCtrlID) != m_mapCtrlLayouts.end())
		{
			CRect originalRect = m_mapCtrlLayouts[nCtrlID];
			CRect newRect(
				static_cast<int>(originalRect.left * dScaleX),
				static_cast<int>(originalRect.top * dScaleY),
				static_cast<int>(originalRect.right * dScaleX),
				static_cast<int>(originalRect.bottom * dScaleY));

			TCHAR szClassName[256];
			GetClassName(pWnd->m_hWnd, szClassName, sizeof(szClassName));

			if (_tcsicmp(szClassName, _T("ComboBox")) == 0) {
				CComboBox* pComboBox = (CComboBox*)pWnd;
				pComboBox->SetItemHeight(-1, newRect.Height());  // -1 表示所有项的高度
			}

			pWnd->MoveWindow(&newRect);
			AdjustControlFont(pWnd, newRect.Width(), newRect.Height());
		}
		pWnd = pWnd->GetNextWindow();
	}
}

void CAxisSettingsDlg::AdjustControlFont(CWnd* pWnd, int nWidth, int nHeight)
{
	// 根据控件高度动态调整字体大小
	int fontSize = nHeight / 2;
	if (fontSize < 8) fontSize = 8;
	if (fontSize > 24) fontSize = 24;  // 最大字体大小

	// 获取或创建字体
	CFont* pFont = GetOrCreateFont(fontSize);

	pWnd->SetFont(pFont);
	pWnd->Invalidate(); // 刷新控件显示
}

void CAxisSettingsDlg::AdjustLabelFont(CBLLabel& label)
{
	// 获取控件的矩形区域
	CRect rect;
	label.GetClientRect(&rect);

	// 动态计算字体大小，基于控件的高度
	int fontSize = rect.Height() / 2; // 控件高度的一半作为字体大小
	if (fontSize < 8) fontSize = 8;   // 最小字体大小
	if (fontSize > 30) fontSize = 30; // 最大字体大小

	// 设置字体大小
	label.SetFontSize(fontSize);

	// 刷新控件显示
	label.Invalidate();
	label.UpdateWindow();
}

void CAxisSettingsDlg::SetStatusColor(CBLLabel& label, BOOL bStatus)
{
	if (bStatus) {
		label.SetBkColor(RGB(0, 255, 0)); // 绿色
	}
	else {
		label.SetBkColor(RGB(255, 0, 0)); // 红色
	}

	label.Invalidate();              // 标记区域无效
	label.UpdateWindow();            // 立即刷新
}

void CAxisSettingsDlg::updatePageButtonStates()
{
	for (int i = 0; i < 5; ++i) {
		if (i + 1 == m_currentPage) {
			m_pageButtons[i].SetFaceColor(RGB(0, 122, 204));	// 选中背景色（蓝色）
		}
		else {
			m_pageButtons[i].SetFaceColor(RGB(240, 240, 240));	// 默认背景色
		}

		m_pageButtons[i].Invalidate();
	}
}

int CAxisSettingsDlg::getCurrentSelectedAxisID()
{
	int currentIndex = m_comboAxisNO.GetCurSel();
	if (currentIndex == CB_ERR) {
		return -1;
	}

	CString strAxisIDStr;
	m_comboAxisNO.GetLBText(currentIndex, strAxisIDStr);
	return _ttoi(strAxisIDStr);
}

void CAxisSettingsDlg::initializeAxisIDCombo()
{
	// 检查配方是否加载成功
	RecipeManager& recipeManager = RecipeManager::getInstance();
	if (m_strRecipeName.IsEmpty() || !recipeManager.loadRecipe(std::string(CT2A(m_strRecipeName)))) {
		AfxMessageBox(_T("加载配方失败！"));
		return;
	}

	// 获取所有轴的编号
	auto axisNumbers = recipeManager.getAllAxisID();

	// 清空下拉框
	m_comboAxisNO.ResetContent();

	// 填充数据到下拉框
	for (const auto& axisID : axisNumbers) {
		CString axisCString;
		axisCString.Format(_T("%d"), axisID);
		m_comboAxisNO.AddString(axisCString);
	}

	// 默认选择第一项
	if (m_comboAxisNO.GetCount() > 0) {
		m_comboAxisNO.SetCurSel(0);
	}
}

void CAxisSettingsDlg::refreshAxisDetails(int nAxisId)
{
	// 获取轴数据
	RecipeManager& recipeManager = RecipeManager::getInstance();
	auto axisDetails = recipeManager.getAxis(nAxisId);

	auto formatDouble = [](double value) -> CString {
		CString str;
		str.Format(_T("%.3f"), value);
		return str;
	};

	// 更新控件显示
	m_staticAxisNO.SetWindowText(CString(axisDetails.number.c_str()));					// 轴编号
	m_staticAxisDescription.SetWindowText(CString(axisDetails.description.c_str()));	// 轴描述
	m_staticStartAddress.SetWindowText(CString(axisDetails.startAddress.c_str()));		// 起始地址
	m_editJogDistance.SetWindowText(formatDouble(axisDetails.jogDistance));				// 微动量
	m_editManualSpeed.SetWindowText(formatDouble(axisDetails.manualSpeed));				// 手动速度
	m_editAutoSpeed.SetWindowText(formatDouble(axisDetails.autoSpeed));					// 自动速度
	m_editAccelerationTime.SetWindowText(formatDouble(axisDetails.accelerationTime));	// 加速时间
	m_editDecelerationTime.SetWindowText(formatDouble(axisDetails.decelerationTime));	// 减速时间
}

void CAxisSettingsDlg::refreshPositionDetails(int nAxisId, int pageNumber)
{
	RecipeManager& recipeManager = RecipeManager::getInstance();
	// 每页显示的定位点数量
	const int pageSize = 5;

	// 获取定位点数据
	auto positions = recipeManager.getPositions(nAxisId, pageNumber, pageSize);

	// 刷新 UI
	for (int i = 0; i < pageSize; ++i) {
		CString descriptionCtrlName, positionCtrlName;
		descriptionCtrlName.Format(_T("IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP%d"), i + 1);
		positionCtrlName.Format(_T("IDC_EDIT_AXIS_ANCHOR_POINT%d"), i + 1);

		UINT descriptionCtrlId = FindIDByName(descriptionCtrlName);
		UINT positionCtrlId = FindIDByName(positionCtrlName);

		CWnd* pDescriptionCtrl = GetDlgItem(descriptionCtrlId);
		CWnd* pPositionCtrl = GetDlgItem(positionCtrlId);

		if (i < positions.size()) {
			CString description = CString(positions[i].first.c_str());
			CString value;
			value.Format(_T("%.3f"), positions[i].second);

			if (pDescriptionCtrl) pDescriptionCtrl->SetWindowText(description);
			if (pPositionCtrl) pPositionCtrl->SetWindowText(value);
		}
		else {
			if (pDescriptionCtrl) pDescriptionCtrl->SetWindowText(_T(""));
			if (pPositionCtrl) pPositionCtrl->SetWindowText(_T(""));
		}
	}
}

void CAxisSettingsDlg::updateAxisSelection(int offset)
{
	int currentIndex = m_comboAxisNO.GetCurSel();
	if (currentIndex == CB_ERR) {
		AfxMessageBox(_T("请选择一个有效的轴编号！"));
		return;
	}

	int newIndex = currentIndex + offset;
	if (newIndex < 0 || newIndex >= m_comboAxisNO.GetCount()) {
		CString error;
		error.Format(_T("已经到达%s一个轴！"), offset < 0 ? _T("上") : _T("下"));
		AfxMessageBox(error);
		return;
	}

	m_comboAxisNO.SetCurSel(newIndex);
	refreshAxisDetails(newIndex + 1);
	refreshPositionDetails(newIndex + 1, m_currentPage);
	updatePageButtonStates();
}

void CAxisSettingsDlg::updateDataFromUI(int nAxisId)
{
	const int pageSize = 5; // 每页显示 5 个定位点

	RecipeManager& recipeManager = RecipeManager::getInstance();
	auto axisData = recipeManager.getAxis(nAxisId);

	// 获取界面上的修改参数
	CString text;
	m_editManualSpeed.GetWindowText(text);
	axisData.manualSpeed = _ttof(text);

	m_editAutoSpeed.GetWindowText(text);
	axisData.autoSpeed = _ttof(text);

	m_editAccelerationTime.GetWindowText(text);
	axisData.accelerationTime = _ttof(text);

	m_editDecelerationTime.GetWindowText(text);
	axisData.decelerationTime = _ttof(text);

	m_editJogDistance.GetWindowText(text);
	axisData.jogDistance = _ttof(text);

	// 更新定位点数据
	for (int i = 0; i < pageSize; ++i) {
		int index = (m_currentPage - 1) * pageSize + i;

		if (index < axisData.positions.size()) {
			CString descriptionName, positionName;
			descriptionName.Format(_T("IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP%d"), i + 1);
			positionName.Format(_T("IDC_EDIT_AXIS_ANCHOR_POINT%d"), i + 1);

			CEdit* pDescriptionEdit = (CEdit*)GetDlgItem(FindIDByName(descriptionName));
			CEdit* pPositionEdit = (CEdit*)GetDlgItem(FindIDByName(positionName));

			if (pDescriptionEdit && pPositionEdit) {
				CString description, positionValue;
				pDescriptionEdit->GetWindowText(description);
				pPositionEdit->GetWindowText(positionValue);

				// 更新 RecipeManager 中的数据
				axisData.positions[index].first = CT2A(description);
				axisData.positions[index].second = _ttof(positionValue);
			}
		}
	}

	// 保存回 RecipeManager
	recipeManager.updateAxis(axisData);
}

void CAxisSettingsDlg::switchToPage(int targetPage)
{
	try {
		// 如果当前页面已经是目标页面，直接返回
		if (m_currentPage == targetPage) {
			return;
		}

		// 获取当前选中的轴 ID
		int axisId = getCurrentSelectedAxisID();
		if (axisId == -1) {
			AfxMessageBox(_T("请选择一个有效的轴编号！"));
			return;
		}

		// 更新 UI 数据到内存
		updateDataFromUI(axisId);

		// 切换页面
		m_currentPage = targetPage;
		refreshPositionDetails(axisId, targetPage);
		updatePageButtonStates();
	}
	catch (const std::exception& ex) {
		CString errorMsg;
		errorMsg.Format(_T("刷新定位组%d失败：%s"), targetPage, CString(ex.what()));
		AfxMessageBox(errorMsg, MB_ICONERROR);
	}
}

void CAxisSettingsDlg::writeAxisDataToPLC(int nAxisId)
{
	// 从 RecipeManager 获取轴数据
	RecipeManager& recipeManager = RecipeManager::getInstance();
	auto axisData = recipeManager.getAxis(nAxisId);

	// 去除非数字字符并转换起始地址
	std::string cleanAddress = axisData.startAddress;
	cleanAddress.erase(std::remove_if(cleanAddress.begin(), cleanAddress.end(),
		[](char c) { return !std::isdigit(c); }), cleanAddress.end());
	if (cleanAddress.empty()) {
		AfxMessageBox(_T("无效的起始地址！"));
		return;
	}
	int startAddress = std::stoi(cleanAddress);

	// 写入手动速度
	m_pPLC->writeWord(MC::SOFT_COMPONENT::D, 5120, (int)axisData.manualSpeed, [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
		if (flag == 0) {
			TRACE("\n写入成功: 手动速度, 地址: %d, 值: %lu\n", addr, value);
		}
		else {
			TRACE("\n写入失败: 手动速度, 地址: %d, 错误码: %d\n", addr, flag);
		}
	});

	// 写入自动速度
	m_pPLC->writeWord(MC::SOFT_COMPONENT::D, startAddress + 2, (int)axisData.autoSpeed, [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
		if (flag == 0) {
			TRACE("\n写入成功: 自动速度, 地址: %d, 值: %lu\n", addr, value);
		}
		else {
			TRACE("\n写入失败: 自动速度, 地址: %d, 错误码: %d\n", addr, flag);
		}
	});

	// 写入加速时间, 转换为毫秒
	m_pPLC->writeWord(MC::SOFT_COMPONENT::D, startAddress + 4, (int)(axisData.accelerationTime * 1000), [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
		if (flag == 0) {
			TRACE("\n写入成功: 加速时间, 地址: %d, 值: %lu\n", addr, value);
		}
		else {
			TRACE("\n写入失败: 加速时间, 地址: %d, 错误码: %d\n", addr, flag);
		}
	});

	// 写入减速时间, 转换为毫秒
	m_pPLC->writeWord(MC::SOFT_COMPONENT::D, startAddress + 6, (int)(axisData.decelerationTime * 1000), [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
		if (flag == 0) {
			TRACE("\n写入成功: 减速时间, 地址: %d, 值: %lu\n", addr, value);
		}
		else {
			TRACE("\n写入失败: 减速时间, 地址: %d, 错误码: %d\n", addr, flag);
		}
	});

	// 写入微动量
	m_pPLC->writeWord(MC::SOFT_COMPONENT::D, startAddress + 8, (int)axisData.jogDistance, [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
		if (flag == 0) {
			TRACE("\n写入成功: 微动量, 地址: %d, 值: %lu\n", addr, value);
		}
		else {
			TRACE("\n写入失败: 微动量, 地址: %d, 错误码: %d\n", addr, flag);
		}
	});

	// 写入定位点数据
	int positionStartAddress = startAddress + 10;
	for (size_t i = 0; i < axisData.positions.size(); ++i) {
		const auto& position = axisData.positions[i];
		int positionAddress = positionStartAddress + (i * 2);

		m_pPLC->writeWord(MC::SOFT_COMPONENT::D, positionAddress, (int)position.second, [i](IMcChannel* pChannel, int addr, DWORD value, int flag) {
			if (flag == 0) {
				TRACE("\n写入成功: 定位点 %d, 地址: %d, 值: %lu\n", i + 1, addr, value);
			}
			else {
				TRACE("\n写入失败: 定位点 %d, 地址: %d, 错误码: %d\n", i + 1, addr, flag);
			}
		});
	}
}

void CAxisSettingsDlg::handleAxisOperation(AxisOperationType eOpType, bool bPressed)
{
	int nAxisId = getCurrentSelectedAxisID();
	if (nAxisId == -1) {
		AfxMessageBox(_T("未选择有效的轴编号！"));
		return;
	}

	// 获取轴数据
	RecipeManager& recipeManager = RecipeManager::getInstance();
	auto axisData = recipeManager.getAxis(nAxisId);

	std::string strCleanAddress = axisData.startAddress;
	strCleanAddress.erase(std::remove_if(strCleanAddress.begin(), strCleanAddress.end(),
		[](unsigned char c) { return !std::isdigit(c); }), strCleanAddress.end());
	if (strCleanAddress.empty()) {
		AfxMessageBox(_T("无效的起始地址！"));
		return;
	}

	int nStartAddress = std::stoi(strCleanAddress);

	// 根据操作类型计算目标地址
	int nTargetAddress = nStartAddress;
	switch (eOpType) {
	case AxisOperationType::OPR:
		nTargetAddress += 10; // OPR 信号地址
		break;
	case AxisOperationType::JOG_ADD:
		nTargetAddress += 12; // JOG+ 信号地址
		break;
	case AxisOperationType::JOG_SUB:
		nTargetAddress += 13; // JOG- 信号地址
		break;
	case AxisOperationType::STOP:
		nTargetAddress += 14; // STOP 信号地址
		break;
	case AxisOperationType::POSITION_1:
		nTargetAddress += 16; // 定位点 1 信号地址
		break;
	case AxisOperationType::POSITION_2:
		nTargetAddress += 18; // 定位点 2 信号地址
		break;
	case AxisOperationType::POSITION_3:
		nTargetAddress += 20; // 定位点 3 信号地址
		break;
	case AxisOperationType::POSITION_4:
		nTargetAddress += 22; // 定位点 4 信号地址
		break;
	case AxisOperationType::POSITION_5:
		nTargetAddress += 24; // 定位点 5 信号地址
		break;
	default:
		AfxMessageBox(_T("未知操作类型！"));
		return;
	}

	// 向 PLC 写入信号
	m_pPLC->writeBit(MC::SOFT_COMPONENT::D, nTargetAddress, bPressed, [eOpType, nTargetAddress, bPressed](IMcChannel* pChannel, int nAddr, DWORD nValue, int nFlag) {
		if (nFlag == 0) {
			TRACE("操作成功：类型=%d，地址=%d，值=%d\n", static_cast<int>(eOpType), nAddr, bPressed);
		}
		else {
			TRACE("操作失败：类型=%d，地址=%d，错误码=%d\n", static_cast<int>(eOpType), nAddr, nFlag);
		}
	});
}


BEGIN_MESSAGE_MAP(CAxisSettingsDlg, CDialogEx)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_LAST, &CAxisSettingsDlg::OnBnClickedButtonAxisLast)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_NEXT, &CAxisSettingsDlg::OnBnClickedButtonAxisNext)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP1, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup1)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP2, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup2)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP3, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup3)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP4, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup4)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP5, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup5)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT1, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint1)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT2, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint2)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT3, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint3)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT4, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint4)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT5, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint5)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_TEST_OPR, &CAxisSettingsDlg::OnBnClickedButtonAxisTestOpr)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_TEST_STOP, &CAxisSettingsDlg::OnBnClickedButtonAxisTestStop)
	ON_CBN_SELCHANGE(IDC_COMBO_AXIS_NAME, &CAxisSettingsDlg::OnSelchangeComboAxisName)
	ON_BN_CLICKED(IDC_BUTTON_AXIS_SAVE, &CAxisSettingsDlg::OnBnClickedButtonAxisSave)
	ON_WM_SIZE()
	ON_WM_CTLCOLOR()
	ON_WM_SIZING()
	ON_WM_TIMER()
END_MESSAGE_MAP()


// CAxisSettingsDlg 消息处理程序


BOOL CAxisSettingsDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// TODO:  在此添加额外的初始化
	CString strTitle;
	strTitle.Format(_T("Axis设定(配方: %s)"), m_strRecipeName);
	SetWindowText(strTitle);

	// 设置测试状态
	CBLLabel* pLabels[] = { &m_staticFLS, &m_staticDOG, &m_staticRLS, &m_staticReady, &m_staticBusy, &m_staticErr };
	for (auto pLabel : pLabels) {
		SetStatusColor(*pLabel, FALSE);
		pLabel->ModifyStyle(0, SS_NOTIFY);
		pLabel->SetTextColor(RGB(255, 255, 255));
		pLabel->SetAlignment(AlignCenter);
		pLabel->SetDynamicFont(TRUE);
	}

	// 初始化当前页面为第一页
	m_currentPage = 1;
	updatePageButtonStates();

	initializeAxisIDCombo();
	refreshAxisDetails(1);
	refreshPositionDetails(1, m_currentPage);

	CRect screenRect, dlgRect, clientRect;
	GetClientRect(&clientRect);
	m_nInitialWidth = clientRect.Width();
	m_nInitialHeight = clientRect.Height();

	// 初始化默认字体
	CFont* pDefaultFont = GetOrCreateFont(12);

	// 遍历所有子控件，记录初始位置并设置默认字体
	CWnd* pWnd = GetWindow(GW_CHILD);
	while (pWnd) {
		int nCtrlID = pWnd->GetDlgCtrlID();
		if (nCtrlID != -1) {
			// 记录控件初始布局
			CRect ctrlRect;
			pWnd->GetWindowRect(&ctrlRect);
			ScreenToClient(&ctrlRect);
			m_mapCtrlLayouts[nCtrlID] = ctrlRect;

			// 设置默认字体
			pWnd->SetFont(pDefaultFont);
		}
		pWnd = pWnd->GetNextWindow();
	}

	GetWindowRect(&dlgRect);
	int dlgWidth = dlgRect.Width() * 2;
	int dlgHeight = dlgRect.Height() * 2;

	SystemParametersInfo(SPI_GETWORKAREA, 0, &screenRect, 0);
	if (dlgWidth > screenRect.Width()) {
		dlgWidth = screenRect.Width();
	}
	if (dlgHeight > screenRect.Height()) {
		dlgHeight = screenRect.Height();
	}

	int centerX = screenRect.left + (screenRect.Width() - dlgWidth) / 2;
	int centerY = screenRect.top + (screenRect.Height() - dlgHeight) / 2;
	MoveWindow(centerX, centerY, dlgWidth, dlgHeight);
	
	SetTimer(TIMER_READ_PLC_DATA, 500, nullptr);

	return TRUE;  // return TRUE unless you set the focus to a control
	// 异常: OCX 属性页应返回 FALSE
}

BOOL CAxisSettingsDlg::PreTranslateMessage(MSG* pMsg)
{
	// TODO: 在此添加专用代码和/或调用基类

	if (pMsg->message == WM_LBUTTONDOWN)
	{
		if (pMsg->hwnd == GetDlgItem(IDC_BUTTON_AXIS_TEST_JOG_ADD)->m_hWnd)
		{
			TRACE("JOG+ 按钮按下\n");
			m_bJogAddPressed = TRUE;

			// 启动定时器连续发送信号
			SetTimer(TIMER_JOG_ADD, 200, nullptr);
			handleAxisOperation(AxisOperationType::JOG_ADD, true);
		}
		else if (pMsg->hwnd == GetDlgItem(IDC_BUTTON_AXIS_TEST_JOG_SUB)->m_hWnd)
		{
			TRACE("JOG- 按钮按下\n");
			m_bJogSubPressed = TRUE;

			// 启动定时器连续发送信号
			SetTimer(TIMER_JOG_SUB, 200, nullptr);
			handleAxisOperation(AxisOperationType::JOG_SUB, true);
		}
	}
	else if (pMsg->message == WM_LBUTTONUP)
	{
		if (pMsg->hwnd == GetDlgItem(IDC_BUTTON_AXIS_TEST_JOG_ADD)->m_hWnd)
		{
			TRACE("JOG+ 按钮松开\n");
			m_bJogAddPressed = FALSE;

			// 停止定时器
			KillTimer(TIMER_JOG_ADD);
			handleAxisOperation(AxisOperationType::JOG_ADD, false);
		}
		else if (pMsg->hwnd == GetDlgItem(IDC_BUTTON_AXIS_TEST_JOG_SUB)->m_hWnd)
		{
			TRACE("JOG- 按钮松开\n");
			m_bJogSubPressed = FALSE;

			// 停止定时器
			KillTimer(TIMER_JOG_SUB);
			handleAxisOperation(AxisOperationType::JOG_SUB, false);
		}
	}

	return CDialogEx::PreTranslateMessage(pMsg);
}

void CAxisSettingsDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialogEx::OnSize(nType, cx, cy);

	// TODO: 在此处添加消息处理程序代码
	if (nType == SIZE_MINIMIZED || m_mapCtrlLayouts.empty()) {
		return;
	}

	float dScaleX = static_cast<float>(cx) / m_nInitialWidth;
	float dScaleY = static_cast<float>(cy) / m_nInitialHeight;

	// 遍历对话框中的所有控件
	AdjustControls(dScaleX, dScaleY);

	// 动态调整各个 CBLLabel 的字体大小
	CBLLabel* pLabels[] = { &m_staticFLS, &m_staticDOG, &m_staticRLS, &m_staticReady, &m_staticBusy, &m_staticErr };
	for (auto pLabel : pLabels) {
		AdjustLabelFont(*pLabel);
	}

	// 调整下拉框高度
	CComboBox* pComboBox = (CComboBox*)GetDlgItem(IDC_COMBO_AXIS_NAME);
	CButton* pButtonLeft = (CButton*)GetDlgItem(IDC_BUTTON_AXIS_LAST);
	CButton* pButtonRight = (CButton*)GetDlgItem(IDC_BUTTON_AXIS_NEXT);

	if (pComboBox && pButtonLeft && pButtonRight) {
		CRect rectButton;
		pButtonLeft->GetWindowRect(&rectButton);	// 获取按钮尺寸
		ScreenToClient(&rectButton);				// 转换为客户端坐标

		CRect rectComboBox;
		pComboBox->GetWindowRect(&rectComboBox);
		ScreenToClient(&rectComboBox);

		// 调整下拉框高度
		int heightAdjustment = 2;
		rectComboBox.top = rectButton.top;
		rectComboBox.bottom = rectButton.bottom + heightAdjustment;
		pComboBox->MoveWindow(&rectComboBox);
		pComboBox->SetItemHeight(-1, rectButton.Height() - 6);
	}
}

void CAxisSettingsDlg::OnSizing(UINT fwSide, LPRECT pRect)
{
	if (fwSide == WMSZ_BOTTOMRIGHT) {
		if (pRect->right - pRect->left < 200) {
			pRect->right = pRect->left + 200;
		}
		if (pRect->bottom - pRect->top < 150) {
			pRect->bottom = pRect->top + 150;
		}
	}

	CDialogEx::OnSizing(fwSide, pRect);
}

HBRUSH CAxisSettingsDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = CDialogEx::OnCtlColor(pDC, pWnd, nCtlColor);

	// TODO:  在此更改 DC 的任何特性

	// TODO:  如果默认的不是所需画笔，则返回另一个画笔
	return hbr;
}

void CAxisSettingsDlg::OnBnClickedButtonAxisLast()
{
	// TODO: 在此添加控件通知处理程序代码
	updateAxisSelection(-1);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisNext()
{
	// TODO: 在此添加控件通知处理程序代码
	updateAxisSelection(1);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup1()
{
	// TODO: 在此添加控件通知处理程序代码
	switchToPage(1);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup2()
{
	// TODO: 在此添加控件通知处理程序代码
	switchToPage(2);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup3()
{
	// TODO: 在此添加控件通知处理程序代码
	switchToPage(3);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup4()
{
	// TODO: 在此添加控件通知处理程序代码
	switchToPage(4);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup5()
{
	// TODO: 在此添加控件通知处理程序代码
	switchToPage(5);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint1()
{
	// TODO: 在此添加控件通知处理程序代码
	handleAxisOperation(AxisOperationType::POSITION_1, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint2()
{
	// TODO: 在此添加控件通知处理程序代码
	handleAxisOperation(AxisOperationType::POSITION_2, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint3()
{
	// TODO: 在此添加控件通知处理程序代码
	handleAxisOperation(AxisOperationType::POSITION_3, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint4()
{
	// TODO: 在此添加控件通知处理程序代码
	handleAxisOperation(AxisOperationType::POSITION_4, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint5()
{
	// TODO: 在此添加控件通知处理程序代码
	handleAxisOperation(AxisOperationType::POSITION_5, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisTestOpr()
{
	// TODO: 在此添加控件通知处理程序代码
	handleAxisOperation(AxisOperationType::OPR, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisTestStop()
{
	// TODO: 在此添加控件通知处理程序代码
	handleAxisOperation(AxisOperationType::STOP, true);
}

void CAxisSettingsDlg::OnSelchangeComboAxisName()
{
	// TODO: 在此添加控件通知处理程序代码
	int axisId = getCurrentSelectedAxisID();
	if (axisId == -1) {
		AfxMessageBox(_T("请选择一个有效的轴编号！"));
		return;
	}

	refreshAxisDetails(axisId);
	refreshPositionDetails(axisId, m_currentPage);
	updatePageButtonStates();
}

void CAxisSettingsDlg::OnBnClickedButtonAxisSave()
{
	// TODO: 在此添加控件通知处理程序代码
	int axisId = getCurrentSelectedAxisID();
	if (axisId == -1) {
		AfxMessageBox(_T("请选择一个有效的轴编号！"));
		return;
	}

	CString cstrMessage;
	cstrMessage.Format(_T("是否保存轴 [%d] 参数？"), axisId);
	int ret = AfxMessageBox(_T(cstrMessage), MB_OKCANCEL | MB_ICONEXCLAMATION);
	if (ret != IDOK) {
		return;
	}

	updateDataFromUI(axisId);
	if (RecipeManager::getInstance().saveRecipe(std::string(CT2A(m_strRecipeName)))) {
		writeAxisDataToPLC(axisId);
		cstrMessage.Format(_T("保存轴 [%d] 参数成功！"), axisId);
		SystemLogManager::getInstance().log(SystemLogManager::LogType::Operation, std::string(CT2A(cstrMessage)));
	}
	else {
		cstrMessage.Format(_T("保存轴 [%d] 参数失败！"), axisId);
		SystemLogManager::getInstance().log(SystemLogManager::LogType::Error, std::string(CT2A(cstrMessage)));
	}

	AfxMessageBox(cstrMessage);
}

void CAxisSettingsDlg::OnTimer(UINT_PTR nIDEvent)
{
	if (TIMER_READ_PLC_DATA == nIDEvent) {
		ASSERT(m_pPLC);

		int addr1, addr2, readSize;
		addr1 = 5120;
		addr2 = 5425;
		readSize = (addr2 - addr1 + 1) * 2;
		auto funOnReadData = [&, addr1, readSize](IMcChannel* pChannel, int addr, char* pData, unsigned int nDataSize, int flag) -> void {
			if (nDataSize == readSize && flag == 0) {
				double fCurPos = CToolUnits::toInt32(pData) * 0.001;
				double fManualSpeed = CToolUnits::toInt32(&pData[(5422- addr1)*2]) * 0.001;
				double fAutoSpeed = CToolUnits::toInt32(&pData[(5424 - addr1) * 2]) * 0.001;
				double fPrm = CToolUnits::toInt32(&pData[(5150 - addr1) * 2]) * 0.1;
				int nLoad = CToolUnits::toInt16(&pData[(5154 - addr1) * 2]);
				int nErrCode = CToolUnits::toInt16(&pData[(5126 - addr1) * 2]);
				int nAlarmCode = CToolUnits::toInt16(&pData[(5127 - addr1) * 2]);
				CToolUnits::setDlgItemDouble(this, IDC_EDIT_AXIS_CURR_POS, fCurPos);
				CToolUnits::setDlgItemDouble(this, IDC_EDIT_AXIS_CURR_MANUAL_SPEED, fManualSpeed);
				CToolUnits::setDlgItemDouble(this, IDC_EDIT_AXIS_CURR_AUTO_SPEED, fAutoSpeed);
				CToolUnits::setDlgItemDouble(this, IDC_EDIT_AXIS_CURR_ROTA_SPEED, fPrm);
				SetDlgItemInt(IDC_EDIT_AXIS_CURR_LOAD, nLoad);
				SetDlgItemInt(IDC_EDIT_AXIS_CURR_ERROR_NUMBER, nErrCode);
				SetDlgItemInt(IDC_EDIT_AXIS_CURR_ALARM_NUMBER, nAlarmCode);
			}
		};
		m_pPLC->readData(MC::SOFT_COMPONENT::D, addr1, readSize, funOnReadData);
	}	
	else if (nIDEvent == TIMER_JOG_ADD && m_bJogAddPressed) {
		TRACE("持续发送 JOG+\n");
		handleAxisOperation(AxisOperationType::JOG_ADD, true); // 持续发送 JOG+
	}
	else if (nIDEvent == TIMER_JOG_SUB && m_bJogSubPressed) {
		TRACE("持续发送 JOG-\n");
		handleAxisOperation(AxisOperationType::JOG_SUB, true); // 持续发送 JOG-
	}

	CDialogEx::OnTimer(nIDEvent);
}