// ServoDlg.cpp : ʵÏÖÎļþ
//

#include "stdafx.h"
#include "Servo.h"
#include "ServoDlg.h"
#include "afxdialogex.h"
#include "Common.h"
#include "Log.h"
#include "SecsTestDlg.h"
#include "AlarmDlg.h"
#include <chrono>
#include <thread>
#include <cmath>


#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// Image
#define IMAGE_ROBOT				2

#define INDICATE_BONDER1		1
#define INDICATE_BONDER2		2
#define INDICATE_FLIPER			3
#define INDICATE_ALIGNER		4
#define INDICATE_LPORT4			5
#define INDICATE_LPORT3			6
#define INDICATE_LPORT2			7
#define INDICATE_LPORT1			8
#define INDICATE_ROBOT_ARM1		9
#define INDICATE_ROBOT_ARM2		10
#define INDICATE_VACUUM_BAKE	11
#define INDICATE_BAKE_COOLING	12
#define INDICATE_MEASUREMENT	13


/* ´´½¨Öն˵Ķ¨Ê±Æ÷ */
#define TIMER_ID_CREATE_TERMINAL		1


// ÓÃÓÚÓ¦ÓóÌÐò¡°¹ØÓÚ¡±²Ëµ¥ÏîµÄ CAboutDlg ¶Ô»°¿ò

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

// ¶Ô»°¿òÊý¾Ý
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_ABOUTBOX };
#endif

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV Ö§³Ö

// ʵÏÖ
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// CServoDlg ¶Ô»°¿ò



CServoDlg::CServoDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(IDD_SERVO_DIALOG, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	m_crBkgnd = APPDLG_BACKGROUND_COLOR;
	m_hbrBkgnd = nullptr;
	m_bShowLogWnd = FALSE;
	m_bShowAlarmWnd = FALSE;
	m_bIsRobotMoving = FALSE;
	m_pLogDlg = nullptr;
	m_pAlarmDlg = nullptr;
	m_pTerminalDisplayDlg = nullptr;
	m_pObserver = nullptr;
	m_pPanelMaster = nullptr;
	m_pPanelEquipment = nullptr;
	m_pPanelAttributes = nullptr;
}

void CServoDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_BUTTON_LOG, m_btnLog);
	DDX_Control(pDX, IDC_BUTTON_ALARM, m_btnAlarm);
}

BEGIN_MESSAGE_MAP(CServoDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDOK, &CServoDlg::OnBnClickedOk)
	ON_BN_CLICKED(IDCANCEL, &CServoDlg::OnBnClickedCancel)
	ON_WM_CTLCOLOR()
	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_BUTTON_LOG, &CServoDlg::OnBnClickedButtonLog)
	ON_WM_SIZE()
	ON_WM_CLOSE()
	ON_MESSAGE(ID_MSG_LOGDLG_HIDE, &CServoDlg::OnLogDlgHide)
	ON_MESSAGE(ID_MSG_ALARMDLG_HIDE, &CServoDlg::OnAlarmDlgHide)
	ON_WM_MOVING()
	ON_WM_MOVE()
	ON_COMMAND(ID_MENU_FILE_EXIT, &CServoDlg::OnMenuFileExit)
	ON_UPDATE_COMMAND_UI(ID_MENU_FILE_EXIT, &CServoDlg::OnUpdateMenuFileExit)
	ON_COMMAND(ID_MENU_FILE_SETTINGS, &CServoDlg::OnMenuFileSettings)
	ON_UPDATE_COMMAND_UI(ID_MENU_FILE_SETTINGS, &CServoDlg::OnUpdateMenuFileSettings)
	ON_COMMAND(ID_MENU_FILE_SECSTEST, &CServoDlg::OnMenuFileSecsTest)
	ON_UPDATE_COMMAND_UI(ID_MENU_FILE_SECSTEST, &CServoDlg::OnUpdateMenuFileSecsTest)
	ON_COMMAND(ID_MENU_WND_LOG, &CServoDlg::OnMenuWndLog)
	ON_UPDATE_COMMAND_UI(ID_MENU_WND_LOG, &CServoDlg::OnUpdateMenuWndLog)
	ON_COMMAND(ID_MENU_WND_ALARM, &CServoDlg::OnMenuWndAlarm)
	ON_UPDATE_COMMAND_UI(ID_MENU_WND_ALARM, &CServoDlg::OnUpdateMenuWndAlarm)
	ON_COMMAND(ID_MENU_HELP_ABOUT, &CServoDlg::OnMenuHelpAbout)
	ON_WM_INITMENUPOPUP()
	ON_WM_TIMER()
	ON_WM_ERASEBKGND()
	ON_BN_CLICKED(IDC_BUTTON_ALARM, &CServoDlg::OnBnClickedButtonAlarm)
	ON_BN_CLICKED(IDC_BUTTON_ALARM, &CServoDlg::OnBnClickedButtonAlarm)
	ON_NOTIFY(BYSERVOGRAPH_ITEM_CLICKED, IDC_SERVO_GRAPH1, &CServoDlg::OnGraphItemClicked)
	ON_MESSAGE(ID_MSG_PANEL_RESIZE, OnPanelResize)
