/********************************************************
*Copyright :Guide Co.,Ltd.
*All rights reserved
*
*@file:.cpp
*@project:IVMS
*@version: V0.0.1
*@remarks:
*
*@author: yp08237
*@date: 2024-12-03
*@history:
*********************************************************/

#include <QPluginLoader>
#include <QScreen>

#include "ui_mainwindow.h"
#include "mainwindow.h"



#include "../Toolkit_Plugins/Toolkit_MediaX/Toolkit_MediaX.h"
#include "../Toolkit_Plugins/Toolkit_Calculator_SystemTask/Toolkit_Calculator_SystemTask.h"
#include "../Toolkit_Plugins/Toolkit_ImageQualityAssessor/Toolkit_ImageQualityAssessor.h"
#include "../Toolkit_Plugins/Toolkit_ProductSets/Toolkit_ProductSets.h"
#include "CommunicationWgt.h"
#include "./Pages/ToolBox.h"
#include "./UiModules/quiwidget.h"
#include "./UIHelper/commonhelper.h"
#include "./UIHelper/frameless_helper.h"

#include "versionInfo/versionWgt.h"

MainWindow::MainWindow(QWidget* parent) :
	QDialog(parent),
	ui(new Ui::MainWindow),m_CommunicationWgt(new CommunicationWgt)
{
	ui->setupUi(this);

	this->InitForm();

	//    QUIWidget::setFormInCenter(this);
		// 显示在屏幕中间
	CommonHelper::FormInCenter(this);

	LoadConnect();

	m_pPlugin_MediaXPlayer = nullptr;
	m_pPlugin_SystemTask = nullptr;
	m_pPlugin_ImageQualityAssessor = nullptr;
	m_pPlugin_CommunicationInterface = nullptr;
	m_pPlugin_ProductSets = nullptr;

	// 创建浮动窗口
	{
		m_pFloatWidget = new QWidget();
		m_pFloatWidget->setWindowTitle("浮动窗口");
		m_pFloatWidget->setGeometry(100, 100, 960, 540);
		m_pFloatWidget->setLayout(new QHBoxLayout());
		m_pFloatWidget->hide();
		m_bDocked = false;
	}
	m_CommunicationWgt->hide();
	emit ui->m_btnMediaPlayer->click();

}

MainWindow::~MainWindow()
{
	Release();
	delete m_CommunicationWgt;
	delete ui;
}

void MainWindow::LoadConnect()
{
	//
	connect(ui->btnMenu_Max, &QPushButton::clicked, this, &MainWindow::OnButtonClicked);
	connect(ui->btnMenu_Min, &QPushButton::clicked, this, &MainWindow::OnButtonClicked);
	connect(ui->btnMenu_Close, &QPushButton::clicked, this, &MainWindow::OnButtonClicked);
	//
	connect(ui->m_btnMediaPlayer, &QToolButton::clicked, this, &MainWindow::OnButtonClicked_LoadPlugin);
	connect(ui->m_btnSystemTask, &QToolButton::clicked, this, &MainWindow::OnButtonClicked_LoadPlugin);
	connect(ui->m_btnImageQualityAssessor, &QToolButton::clicked, this, &MainWindow::OnButtonClicked_LoadPlugin);
	connect(ui->m_btnCommunicationInterface, &QToolButton::clicked, this, &MainWindow::OnButtonClicked_LoadPlugin);
	connect(ui->m_btnComAssist, &QToolButton::clicked, this, &MainWindow::OnButtonClicked_LoadPlugin);

	connect(ui->btnMenu_Help, &QPushButton::clicked, this, [this]() {
			auto wgt=new VersionWgt;
			wgt->setFixedSize(QSize(300,300));
			wgt->show();
		});
}

