#include "muban.h"
#include <QtUiTools/QUiLoader>
#include "RasterAnalysis.h"
#include "QtWidgets/QGroupBox"
#include "QtWidgets/QTextBrowser"
#include "QtWidgets/QApplication"
#include "QtWidgets/QBoxLayout"
#include "QtWidgets/QLineEdit"
#include "QList"
#include "switchbutton.h"
#include "mychart1.h"
#include "QFile"
#include "QIODevice"
#include "myhelper.h"
#include "QTimer"
#include <QDockWidget>
#include "Raster.h"
#include "QSpinBox"
#include "QtSerialPort/QSerialPortInfo"
#include "QtSerialPort/QSerialPort"
#include "QComboBox"
#include "QPushButton"
#include "QCheckBox"
#include "QLabel"
#include "qfinddevice.h"

#pragma execution_character_set("utf-8")
struct RecvData{
	quint8 data1;
	quint8 data2;
	quint8 data3;
	quint8 data4;
	quint8 data5;
	quint8 data6;
	quint8 data7;
	quint8 data8;
};

muban::muban(QWidget *parent) :QWidget(parent), m_pRasterCom(NULL), m_pRaster(NULL), bInsertData(false), m_graph1(NULL)
{
	ui.setupUi(this);

	initUI();

	Rasteranalysis = new QRasterAnalysis();
	Rasteranalysis->loadAnalyseUpdatefunc(this, &muban::Appanalysis);
	connect(this, SIGNAL(recvDataSignal(QByteArray)), Rasteranalysis, SLOT(recvDataByCOM(QByteArray)));

	/*类内部的信号和槽自个绑定 各有各的功能*/
	m_timer = new QTimer();
	m_timerChackSys = new QTimer();
	connect(m_timer, SIGNAL(timeout()), this, SLOT(onTimer()));
	connect(m_timerChackSys, SIGNAL(timeout()), this, SLOT(onTimerCheckSys()));
	connect(this, SIGNAL(sgShowSys(QString,int)), this, SLOT(onShowSys(QString,int)));
	connect(this, SIGNAL(sgShowValue(int)), this, SLOT(onShowValue(int)));
	connect(this, SIGNAL(sgShowMsgLabel(int, int)), this, SLOT(onShowMsgLabel(int, int)));

	connect(this, SIGNAL(sgThress(int)), this, SLOT(onAddData2Graph(int)));
	onScanDevice();

}

muban::~muban()
{
	if (m_timer){
		m_timer->stop();
		delete m_timer;
		m_timer = NULL;
	}
	if (m_timerChackSys)
	{
		m_timerChackSys->stop();
		delete m_timerChackSys;
		m_timerChackSys = NULL;
	}
	
	if (m_switchbp)
	{
		delete m_switchbp;
		m_switchbp = NULL;
	}

	if (m_switsybp)
	{
		delete m_switsybp;
		m_switsybp = NULL;
	}

	if (m_graph1)
	{
		delete m_graph1;
		m_graph1 = NULL;
	}
	if (m_chart){
		delete m_chart;
		m_chart = NULL;
	}
	if (Rasteranalysis){
		delete Rasteranalysis;
		Rasteranalysis = NULL;
	}
}

void muban::Appanalysis(Raster_ComFrame m_ComFrame){
	RecvData m_RecvData;
	memset(&m_RecvData, 0, sizeof(RecvData));
	memcpy(&m_RecvData, m_ComFrame.pData, m_ComFrame.len);
	switch (m_ComFrame.cmd)
	{
	case 0x64:
		m_RecvData.data1 = 1;
		break;
	case 0x66:
	{
		QString str;
		str += tr("发送器光束数:%1\n").arg(m_RecvData.data1);
		str += tr("发送器故障通道位置:%1\n").arg(m_RecvData.data2);
		str += tr("接收器光束数:%1\n").arg(m_RecvData.data3);
		str += tr("接收器故障通道位置:%1\n").arg(m_RecvData.data4);
		str += getSysState(m_RecvData.data5);
		emit(sgShowSys(str, m_RecvData.data5));
		
	}
		break;
	case 0x67:
	{
		emit(sgThress((m_RecvData.data4 * 255 + m_RecvData.data3)));//发送光栅数据

		emit(sgShowValue(63-(m_RecvData.data4 * 255 + m_RecvData.data3)));//显示光栅数据
		if (bInsertData)
		{
			emit(sgShowMsgLabel(m_RecvData.data4 * 255 + m_RecvData.data3, 1));
			emit(sgShowMsgLabel(63 - (m_RecvData.data4 * 255 + m_RecvData.data3), 2));
			emit(sgShowMsgLabel(m_RecvData.data2 * 255 + m_RecvData.data1, 3));
		}

		//Raster_ShowlineEdit->setText(QString::number());
		//Raster_ShowlineEdit_2->setText(QString::number());
		//Raster_ShowlineEdit_3->setText(QString::number());
	}
		break;
	default:
		break;
	}
}