END_MESSAGE_MAP()


// CServoDlg ÏûÏ¢´¦Àí³ÌÐò

void CServoDlg::InitRxWindows()
{
	/* code */
	// ¶©ÔÄÊý¾Ý
	IRxWindows* pRxWindows = RX_GetRxWindows();
	pRxWindows->enableLog(5);
	if (m_pObserver == NULL) {
		m_pObserver = pRxWindows->allocObserver([&](IAny* pAny) -> void {
			// onNext
			pAny->addRef();
			int code = pAny->getCode();
			if (RX_HSMS_TERMINAL_TEXT == code) {
				const char* pszText;
				if (pAny->getStringValue("text", pszText)) {
					ShowTerminalText(pszText);
				}
			}
			else if (RX_CODE_EQ_ALIVE == code) {
				// ֪ͨÉ豸״̬
				SERVO::CEquipment* pEquipment = nullptr;
				if (pAny->getPtrValue("ptr", (void*&)pEquipment)) {
					if (pEquipment != nullptr) {
						int nID = pEquipment->getID();
						BOOL bAlive = pEquipment->isAlive();
						if (EQ_ID_EFEM == nID) {
							DeviceStatus status = bAlive ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
							UpdateDeviceStatus(INDICATE_ROBOT_ARM1, status);
							UpdateDeviceStatus(INDICATE_ROBOT_ARM2, status);
						}
					}
				}
			}
			else if (RX_CODE_SELECT_EQUIPMENT == code) {
				SERVO::CEquipment* pEquipment = nullptr;
				if (pAny->getPtrValue("ptr", (void*&)pEquipment)) {
					ASSERT(pEquipment);
					ASSERT(m_pPanelEquipment);
					ASSERT(m_pPanelAttributes);
					m_pPanelEquipment->SetEquipment(pEquipment);
					m_pPanelAttributes->ShowWindow(SW_HIDE);
					if (!m_pPanelEquipment->IsWindowVisible()) {
						m_pPanelEquipment->ShowWindow(SW_SHOW);
						Resize();
					}
				}
			}
			else if (RX_CODE_SELECT_STEP == code) {
				SERVO::CStep* pStep = nullptr;
				if (pAny->getPtrValue("ptr", (void*&)pStep)) {
					ASSERT(pStep);
					ASSERT(m_pPanelEquipment);
					ASSERT(m_pPanelAttributes);
					m_pPanelEquipment->ShowWindow(SW_HIDE);
					m_pPanelAttributes->loadDataFromStep(pStep);
					if (!m_pPanelAttributes->IsWindowVisible()) {
						m_pPanelAttributes->ShowWindow(SW_SHOW);
						Resize();
					}
				}
			}

			pAny->release();
		}, [&]() -> void {
			// onComplete
		}, [&](IThrowable* pThrowable) -> void {
			// onErrorm
			pThrowable->printf();
		});

		theApp.m_model.getObservable()->observeOn(pRxWindows->mainThread())
			->subscribe(m_pObserver);
	}
}

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

	// ½«¡°¹ØÓÚ...¡±²Ëµ¥ÏîÌí¼Óµ½ÏµÍ³²Ëµ¥ÖС£

	// IDM_ABOUTBOX ±ØÐëÔÚϵͳÃüÁΧÄÚ¡£
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// ÉèÖô˶Ի°¿òµÄͼ±ê¡£  µ±Ó¦ÓóÌÐòÖ÷´°¿Ú²»ÊǶԻ°¿òʱ£¬¿ò¼Ü½«×Ô¶¯
	//  Ö´Ðд˲Ù×÷
	SetIcon(m_hIcon, TRUE);			// ÉèÖôóͼ±ê
	SetIcon(m_hIcon, FALSE);		// ÉèÖÃСͼ±ê


									// ²Ëµ¥
	CMenu menu;
	menu.LoadMenu(IDR_MENU_APP);
	SetMenu(&menu);



	// ͼʾ
	m_pGraph = CServoGraph::Hook(GetDlgItem(IDC_SERVO_GRAPH1)->GetSafeHwnd());
	CString strPath;
	strPath.Format(_T("%s\\res\\Servo001.bmp"), (LPTSTR)(LPCTSTR)theApp.m_strAppDir);
	m_pGraph->AddImage(1, (LPTSTR)(LPCTSTR)strPath, 0, 0);

	strPath.Format(_T("%s\\res\\Robot001.bmp"), (LPTSTR)(LPCTSTR)theApp.m_strAppDir);
	m_pGraph->AddImage(IMAGE_ROBOT, (LPTSTR)(LPCTSTR)strPath, 170, 270);

	// Ìí¼ÓָʾÆ÷
	// Bonder
	m_pGraph->AddIndicateBox(INDICATE_BONDER1, 220, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_BONDER1, "10", "Bonder 1");
	m_pGraph->AddIndicateBox(INDICATE_BONDER2, 220, 516, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_BONDER2, "11", "Bonder 2");


	// ·­×ª
	m_pGraph->AddIndicateBox(INDICATE_FLIPER, 338, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_FLIPER, "8", "Fliper");


	// ¶Ôλ
	m_pGraph->AddIndicateBox(INDICATE_ALIGNER, 428, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_ALIGNER, "7", "Aligner");


	// Load port 4
	m_pGraph->AddIndicateBox(INDICATE_LPORT4, 518, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_LPORT4, "4", "LPort4");


	// Load port 3
	m_pGraph->AddIndicateBox(INDICATE_LPORT3, 606, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_LPORT3, "3", "LPort3");


	// Load port 2
	m_pGraph->AddIndicateBox(INDICATE_LPORT2, 690, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_LPORT2, "2", "LPort2");


	// Load port 1
	m_pGraph->AddIndicateBox(INDICATE_LPORT1, 774, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_LPORT1, "1", "LPort1");


	// Robot
	m_pGraph->AddIndicateBox(INDICATE_ROBOT_ARM1, 190, 294, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_ROBOT_ARM1, "5", "Robot");
	m_pGraph->AddIndicateBox(INDICATE_ROBOT_ARM2, 243, 294, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_ROBOT_ARM2, "6", "Robot");




	// Vacuum bake
	m_pGraph->AddIndicateBox(INDICATE_VACUUM_BAKE, 396, 516, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_VACUUM_BAKE, "9", "Vacuum bake");


	// Bake cooling
	m_pGraph->AddIndicateBox(INDICATE_BAKE_COOLING, 566, 516, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_BAKE_COOLING, "12", "Bake cooling");


	// Bake cooling
	m_pGraph->AddIndicateBox(INDICATE_MEASUREMENT, 736, 516, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), RGB(0, 176, 80));
	m_pGraph->SetBoxText(INDICATE_MEASUREMENT, "13", "Measurement");



	m_pPanelMaster = new CPanelMaster();
	m_pPanelMaster->Create(IDD_PANEL_MASTER, this);
	m_pPanelMaster->ShowWindow(SW_SHOW);
	m_pPanelEquipment = new CPanelEquipment();
	m_pPanelEquipment->Create(IDD_PANEL_EQUIPMENT, this);
	m_pPanelAttributes = new CPanelAttributes();
	m_pPanelAttributes->Create(IDD_PANEL_ATTRIBUTES, this);
	


	// µ÷Õû³õʼ´°¿ÚλÖÃ
	CRect rcWnd;
	GetWindowRect(&rcWnd);
	int width = GetSystemMetrics(SM_CXSCREEN);
	int height = GetSystemMetrics(SM_CYSCREEN);
	MoveWindow((width - rcWnd.Width()) / 2, 0, rcWnd.Width(), rcWnd.Height(), TRUE);


	// model init
	theApp.m_model.init();


	SetTimer(TIMER_ID_CREATE_TERMINAL, 3000, nullptr);
	InitRxWindows();
	OnBnClickedButtonLog();
	UpdateLogBtn();
	UpdateAlarmBtn();
	Resize();


	// Ï൱ÓÚÑÓʱµ÷ÓÃmasterµÄ³õʼ»¯
	theApp.m_model.m_master.init();


	// °ó¶¨Êý¾Ý
	{
		SERVO::CEquipment* pEquipment = theApp.m_model.m_master.getEquipment(EQ_ID_EFEM);
		m_pGraph->SetIndicateBoxData(INDICATE_ROBOT_ARM1, pEquipment);
	}


	return TRUE;  // ³ý·Ç½«½¹µãÉèÖõ½¿Ø¼þ£¬·ñÔò·µ»Ø TRUE
}

void CServoDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

// Èç¹ûÏò¶Ô»°¿òÌí¼Ó×îС»¯°´Å¥£¬ÔòÐèÒªÏÂÃæµÄ´úÂë
//  À´»æÖƸÃͼ±ê¡£  ¶ÔÓÚʹÓÃÎĵµ/ÊÓͼģÐ굀 MFC Ó¦ÓóÌÐò£¬
//  Õ⽫ÓÉ¿ò¼Ü×Ô¶¯Íê³É¡£

void CServoDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // ÓÃÓÚ»æÖƵÄÉ豸ÉÏÏÂÎÄ

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// ʹͼ±êÔÚ¹¤×÷Çø¾ØÐÎÖоÓÖÐ
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// »æÖÆͼ±ê
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

//µ±Óû§Í϶¯×îС»¯´°¿Úʱϵͳµ÷Óô˺¯ÊýÈ¡µÃ¹â±ê
//ÏÔʾ¡£
HCURSOR CServoDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

void CServoDlg::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
{
	ASSERT(pPopupMenu != NULL);

	CCmdUI state;
	state.m_pMenu = pPopupMenu;
	ASSERT(state.m_pOther == NULL);
	ASSERT(state.m_pParentMenu == NULL);

	HMENU hParentMenu;
	if (AfxGetThreadState()->m_hTrackingMenu == pPopupMenu->m_hMenu)
		state.m_pParentMenu = pPopupMenu;
	else if ((hParentMenu = ::GetMenu(m_hWnd)) != NULL)
	{
		CWnd* pParent = this;
		if (pParent != NULL &&
			(hParentMenu = ::GetMenu(pParent->m_hWnd)) != NULL)
		{
			int nIndexMax = ::GetMenuItemCount(hParentMenu);
			for (int nIndex = 0; nIndex < nIndexMax; nIndex++)
			{
				if (::GetSubMenu(hParentMenu, nIndex) == pPopupMenu->m_hMenu)
				{
					state.m_pParentMenu = CMenu::FromHandle(hParentMenu);
					break;
				}
			}
		}
	}

	state.m_nIndexMax = pPopupMenu->GetMenuItemCount();
	for (state.m_nIndex = 0; state.m_nIndex < state.m_nIndexMax;
	state.m_nIndex++)
	{
		state.m_nID = pPopupMenu->GetMenuItemID(state.m_nIndex);
		if (state.m_nID == 0)
			continue;

		ASSERT(state.m_pOther == NULL);
		ASSERT(state.m_pMenu != NULL);
		if (state.m_nID == (UINT)-1)
		{
			state.m_pSubMenu = pPopupMenu->GetSubMenu(state.m_nIndex);
			if (state.m_pSubMenu == NULL ||
				(state.m_nID = state.m_pSubMenu->GetMenuItemID(0)) == 0 ||
				state.m_nID == (UINT)-1)
			{
				continue;
			}
			state.DoUpdate(this, TRUE);
		}
		else
		{
			state.m_pSubMenu = NULL;
			state.DoUpdate(this, FALSE);
		}

		UINT nCount = pPopupMenu->GetMenuItemCount();
		if (nCount < state.m_nIndexMax)
		{
			state.m_nIndex -= (state.m_nIndexMax - nCount);
			while (state.m_nIndex < nCount &&
				pPopupMenu->GetMenuItemID(state.m_nIndex) == state.m_nID)
			{
				state.m_nIndex++;
			}
		}
		state.m_nIndexMax = nCount;
	}
}