void    MainWindow::Release()
{
	if (nullptr != m_pPlugin_MediaXPlayer)
	{
		delete m_pPlugin_MediaXPlayer;
		m_pPlugin_MediaXPlayer = nullptr;
	}

	if (nullptr != m_pPlugin_SystemTask)
	{
		delete m_pPlugin_SystemTask;
		m_pPlugin_SystemTask = nullptr;
	}

	if (nullptr != m_pPlugin_ImageQualityAssessor)
	{
		delete m_pPlugin_ImageQualityAssessor;
		m_pPlugin_ImageQualityAssessor = nullptr;
	}

	if (nullptr != m_pPlugin_CommunicationInterface)
	{
		delete m_pPlugin_CommunicationInterface;
		m_pPlugin_CommunicationInterface = nullptr;
	}

	if (nullptr != m_pPlugin_ProductSets)
	{
		delete m_pPlugin_ProductSets;
		m_pPlugin_ProductSets = nullptr;
	}

	if (nullptr != m_pFloatWidget)
	{
		delete m_pFloatWidget;
		m_pFloatWidget = nullptr;
	}
}


/********************************************************
* @projectName: Toolkits
* @brief:鼠标操作事件
* @param:
* @note:
* @CreatDate: 2024-12-03
* @author:
*********************************************************/

bool MainWindow::eventFilter(QObject* obj, QEvent* event)
{
	QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);//判断鼠标事件

	if (!mouseEvent)
	{
		return false;
	}

	{
		this->setProperty("canMove", true);
	}
	return false;
}

void    MainWindow::closeEvent(QCloseEvent* event)
{
	Release();
}

void MainWindow::InitForm()
{
	this->m_bMax = false;
	this->m_rcLocation = this->geometry();

	this->setProperty("form", true);
	this->setProperty("canMove", true);
	this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint);

	QStatusBar* statusBar = new QStatusBar();

	//IconHelper::Instance()->setIcon(ui->labIco, QChar(0xF243), 30);
	IconHelper::Instance()->setIcon(ui->btnMenu_Min, QChar(0xF2D1));
	IconHelper::Instance()->setIcon(ui->btnMenu_Max, QChar(0xF2D2));
	IconHelper::Instance()->setIcon(ui->btnMenu_Close, QChar(0xF00D));
	IconHelper::Instance()->setIcon(ui->btnMenu_Help, QChar(0xFF1F));


	ui->widgetTitle->setProperty("form", "title");
	ui->widgetTop->setProperty("nav", "top");

	ui->labTitle->setText("工具集软件 V1.00.10/2025-11-21");
	ui->labTitle->setFont(QFont("Microsoft Yahei", 20));
	this->setWindowTitle(ui->labTitle->text());

	//
	QSize icoSize(32, 32);
	int icoWidth = 85;

	//设置顶部导航按钮
	QList<QToolButton*> tbtns = ui->widgetTop->findChildren<QToolButton*>();

	foreach(QToolButton * btn, tbtns)
	{
		btn->setIconSize(icoSize);
		btn->setMinimumWidth(icoWidth);
		btn->setCheckable(true);
		connect(btn, &QToolButton::clicked, this, &MainWindow::OnButtonClicked_CheckStatus);
	}

	//初始化样式
	QString fileName = ":/qss/psblack.css";

	if (!fileName.isEmpty())
	{
		QFile file(fileName);

		if (file.open(QFile::ReadOnly))
		{
			QString str = file.readAll();
			this->SetStyle(str);
		}
	}

	//焦点设置
	installEventFilter(this);
	setMouseTracking(true);
	InitStyles();
}
void MainWindow::InitStyles()
{
	QString fileName = ":/skin/qss/psblack.css";
	if (!fileName.isEmpty())
	{
		QFile file(fileName);

		if (file.open(QFile::ReadOnly))
		{
			QString str = file.readAll();
			this->setStyleSheet(str);
		}
	}
}