void muban::SlotRecvDataByParent(QByteArray m_data)
{
	emit(recvDataSignal(m_data));
}

void muban::SlotRxNumByParent(int num)
{

}

void muban::SlotTxNumByParent(int num)
{

}

void muban::SlotRxSizeByParent(int num)
{

}

void muban::SlotTxSizeByParent(int num)
{

}

void muban::SlotGetPosByParent(QPoint point)
{

}

void muban::SlotTxDataByParent(QByteArray m_data)
{

}

void muban::initUI()
{
	//connect(ui.Raster_SendData, SIGNAL(clicked()), this, SLOT(ButtonClick()));
	Raster_ShowlineEdit = ui.Raster_ShowlineEdit;
	Raster_ShowlineEdit_2 = ui.Raster_ShowlineEdit_2;
	Raster_ShowlineEdit_3 = ui.Raster_ShowlineEdit_3;
	QGroupBox *pGroup = ui.groupBox_2;
	QHBoxLayout *pGridLayout = new QHBoxLayout;
	m_switchbp = new SWitchButton;
	//m_switchbp->resize(150, 100);
	//m_switchbp->setFixedHeight(50);
	m_switchbp->SetOffName(tr("停止采样"));
	m_switchbp->SetOnName(tr("开始采样"));
	m_switchbp->SetPressOffBkColor1(QColor(230, 10, 10));
	m_switchbp->SetPressOffBkColor2(QColor(230, 10, 10));
	m_switchbp->SetPressOnBkColor1(QColor(46, 183, 67));
	m_switchbp->SetPressOnBkColor2(QColor(46, 183, 67));
	m_switchbp->setObjectName("switchBP1");
	m_switchbp->SetSwitchState(1);
	connect(m_switchbp, SIGNAL(onStateChanged(int)), this, SLOT(onButtonClick(int)));
	pGroup->setLayout(pGridLayout);
	//pGroup->setFixedHeight(50);
	pGridLayout->addWidget(m_switchbp);
	pGridLayout->addSpacing(1);


	Raster_textBrowser = ui.Raster_textBrowser;
	
	Raster_frame = ui.Raster_frame;
	QSize ht = Raster_frame->size();
	QRect a= Raster_frame->rect();
	m_chart = new myChart1(Raster_frame);
	m_chart->setTitle(tr("光栅数据采样"));

	{
		QGroupBox *pGroup = ui.Raster_groupBoxSys;
		QHBoxLayout *pGridLayout = new QHBoxLayout;
		m_switsybp = new SWitchButton;
		m_switsybp->resize(150, 50);
		m_switsybp->SetOffName(tr("停止查询"));
		m_switsybp->SetOnName(tr("5s定时查询"));
		m_switsybp->SetPressOffBkColor1(QColor(200, 10, 10));
		m_switsybp->SetPressOffBkColor2(QColor(200, 10, 10));
		m_switsybp->SetPressOnBkColor1(QColor(46, 150, 67));
		m_switsybp->SetPressOnBkColor2(QColor(46, 150, 67));
		m_switsybp->setObjectName("switchBP2");
		m_switsybp->SetSwitchState(1);
		connect(m_switsybp, SIGNAL(onStateChanged(int)), this, SLOT(onButtonClick(int)));
		pGroup->setLayout(pGridLayout);
		//pGroup->setFixedHeight(1);
		pGridLayout->addWidget(m_switsybp);
		pGridLayout->addSpacing(1);
	}
	doubleSpinBox_beilv = ui.doubleSpinBox_beilv;
	doubleSpinBox_baseheight = ui.doubleSpinBox_baseheight;
	doubleSpinBox_min = ui.doubleSpinBox_min;
	
	connect(ui.Raster_SaveRaster, SIGNAL(clicked()), this, SLOT(onSaveData()));
	
//串口扫描按钮
	connect(ui.Raster_ResScan, SIGNAL(clicked()), this, SLOT(onScanDevice()));
	
//串口名
	Raster_ComBox = ui.Raster_ComBox;
	
//波特率
	Raster_Baute = ui.Raster_Baute;
	Raster_Baute->addItem("115200");
	Raster_Baute->addItem("38400");
	Raster_Baute->addItem("19200");
	Raster_Baute->addItem("9600");
	
// 打开设备
	Raster_OpenDevice = ui.Raster_OpenDevice;
	connect(Raster_OpenDevice, SIGNAL(clicked()), this, SLOT(onCtrolDevice()));
	
//关闭设备
	Raster_CloseDevice = ui.Raster_CloseDevice;
	connect(Raster_CloseDevice, SIGNAL(clicked()), this, SLOT(onCtrolDevice()));
	

	connect(ui.Raster_SaveCombp, SIGNAL(clicked()), this, SLOT(onSaveData()));

	Raster_checkBox = ui.Raster_checkBox;
	

	Raster_showState_lb = ui.Raster_showState_lb;
	

	SpinBox_max_size = ui.spinBox_maxsize;
	

	doubleSpinBox_mid_value = ui.doubleSpinBox_mid_value;
	

	m_tabWidget = ui.tabWidget;
	m_tabWidget->setCurrentIndex(10);
	

	Raster_doubleSpinBox_B = ui.Raster_doubleSpinBox_B;

	Raster_doubleSpinBox_K = ui.Raster_doubleSpinBox_K;

	QPushButton *pBb = ui.Raster_SaveRasterDire;
	connect(pBb, SIGNAL(clicked()), this, SLOT(onSaveData()));

	QFrame *pFrame = ui.Raster_frame_2;
	QGridLayout *pLayout = new QGridLayout;
	m_graph1 = new QSimpleTickerGraph(pFrame);

	m_graph1->setUnits("mm");
	m_graph1->setRange(0, 300);
	m_graph1->setPointWidth(5);
	m_graph1->setBackgroundBrush(QBrush(QColor(15, 10, 10)));
	m_graph1->setDataLinePen(QPen(QColor(255, 255, 255), 1));
	m_graph1->setGridPitch(100);
	m_graph1->setReferencePoints(QList<double>() << 10);

	pLayout->addWidget(m_graph1);
	pFrame->setLayout(pLayout);
}