void CServoDlg::OnMenuFileSettings()
{

}

void CServoDlg::OnUpdateMenuFileSettings(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(TRUE);
}

void CServoDlg::OnMenuFileSecsTest()
{
	CSecsTestDlg dlg;
	dlg.DoModal();
}

void CServoDlg::OnUpdateMenuFileSecsTest(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(TRUE);
}

void CServoDlg::OnMenuWndLog()
{
	OnBnClickedButtonLog();
}

void CServoDlg::OnUpdateMenuWndLog(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(m_bShowLogWnd);
}

void CServoDlg::OnMenuWndAlarm()
{
	OnBnClickedButtonAlarm();
}

void CServoDlg::OnUpdateMenuWndAlarm(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(m_bShowAlarmWnd);
}

void CServoDlg::OnMenuFileExit()
{
	PostMessage(WM_CLOSE);
}

void CServoDlg::OnUpdateMenuFileExit(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(TRUE);
}

void CServoDlg::OnMenuHelpAbout()
{
	CAboutDlg dlgAbout;
	dlgAbout.DoModal();
}

void CServoDlg::OnBnClickedOk()
{
	// TODO: ÔÚ´ËÌí¼Ó¿Ø¼þ֪ͨ´¦Àí³ÌÐò´úÂë
	CDialogEx::OnOK();
}


void CServoDlg::OnBnClickedCancel()
{
	// TODO: ÔÚ´ËÌí¼Ó¿Ø¼þ֪ͨ´¦Àí³ÌÐò´úÂë
	CDialogEx::OnCancel();
}

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

	if (nCtlColor == CTLCOLOR_STATIC) {
		pDC->SetBkColor(m_crBkgnd);
		pDC->SetTextColor(RGB(0, 0, 0));
	}

	if (m_hbrBkgnd == nullptr) {
		m_hbrBkgnd = CreateSolidBrush(m_crBkgnd);
	}

	return m_hbrBkgnd;
}