void MainWindow::OnButtonClicked_CheckStatus(bool bChecked)
{
	QToolButton* b = (QToolButton*)sender();

	QList<QToolButton*> btns = ui->widgetTop->findChildren<QToolButton*>();

	foreach(QToolButton * btn, btns)
	{
		if (btn == b)
		{
			btn->setChecked(true);
		}
		else
		{
			btn->setChecked(false);
		}
	}
}

void MainWindow::SetStyle(const QString& str)
{
	static QString qss;

	if (qss == str)
	{
		return;
	}

	qss = str;
	QString paletteColor = str.mid(20, 7);
	qApp->setPalette(QPalette(QColor(paletteColor)));
	qApp->setStyleSheet(str);
}

void MainWindow::DoNotify(ePluginCode ePluginCode, int nNotifyCode)
{
	ToolkitBase_Interface* pToolkit = nullptr;

	switch (ePluginCode)
	{
	case ePluginCode_MediaXPlayer:
	{
		pToolkit = dynamic_cast<Toolkit_MediaX*>(m_pPlugin_MediaXPlayer);

		break;
	}
	case ePluginCode_Calculator_SystemTask:
	{
		pToolkit = dynamic_cast<Toolkit_Calculator_SystemTask*>(m_pPlugin_SystemTask);

		break;
	}
	case ePluginCode_ImageQualityAssessor:
	{
		pToolkit = dynamic_cast<Toolkit_ImageQualityAssessor*>(m_pPlugin_ImageQualityAssessor);

		break;
	}
	case ePluginCode_ComAssist:
	{
		pToolkit = dynamic_cast<Toolkit_ProductSets*>(m_pPlugin_ProductSets);

		break;
	}
	default:
	{
		return;
	}
	}

	//
	if (nullptr == pToolkit)
	{
		return;
	}

	//
	QMainWindow* pMainWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

	//
	if (!m_bDocked)
	{
		m_pFloatWidget->hide();

		ui->m_verticalLayout_DockLayout->addWidget(pMainWindow);
	}
	else
	{
		ui->m_verticalLayout_DockLayout->removeWidget(pMainWindow);

		{
			//
			while (!m_pFloatWidget->layout()->isEmpty())
			{
				QWidget* pWidiget = m_pFloatWidget->layout()->itemAt(0)->widget();

				if (nullptr != pWidiget)
				{
					pWidiget->hide();

					m_pFloatWidget->layout()->removeWidget(pWidiget);

					pWidiget = nullptr;
				}
			}
			//
			m_pFloatWidget->setWindowTitle(pToolkit->GetTitle());

			//
			m_pFloatWidget->layout()->setContentsMargins(3, 3, 3, 3);
			m_pFloatWidget->layout()->addWidget(pMainWindow);
			m_pFloatWidget->show();
		}
	}

	m_bDocked = !m_bDocked;
}

void    MainWindow::OnButtonClicked()
{
	/*
	 * Maxsize Window
	 */
	if (sender() == ui->btnMenu_Max)
	{
		if (m_bMax)
		{
			this->setGeometry(m_rcLocation);
			this->setProperty("canMove", true);
		}
		else
		{
			m_rcLocation = this->geometry();
			//                this->showMaximized();

#if 1//QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
			// Qt6 使用 QScreen API
			this->setGeometry(qApp->primaryScreen()->availableGeometry());
#else
			// Qt5 使用原有的 desktop() 方法
			this->setGeometry(qApp->desktop()->availableGeometry());
#endif
			this->setProperty("canMove", false);
		}

		m_bMax = !m_bMax;
	}

	/*
	 * Minsize Window
	 */
	if (sender() == ui->btnMenu_Min)
	{
		this->showMinimized();
	}

	/*
	 * Close Window
	 */
	if (sender() == ui->btnMenu_Close)
	{
		this->close();
	}
}