void muban::changeEvent(QEvent *event)
{
	int a = 0;
}
QString muban::getSysState(quint8 nValue)
{
	QString str;
	switch (nValue)
	{
	case 0:
		str = tr("系统工作正常");
		break;
	case 1:
		str = tr("系统检测到对准不良");
		break;
	case 2:
		str = tr("输入电源电压偏高");
		break;
	case 3:
		str = tr("输入电源电压偏低");
		break;
	case 4:
		str = tr("同步丢失，发送单元没接");
		break;
	case 5:
		str = tr("系统内部出错");
		break;
	default:
		break;
	}
	return str;
}

Q_SLOT void muban::ButtonClick()
{
	QObject *watchObj = sender();
	QString strObj = watchObj->objectName();
	if (strObj == "Raster_SendData"){
		QByteArray m_sendData;
		QString strSend = "F4 41 67 00 63 FE ";//查询光栅值 
		m_sendData.append(MyHelper::QString2Hex(strSend));
		emit (SignalByteData2Parent(m_sendData));
	}
	else if (strObj == "Raster_CheckSys"){
		QByteArray m_sendData;
		QString strSend = "F4 41 66 00 64 FE ";//查询光栅系统状态 
		m_sendData.append(MyHelper::QString2Hex(strSend));
		emit(SignalByteData2Parent(m_sendData));
	}
}

Q_SLOT void muban::onTimer()
{
	QByteArray m_sendData;
	QString strSend = "F4 41 67 00 63 FE ";
	m_sendData.append(MyHelper::QString2Hex(strSend));

	emit(SignalByteData2Parent(m_sendData));
}

Q_SLOT void muban::onButtonClick(int state)
{
	QObject *obj = sender();
	QString strName = obj->objectName();
	if (strName == "switchBP1"){
		if (state == 1){
			m_timer->stop();
		}
		else
		{
			m_timer->start(100);
		}
	}
	else if (strName == "switchBP2"){
		if (state == 1){
			m_timerChackSys->stop();
		}
		else
		{
			m_timerChackSys->start(5000);
		}
	}
}