void CServoDlg::OnDestroy()
{
	CDialogEx::OnDestroy();

	if (m_pLogDlg != nullptr) {
		m_pLogDlg->DestroyWindow();
		delete m_pLogDlg;
		m_pLogDlg = nullptr;
	}

	if (m_pAlarmDlg != nullptr) {
		m_pAlarmDlg->DestroyWindow();
		delete m_pAlarmDlg;
		m_pAlarmDlg = nullptr;
	}

	if (m_pTerminalDisplayDlg != nullptr) {
		m_pTerminalDisplayDlg->DestroyWindow();
		delete m_pTerminalDisplayDlg;
		m_pTerminalDisplayDlg = nullptr;
	}

	if (m_pPanelMaster != nullptr) {
		m_pPanelMaster->DestroyWindow();
		delete m_pPanelMaster;
		m_pPanelMaster = nullptr;
	}

	if (m_pPanelEquipment != nullptr) {
		m_pPanelEquipment->DestroyWindow();
		delete m_pPanelEquipment;
		m_pPanelEquipment = nullptr;
	}

	if (m_pPanelAttributes != nullptr) {
		m_pPanelAttributes->DestroyWindow();
		delete m_pPanelAttributes;
		m_pPanelAttributes = nullptr;
	}
	
	if (m_hbrBkgnd != nullptr) {
		::DeleteObject(m_hbrBkgnd);
	}

	if (m_pObserver != nullptr) {
		m_pObserver->unsubscribe();
		m_pObserver = NULL;
	}

}

void CServoDlg::OnBnClickedButtonAlarm()
{
	m_bShowAlarmWnd = !m_bShowAlarmWnd;

	// Èç¹ûÒªÏÔʾ±¨¾¯´°¿Ú£¬ÔòÒþ²ØÈÕÖ¾´°¿Ú
	if (m_bShowLogWnd) {
		m_bShowLogWnd = false;
		if (m_pLogDlg != nullptr) {
			m_pLogDlg->ShowWindow(SW_HIDE);
			UpdateLogBtn();
		}
	}

	if (m_pAlarmDlg == nullptr) {
		m_pAlarmDlg = new CAlarmDlg();
		m_pAlarmDlg->Create(IDD_DIALOG_ALARM, this);

		CRect rcWnd;
		GetWindowRect(&rcWnd);
		m_pAlarmDlg->MoveWindow(rcWnd.left, rcWnd.bottom - 8, rcWnd.Width(), 200);
	}
	ASSERT(m_pAlarmDlg);
	m_pAlarmDlg->ShowWindow(m_bShowAlarmWnd ? SW_SHOW : SW_HIDE);

	UpdateAlarmBtn();
}

void CServoDlg::OnBnClickedButtonLog()
{
	m_bShowLogWnd = !m_bShowLogWnd;

	// Èç¹ûÒªÏÔʾÈÕÖ¾´°¿Ú£¬ÔòÒþ²Ø±¨¾¯´°¿Ú
	if (m_bShowLogWnd) {
		m_bShowAlarmWnd = false;
		if (m_pAlarmDlg != nullptr) {
			m_pAlarmDlg->ShowWindow(SW_HIDE);
			UpdateAlarmBtn();
		}
	}

	if (m_pLogDlg == nullptr) {
		m_pLogDlg = new CLogDlg();
		m_pLogDlg->Create(IDD_DIALOG_LOG, this);

		CRect rcWnd;
		GetWindowRect(&rcWnd);
		m_pLogDlg->MoveWindow(rcWnd.left, rcWnd.bottom - 8, rcWnd.Width(), 200);
	}
	ASSERT(m_pLogDlg);
	m_pLogDlg->ShowWindow(m_bShowLogWnd ? SW_SHOW : SW_HIDE);

	UpdateLogBtn();
}

void CServoDlg::UpdateLogBtn()
{
	m_btnLog.SetFrameColor(BS_NORMAL, BTN_LOG_FRAME_NORMAL);
	m_btnLog.SetFrameColor(BS_HOVER, BTN_LOG_FRAME_HOVER);
	m_btnLog.SetFrameColor(BS_PRESS, BTN_LOG_FRAME_PRESS);
	m_btnLog.SetBkgndColor(BS_NORMAL, m_bShowLogWnd ? BTN_LOG_BKGND_PRESS : BTN_LOG_BKGND_NORMAL);
	m_btnLog.SetBkgndColor(BS_HOVER, BTN_LOG_BKGND_HOVER);
	m_btnLog.SetBkgndColor(BS_PRESS, BTN_LOG_BKGND_PRESS);
	m_btnLog.Invalidate();
}