void    MainWindow::DockPluginWindow(QMainWindow* pPluginWindow)
{
	if (!ui->m_verticalLayout_DockLayout->isEmpty())
	{
		QWidget* pOldPluginWindow = ui->m_verticalLayout_DockLayout->itemAt(0)->widget();

		if (pOldPluginWindow == pPluginWindow)
		{
			return;
		}

		pOldPluginWindow->hide();

		ui->m_verticalLayout_DockLayout->removeWidget(pOldPluginWindow);
	}

	pPluginWindow->showNormal();

	int nCount = ui->m_verticalLayout_DockLayout->count();
	ui->m_verticalLayout_DockLayout->addWidget(pPluginWindow);

	QWidget* pWgt = ui->m_verticalLayout_DockLayout->widget();

	nCount = ui->m_verticalLayout_DockLayout->count();

	m_bDocked = true;
}

void    MainWindow::OnButtonClicked_LoadPlugin()
{
	int nCode = 0;

	/*
	 * 采集回放(媒体播放器)
	 */
	if (sender() == ui->m_btnMediaPlayer)
	{
		nCode = 1;
		QObject*& pPluginObject = m_pPlugin_MediaXPlayer;

		if (nullptr == pPluginObject)
		{
			QPluginLoader* pPluginLoader = new QPluginLoader("./Plugins/Toolkit_MediaX.dll");

			if (pPluginLoader->load())
			{
				std::function<int(int, void*)> OnOntify_Toolkit_MediaX = [this](int nNotifyCode, void* pOwner) -> int
					{
						MainWindow* pThis = reinterpret_cast<MainWindow*>(pOwner);

						//
						pThis->DoNotify(ePluginCode_MediaXPlayer, nNotifyCode);

						return 0;
					};

				pPluginObject = pPluginLoader->instance();

				Toolkit_MediaX* pToolkit = dynamic_cast<Toolkit_MediaX*>(pPluginObject);
				pToolkit->SetGlobalLogger(log_utils::g_logger);
				pToolkit->SetGlobalBus(Bus::g_dataBusInstance);

				pToolkit->InitUi();
				pToolkit->SetOntify(OnOntify_Toolkit_MediaX, this);

				QMainWindow* pPluginWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

				//
				DockPluginWindow(pPluginWindow);
			}
		}
		else
		{
			Toolkit_MediaX* pToolkit = dynamic_cast<Toolkit_MediaX*>(pPluginObject);

			QMainWindow* pPluginWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

			//
			DockPluginWindow(pPluginWindow);
		}
	}

	/*
	 * 系统任务
	 */
	if (sender() == ui->m_btnSystemTask)
	{
		nCode = 2;
		QObject*& pPluginObject = m_pPlugin_SystemTask;     //

		if (nullptr == pPluginObject)
		{
			QPluginLoader* pPluginLoader = new QPluginLoader("./Plugins/Toolkit_Calculator_SystemTask.dll");

			if (pPluginLoader->load())
			{
				std::function<int(int, void*)> OnOntify_Toolkit_SystemTask = [this](int nNotifyCode, void* pOwner) -> int
					{
						MainWindow* pThis = reinterpret_cast<MainWindow*>(pOwner);

						//
						pThis->DoNotify(ePluginCode_Calculator_SystemTask, nNotifyCode);

						return 0;
					};

				pPluginObject = pPluginLoader->instance();

				Toolkit_Calculator_SystemTask* pToolkit = dynamic_cast<Toolkit_Calculator_SystemTask*>(pPluginObject);
				pToolkit->SetGlobalLogger(log_utils::g_logger);
				pToolkit->SetGlobalBus(Bus::g_dataBusInstance);

				pToolkit->InitUi();
				pToolkit->SetOntify(OnOntify_Toolkit_SystemTask, this);

				QMainWindow* pPluginWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

				//
				DockPluginWindow(pPluginWindow);
			}
		}
		else
		{
			Toolkit_Calculator_SystemTask* pToolkit = dynamic_cast<Toolkit_Calculator_SystemTask*>(pPluginObject);

			QMainWindow* pPluginWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

			//
			DockPluginWindow(pPluginWindow);
		}
	}

	/*
	 * 图像质量评估
	 */
	if (sender() == ui->m_btnImageQualityAssessor)
	{
		nCode = 3;
		QObject*& pPluginObject = m_pPlugin_ImageQualityAssessor;

		if (nullptr == pPluginObject)
		{
			QPluginLoader* pPluginLoader = new QPluginLoader("./Plugins/Toolkit_ImageQualityAssessor.dll");

			if (pPluginLoader->load())
			{
				std::function<int(int, void*)> OnOntify_Toolkit_ImageQualityAssesor = [this](int nNotifyCode, void* pOwner) -> int
					{
						MainWindow* pThis = reinterpret_cast<MainWindow*>(pOwner);

						//
						pThis->DoNotify(ePluginCode_ImageQualityAssessor, nNotifyCode);

						return 0;
					};

				pPluginObject = pPluginLoader->instance();

				Toolkit_ImageQualityAssessor* pToolkit = dynamic_cast<Toolkit_ImageQualityAssessor*>(pPluginObject);
				pToolkit->SetGlobalLogger(log_utils::g_logger);
				pToolkit->SetGlobalBus(Bus::g_dataBusInstance);

				pToolkit->InitUi();
				pToolkit->SetOntify(OnOntify_Toolkit_ImageQualityAssesor, this);

				QMainWindow* pPluginWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

				//
				DockPluginWindow(pPluginWindow);
			}
		}
		else
		{
			Toolkit_ImageQualityAssessor* pToolkit = dynamic_cast<Toolkit_ImageQualityAssessor*>(pPluginObject);

			QMainWindow* pPluginWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

			//
			DockPluginWindow(pPluginWindow);
		}
	}

	/*
	 * 通信设置
	 */
	if (sender() == ui->m_btnCommunicationInterface)
	{
		m_CommunicationWgt->show();
	}

	/*
	 * 生产工具(串口控制/网口控制)
	 */
	if (sender() == ui->m_btnComAssist)
	{
		nCode = 5;
		QObject*& pPluginObject = m_pPlugin_ProductSets;

		if (nullptr == m_pPlugin_ProductSets)
		{
			QPluginLoader* pPluginLoader = new QPluginLoader("./Plugins/Toolkit_ProductSets.dll");

			if (pPluginLoader->load())
			{
				std::function<int(int, void*)> OnOntify_Toolkit_ComAssist = [this](int nNotifyCode, void* pOwner) -> int
					{
						MainWindow* pThis = reinterpret_cast<MainWindow*>(pOwner);

						//
						pThis->DoNotify(ePluginCode_ComAssist, nNotifyCode);

						return 0;
					};

				pPluginObject = pPluginLoader->instance();

				Toolkit_ProductSets* pToolkit = dynamic_cast<Toolkit_ProductSets*>(pPluginObject);
				pToolkit->SetGlobalLogger(log_utils::g_logger);
				pToolkit->SetGlobalBus(Bus::g_dataBusInstance);
				pToolkit->SetGlobalSerialportMap(SerialPortTools::SerialPortList);

				pToolkit->InitUi();
				pToolkit->SetOntify(OnOntify_Toolkit_ComAssist, this);
				QMainWindow* pPluginWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

				//
				DockPluginWindow(pPluginWindow);
			}
			else
			{
				QMessageBox msgBox(QMessageBox::Icon::Warning, "提示", "打开插件失败!");
				msgBox.exec();
				return;
			}
		}
		else
		{
			Toolkit_ProductSets* pToolkit = dynamic_cast<Toolkit_ProductSets*>(pPluginObject);

			QMainWindow* pPluginWindow = dynamic_cast<QMainWindow*>(pToolkit->GetWndObject());

			//
			DockPluginWindow(pPluginWindow);
		}
	}
}