Q_SLOT void muban::onShowSys(QString str,int value)
{
	Raster_textBrowser->clear();
	if (Raster_textBrowser){
		if (value == 0)
		{
			Raster_textBrowser->setTextColor(QColor(16, 67, 24));
		}
		else
		{
			Raster_textBrowser->setTextColor(QColor(255, 0, 0));
		}
		Raster_textBrowser->append(str);
	}
}

Q_SLOT void muban::onShowValue(int value)
{
	if (bInsertData)
	{	
		if (!m_tabWidget)
		{
			return;
		}
		if (m_tabWidget->currentIndex() == 0)
			m_chart->addData(value);
		else
			m_chart->clearVec();
	}
}

Q_SLOT void muban::onTimerCheckSys()
{
	QByteArray m_sendData;
	QString strSend = "F4 41 66 00 64 FE ";//查询光栅系统状态 
	m_sendData.append(MyHelper::QString2Hex(strSend));
	emit(SignalByteData2Parent(m_sendData));
}

void muban::onStartSampling()
{
	m_timer->start(100);
	m_switchbp->SetSwitchState(0);
}

void muban::onStopSampling()
{
	m_timer->stop();
	m_switchbp->SetSwitchState(1);
}

void muban::SetData2UI(RasterST *m_rastdata)
{
	if (m_rastdata == NULL)
		return;
	m_pRaster = m_rastdata;
	doubleSpinBox_beilv->setValue(m_rastdata->m_beilv);
	doubleSpinBox_min->setValue(m_rastdata->m_lowNum);
 	doubleSpinBox_baseheight->setValue(m_rastdata->m_baseHight);
	doubleSpinBox_mid_value->setValue(m_pRaster->mid_value);
	SpinBox_max_size->setValue(m_pRaster->m_maxsize);
 	if (m_rastdata->m_bool_beilv == false)
 		doubleSpinBox_beilv->setDisabled(true);
 	if (m_rastdata->m_bool_baseHight == false)
 		doubleSpinBox_baseheight->setDisabled(true);
 	if (m_rastdata->m_bool_maxsize == false)
 		SpinBox_max_size->setDisabled(true);
	if (m_rastdata->m_bool_lowNum == false)
		doubleSpinBox_min->setDisabled(true);
	if (m_rastdata->m_bool_mid_value == false)
		doubleSpinBox_mid_value->setDisabled(true);
}

void muban::SetData2UI(RasterCom *m_rastdata)
{
	if (m_rastdata == NULL)
		return;
	m_pRasterCom = m_rastdata;
	Raster_ComBox->setCurrentText(m_rastdata->m_ComName);
	Raster_Baute->setCurrentText(m_pRasterCom->m_Baute);
	Raster_checkBox->setChecked(m_pRasterCom->m_UseRaster);
}

void muban::GetDataFromUI(RasterST *m_rastdata)
{
	if (m_rastdata == NULL)
		return;
 	m_rastdata->m_beilv = doubleSpinBox_beilv->value();
 	m_rastdata->m_lowNum = doubleSpinBox_min->value();
 	m_rastdata->m_baseHight = doubleSpinBox_baseheight->value();
	m_rastdata->mid_value = doubleSpinBox_mid_value->value();
	m_rastdata->m_maxsize = SpinBox_max_size->value();
}

void muban::GetDataFromUI(RasterCom *m_rastdata)
{
	if (m_rastdata == NULL)
		return;
	m_rastdata->m_ComName = Raster_ComBox->currentText();
	m_rastdata->m_Baute = Raster_Baute->currentText();
	m_rastdata->m_UseRaster = (Raster_checkBox->checkState() == Qt::Checked ? true : false);
}

Q_SLOT void muban::onSaveData()
{
	QString strObj = sender()->objectName();
	if (strObj == "Raster_SaveRaster"){
		GetDataFromUI(m_pRaster);
		emit(sgSaveData(int(EMTYPE_RASTER)));
	}
	else if (strObj == "Raster_SaveCombp"){
		GetDataFromUI(m_pRasterCom);
		emit(sgSaveData(int(EMTYPE_COM)));
	}
	else if ("Raster_SaveRasterDire" == strObj)
	{
		float mK = 0, mB = 0;
		if (Raster_doubleSpinBox_B)
			mB = Raster_doubleSpinBox_B->value();
		if (Raster_doubleSpinBox_K)
			mK = Raster_doubleSpinBox_K->value();
		if (setfunc_)
		{
			Dia2ThPara st;
			st.mb_ = mB;
			st.mk_ = mK;
			setfunc_(st);
		}
	}
}