void CServoDlg::UpdateAlarmBtn()
{
	m_btnAlarm.SetFrameColor(BS_NORMAL, BTN_ALARM_FRAME_NORMAL);
	m_btnAlarm.SetFrameColor(BS_HOVER, BTN_ALARM_FRAME_HOVER);
	m_btnAlarm.SetFrameColor(BS_PRESS, BTN_ALARM_FRAME_PRESS);
	m_btnAlarm.SetBkgndColor(BS_NORMAL, m_bShowAlarmWnd ? BTN_ALARM_BKGND_PRESS : BTN_ALARM_BKGND_NORMAL);
	m_btnAlarm.SetBkgndColor(BS_HOVER, BTN_ALARM_BKGND_HOVER);
	m_btnAlarm.SetBkgndColor(BS_PRESS, BTN_ALARM_BKGND_PRESS);
	m_btnAlarm.Invalidate();
}

void CServoDlg::UpdateRobotPosition(float percentage)
{
	// ÏÞÖưٷֱȷ¶Î§ÔÚ [0, 1] Ö®¼ä
	if (percentage < 0.0f) percentage = 0.0f;
	if (percentage > 1.0f) percentage = 1.0f;

	// ¸ù¾Ý°Ù·Ö±È¼ÆËãÄ¿±ê X ×ø±ê
	int startX = m_pGraph->GetImage(IMAGE_ROBOT)->x;
	int endX = static_cast<int>(170 + percentage * (700 - 170));

	int arm1Offset = 20;  // ´ÓͼƬµ½ARM1µÄÆ«ÒÆ
	int arm2Offset = 73;  // ´ÓͼƬµ½ARM2µÄÆ«ÒÆ

	// ¼ÆËãÒƶ¯ËùÐèµÄʱ¼ä
	int distance = abs(endX - startX);
	int duration = static_cast<int>((distance / 100.0) * 1000);

	auto startTime = std::chrono::steady_clock::now();
	auto endTime = startTime + std::chrono::milliseconds(duration);

	// ¿ªÊ¼Òƶ¯£¬ÉèÖñê¼Ç
	m_bIsRobotMoving = TRUE;

	// ¿ªÊ¼Æ½»¬Òƶ¯
	while (std::chrono::steady_clock::now() < endTime) {
		auto currentTime = std::chrono::steady_clock::now();
		float progress = std::chrono::duration<float, std::milli>(currentTime - startTime).count() / duration;
		progress = min(progress, 1.0f);

		// ¸ù¾Ý½ø¶È¼ÆË㵱ǰλÖÃ
		int currentX = static_cast<int>(startX + progress * (endX - startX));
		m_pGraph->UpdateImageCoordinates(IMAGE_ROBOT, currentX, 270);
		m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, currentX + arm1Offset, 294);
		m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, currentX + arm2Offset, 294);

		// ˢнçÃæ
		Invalidate();
		UpdateWindow();

		// ¿ØÖÆÖ¡ÂÊԼΪ 60 FPS
		std::this_thread::sleep_for(std::chrono::milliseconds(16));
	}

	// È·±£×îºóλÖþ«È·µ½Ä¿±êλÖÃ
	m_pGraph->UpdateImageCoordinates(IMAGE_ROBOT, endX, 270);
	m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, endX + arm1Offset, 294);
	m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, endX + arm2Offset, 294);

	// ½çÃæÖØ»æ
	Invalidate();

	// ¶¯»­½áÊø£¬ÉèÖñê¼Ç
	m_bIsRobotMoving = FALSE;
}