Q_SLOT void muban::onScanDevice()
{/*扫描所有串口设备*/
	Raster_ComBox->clear();//清空

	QFindDevice *workerThread = new QFindDevice(this);
	connect(workerThread, &QFindDevice::resultReady, this, &muban::onRecvThread);
	connect(workerThread, &QFindDevice::finished, workerThread, &QObject::deleteLater);
	workerThread->start();

// 	foreach(const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
// 	{
// 		QSerialPort serial;
// 		serial.setPort(info);
// 		{
// 			QString comportInfo = info.portName();
// 			Raster_ComBox->addItem(comportInfo);
// 			serial.close();
// 		}
// 	}
// 	if (m_pRasterCom)
// 		Raster_ComBox->setCurrentText(m_pRasterCom->m_ComName);
}
Q_SLOT void muban::onRecvThread(const QStringList &s)
{
	if (Raster_ComBox)
		Raster_ComBox->addItems(s);
	if (m_pRasterCom)
		Raster_ComBox->setCurrentText(m_pRasterCom->m_ComName);
}
Q_SLOT void muban::onShowComState(QString str, int bValue)
{
	QPalette m_plate;
	if (bValue == (int)EMTYPE_OPENCOM){
		Raster_OpenDevice->setDisabled(true);
		Raster_CloseDevice->setDisabled(false);
		m_plate.setColor(QPalette::WindowText, QColor(55, 150, 20));
	}
	else if(bValue == (int)EMTYPE_CLOSECOM || bValue == (int)EMTYPE_OPENERROR||bValue==(int)EMTYPE_NOOPEN)
	{
		Raster_OpenDevice->setDisabled(false);
		Raster_CloseDevice->setDisabled(true);
		m_plate.setColor(QPalette::WindowText, QColor(205, 50, 20));
	}
	else {
		m_plate.setColor(QPalette::WindowText, QColor(205, 50, 20));
	}
	if (Raster_showState_lb)
	{
		Raster_showState_lb->setText(str);
		Raster_showState_lb->setPalette(m_plate);
	}
}

Q_SLOT void muban::onCtrolDevice()
{
	QString strObj = sender()->objectName();
	if (strObj == "Raster_OpenDevice"){
		GetDataFromUI(m_pRasterCom);
		Raster_OpenDevice->setDisabled(true);
		Raster_CloseDevice->setDisabled(false);
		emit(sgCtrolDevice(int(EMTYPE_OPENCOM)));
	}
	else if (strObj == "Raster_CloseDevice"){
		emit(sgCtrolDevice(int(EMTYPE_CLOSECOM)));
		Raster_OpenDevice->setDisabled(false);
		Raster_CloseDevice->setDisabled(true);
	}
}

Q_SLOT void muban::onShowThrenss(QString)
{
	int a = 0;
}

Q_SLOT void muban::onShowMsgLabel(int nData, int nType)
{
	switch (nType){
	case  1:
		Raster_ShowlineEdit->setText(QString::number(nData));
		break;
	case 2:
		Raster_ShowlineEdit_2->setText(QString::number(nData));
		break;
	case 3:
		Raster_ShowlineEdit_3->setText(QString::number(nData));
		break;
	default:  
		break;
	}
}

void muban::closeEvent(QCloseEvent *event)
{
	bInsertData = false;
}

void muban::showEvent(QShowEvent *event)
{
	int a = 0;
	bInsertData = true;
	if (getfunc_)
	{
		Dia2ThPara st = getfunc_();
		float mB= st.mb_, mK=st.mk_;
		if (Raster_doubleSpinBox_B)
		{
			Raster_doubleSpinBox_B->setValue(mB);
		}
		if (Raster_doubleSpinBox_K)
		{
			Raster_doubleSpinBox_K->setValue(mK);
		}
	}
}

Q_SLOT void muban::onAddData2Graph(int nData)
{
	if (m_graph1&&bInsertData&&m_pRaster)
	{
		double dThickness = (63 - nData) * m_pRaster->m_beilv*1.0;//获取光栅数据 乘以 倍率 得出遮挡的厚度
		double dValue = dThickness + m_pRaster->m_baseHight;
		m_graph1->appendPoint(dValue);
	}
}