void CServoDlg::RotateRobot(float angleInDegrees)
{
	// ½«½Ç¶Èת»»Îª»¡¶È
	float angleInRadians = static_cast<float>(std::acos(-1)) / 180.0f * angleInDegrees;

	// »ñÈ¡»úÆ÷ÈËͼƬµÄµ±Ç°×ø±êºÍÖÐÐÄ
	auto* pImage = m_pGraph->GetImage(IMAGE_ROBOT);
	if (!pImage) return;

	// ¸üРRotate ͼƬµÄ½Ç¶È£¬È·±£½Ç¶È±£³ÖÔÚ [0, 360) ·¶Î§ÄÚ
	m_pGraph->UpdateImageAngle(IMAGE_ROBOT, static_cast<float>(fmod(pImage->angle + angleInDegrees + 360, 360)));

	int cx = pImage->x + pImage->bmWidth / 2;  // ͼƬÖÐÐÄ X
	int cy = pImage->y + pImage->bmHeight / 2; // ͼƬÖÐÐÄ Y

	// Ðýתָʾ¿òµÄ×ø±ê
	auto* pRobot1 = m_pGraph->GetIndicateBox(INDICATE_ROBOT_ARM1);
	auto* pRobot2 = m_pGraph->GetIndicateBox(INDICATE_ROBOT_ARM2);

	if (pRobot1 && pRobot2) {
		int newArmX1 = pImage->x + 20;
		int newArmY1 = 294;

		int newArmX2 = pImage->x + 73;
		int newArmY2 = 294;

		if (angleInDegrees != 0.0f) {
			// ¼ÆËãָʾ¿ò1µÄÐÂ×ø±ê
			newArmX1 = static_cast<int>(cx + (pRobot1->x - cx) * cos(angleInRadians) - (pRobot1->y - cy) * sin(angleInRadians));
			newArmY1 = static_cast<int>(cy + (pRobot1->x - cx) * sin(angleInRadians) + (pRobot1->y - cy) * cos(angleInRadians));

			// ¼ÆËãָʾ¿ò2µÄÐÂ×ø±ê
			newArmX2 = static_cast<int>(cx + (pRobot2->x - cx) * cos(angleInRadians) - (pRobot2->y - cy) * sin(angleInRadians));
			newArmY2 = static_cast<int>(cy + (pRobot2->x - cx) * sin(angleInRadians) + (pRobot2->y - cy) * cos(angleInRadians));
		}

		// ¸üÐÂָʾ¿òµÄλÖÃ
		m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, newArmX1, newArmY1);
		m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, newArmX2, newArmY2);
	}

	// Ç¿ÖÆÖØ»æ½çÃæ
	Invalidate();
}

void CServoDlg::UpdateDeviceStatus(int id, DeviceStatus status)
{
	// ¸ù¾Ý״̬ÉèÖÃÑÕÉ«
	COLORREF newBackgroundColor;
	COLORREF newFrameColor1;
	COLORREF newFrameColor2;

	switch (status) {
	case ONLINE:
		newBackgroundColor = RGB(0, 255, 0);
		newFrameColor1 = RGB(22, 22, 22);
		newFrameColor2 = RGB(255, 127, 39);
		break;
	case OFFLINE:
		newBackgroundColor = RGB(255, 0, 0);
		newFrameColor1 = RGB(22, 22, 22);
		newFrameColor2 = RGB(255, 127, 39);
		break;
	default:
		newBackgroundColor = RGB(255, 255, 255); // ĬÈÏ°×É«±³¾°
		newFrameColor1 = RGB(0, 0, 0);           // ĬÈϺÚÉ«¿ò¼Ü1
		newFrameColor2 = RGB(0, 0, 0);           // ĬÈϺÚÉ«¿ò¼Ü2
		break;
	}

	m_pGraph->UpdateIndicateBox1Colors(id, newBackgroundColor, newFrameColor1, newFrameColor2);

	// ˢнçÃæ
	Invalidate();
	UpdateWindow();
}

void CServoDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialogEx::OnSize(nType, cx, cy);
	if (GetDlgItem(IDC_SERVO_GRAPH1) == nullptr) return;
	Resize();
}

void CServoDlg::Resize()
{
	CRect rcClient, rcItem;
	CWnd* pItem = nullptr;
	int x, y;
	GetClientRect(&rcClient);

	x = 0;
	y = 0;
	int nPanelWidth = 0;
	if (m_pPanelMaster != nullptr) {
		nPanelWidth = m_pPanelMaster->getPanelWidth();
		m_pPanelMaster->MoveWindow(x, y, nPanelWidth, rcClient.Height());
		x += nPanelWidth;
	}

	if (m_pPanelEquipment != nullptr && m_pPanelEquipment->IsWindowVisible()) {
		nPanelWidth = m_pPanelEquipment->getPanelWidth();
		m_pPanelEquipment->MoveWindow(x, y, nPanelWidth, rcClient.Height());
		x += nPanelWidth;
	}

	if (m_pPanelAttributes != nullptr && m_pPanelAttributes->IsWindowVisible()) {
		nPanelWidth = m_pPanelAttributes->getPanelWidth();
		m_pPanelAttributes->MoveWindow(x, y, nPanelWidth, rcClient.Height());
		x += nPanelWidth;
	}

	pItem = GetDlgItem(IDC_SERVO_GRAPH1);
	pItem->GetClientRect(&rcItem);
	pItem->MoveWindow(x, y, rcItem.Width(), rcItem.Height());
	y += rcItem.Height();
	y += 8;

	x = rcClient.right - 8;
	pItem = GetDlgItem(IDC_BUTTON_LOG);
	pItem->GetClientRect(&rcItem);
	x -= rcItem.Width();
	pItem->MoveWindow(x, rcClient.bottom - 8 - rcItem.Height(), rcItem.Width(), rcItem.Height());
	x -= 8;

	pItem = GetDlgItem(IDC_BUTTON_ALARM);
	pItem->GetClientRect(&rcItem);
	x -= rcItem.Width();
	pItem->MoveWindow(x, rcClient.bottom - 8 - rcItem.Height(), rcItem.Width(), rcItem.Height());
}

void CServoDlg::OnClose()
{
	// TODO: ÔÚ´ËÌí¼ÓÏûÏ¢´¦Àí³ÌÐò´úÂëºÍ/»òµ÷ÓÃĬÈÏÖµ

	CDialogEx::OnClose();
}

LRESULT CServoDlg::OnLogDlgHide(WPARAM wParam, LPARAM lParam)
{
	m_bShowLogWnd = FALSE;
	UpdateLogBtn();
	LOGE("OnLogDlgHide");

	unsigned int DATAID, RPTID;
	DATAID = 111;
	RPTID = 1001;
	std::vector<std::string> v;
	v.push_back("abc");
	v.push_back("def");
	theApp.m_model.m_hsmsPassive.requestEventReportSend(DATAID, RPTID, v);

	return 0;
}

LRESULT CServoDlg::OnAlarmDlgHide(WPARAM wParam, LPARAM lParam)
{
	m_bShowAlarmWnd = FALSE;
	UpdateAlarmBtn();
	LOGE("OnAlarmDlgHide");

	return 0;
}

void CServoDlg::OnMoving(UINT fwSide, LPRECT pRect)
{
	CDialogEx::OnMoving(fwSide, pRect);
}

void CServoDlg::OnMove(int x, int y)
{
	if (m_pLogDlg != nullptr && !m_pLogDlg->IsZoomed()) {
		CRect rcWnd;
		GetWindowRect(&rcWnd);
		m_pLogDlg->MoveWindow(rcWnd.left, rcWnd.bottom - 8, rcWnd.Width(), 200);
	}

	if (m_pAlarmDlg != nullptr && !m_pAlarmDlg->IsZoomed()) {
		CRect rcWnd;
		GetWindowRect(&rcWnd);
		m_pAlarmDlg->MoveWindow(rcWnd.left, rcWnd.bottom - 8, rcWnd.Width(), 200);
	}

	CDialogEx::OnMove(x, y);
}

void CServoDlg::ShowTerminalText(const char* pszText, unsigned int duration/* = -1*/)
{
	ASSERT(m_pTerminalDisplayDlg);
	m_pTerminalDisplayDlg->ShowText(pszText, duration);
}

void CServoDlg::OnTimer(UINT_PTR nIDEvent)
{
	if (TIMER_ID_CREATE_TERMINAL == nIDEvent) {
		// Ô¤ÏÈ´´½¨Öն˴°¿Ú
		KillTimer(TIMER_ID_CREATE_TERMINAL);
		char szBuffer[MAX_PATH];
		sprintf_s(szBuffer, MAX_PATH, "%s\\RES\\TeminalMsg.html", (LPTSTR)(LPCTSTR)theApp.m_strAppDir);
		m_pTerminalDisplayDlg = new CTerminalDisplayDlg();
		m_pTerminalDisplayDlg->SetTemplateHtml(szBuffer);
		m_pTerminalDisplayDlg->Create(IDD_DIALOG_TERMINAL_DISPLAY, this);
	}

	CDialogEx::OnTimer(nIDEvent);
}


BOOL CServoDlg::OnEraseBkgnd(CDC* pDC)
{
	// TODO: ÔÚ´ËÌí¼ÓÏûÏ¢´¦Àí³ÌÐò´úÂëºÍ/»òµ÷ÓÃĬÈÏÖµ
	if (m_bIsRobotMoving) {
		// ½ûֹˢб³¾°£¬±ÜÃâÉÁ˸
		return TRUE;
	}
	
	return CDialogEx::OnEraseBkgnd(pDC);
}

void CServoDlg::OnGraphItemClicked(NMHDR* pNMHDR, LRESULT* pResult)
{
	BYSERVOGRAPH_NMHDR* pGraphNmhdr = reinterpret_cast<BYSERVOGRAPH_NMHDR*>(pNMHDR);
	CString s; s.Format(_T("OnGraphItemClicked %d"), pGraphNmhdr->dwData);
	SERVO::CEquipment* pEquipment = (SERVO::CEquipment*)m_pGraph->GetIndicateBoxData(pGraphNmhdr->dwData);
	if (pEquipment != nullptr) {
		AfxMessageBox(pEquipment->getName().c_str());
	}
	
	
	*pResult = 0;
}

LRESULT CServoDlg::OnPanelResize(WPARAM wParam, LPARAM lParam)
{
	int width = wParam;
	// m_pPanel->SetPanelWidth(width);
	Resize();

	return 0;
}