#include "pch.h"
#include "ATPControl_Serial_QT.h"

ZZ_ATPControl_Serial_Qt::ZZ_ATPControl_Serial_Qt()
{
	m_pSerialPort = new QSerialPort;
	//connect(m_pSerialPort, &QSerialPort::readyRead, this, &ZZ_ATPControl_Serial_Qt::ReadMessage);
	m_iBaudRate = 115200;
}

ZZ_ATPControl_Serial_Qt::~ZZ_ATPControl_Serial_Qt()
{
	if (m_pSerialPort != NULL)
	{
		delete m_pSerialPort;
	}
	
}

int ZZ_ATPControl_Serial_Qt::SetBaudRate(int iBaud)
{
	m_iBaudRate = iBaud;
	return 0;
}


int ZZ_ATPControl_Serial_Qt::ATPInitialize(ZZ_U8 ucPortNumber)
{
	QString qstrPortName = QString("COM%1").arg(ucPortNumber);

	m_pSerialPort->setPortName(qstrPortName);
	m_pSerialPort->setReadBufferSize(512);
	bool bRes = m_pSerialPort->setBaudRate(m_iBaudRate);
	if (!bRes)
	{
		qDebug() << "Err:setBaudRate Failed.Exit Code:1";
		//std::cout << "Err.setBaudRate Failed" << std::endl;
		return 1;
	}

	bRes = m_pSerialPort->open(QIODevice::ReadWrite);
	if (!bRes)
	{
		qDebug() << "Err:open Failed.Exit Code:2";
		//std::cout << "Err.open Failed" << std::endl;
		return 2;
	}

	return 0;
}

int ZZ_ATPControl_Serial_Qt::ATPClose()
{
	m_pSerialPort->close();

	return 0;
}
int ZZ_ATPControl_Serial_Qt::GetDeviceInfo()
{
	QByteArray qbSend, qbRecv;

	qbSend.clear();
	qbRecv.clear();
	qbSend.append(GET_PN_NUMBER);
	SendCommand(qbSend);
	RecvData(qbRecv);
	ParseData(qbRecv);
	m_adiDeviceInfo.strPN = qbRecv.data();

	qbSend.clear();
	qbRecv.clear();
	qbSend.append(GET_SN_NUMBER);
	SendCommand(qbSend);
	RecvData(qbRecv);
	ParseData(qbRecv);
	m_adiDeviceInfo.strSN = qbRecv.data();


	return 0;
}

int ZZ_ATPControl_Serial_Qt::GetDeviceAttribute()
{
	QByteArray qbSend, qbRecv;

	qbSend.clear();
	qbRecv.clear();
	qbSend.append(GET_MIN_INTEGRATION_TIME);
	SendCommand(qbSend);
	RecvData(qbRecv);
	ParseData(qbRecv);
	m_adaDeviceAttr.iMinIntegrationTime = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;

	qbSend.clear();
	qbRecv.clear();
	qbSend.append(GET_MAX_INTEGRATION_TIME);
	SendCommand(qbSend);
	RecvData(qbRecv);
	ParseData(qbRecv);
	m_adaDeviceAttr.iMaxIntegrationTime = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;


	SetExposureTime(m_adaDeviceAttr.iMinIntegrationTime);
	SingleShot(m_adaDeviceAttr.iPixels);


	qbSend.clear();
	qbRecv.clear();
	qbSend.append(GET_WAVELENGTH_CALIBRATION_COEF);
	qbSend.resize(3);
	qbSend[1] = 0x00;
	qbSend[2] = 0x01;
	SendCommand(qbSend);
	RecvData(qbRecv);
	ParseData(qbRecv);

	float fWaveLengthCoef[4];
	memcpy(fWaveLengthCoef, qbRecv.data()+16, 4 * sizeof(float));
// 	for ()
// 	{
// 	}
	return 0;
}

int ZZ_ATPControl_Serial_Qt::SendCommand(QByteArray qbCommand)
{
	int iSize = qbCommand.size() + 3;
	QByteArray qbSend;
	qbSend.resize(4);
	qbSend[0] = (ZZ_U8)0xAA;
	qbSend[1] = 0x55;
	qbSend[2] = iSize / 256;
	qbSend[3] = iSize % 256;
	qbSend.append(qbCommand);

	int iSum = 0;
	for (int i = 0; i < iSize - 1; i++)
	{
		iSum = iSum + qbSend[i + 2];
	}

	qbSend.append(iSum % 256);

	qint64 qi64Write= m_pSerialPort->write(qbSend);
	if (qi64Write != qbSend.size())
	{
		qDebug() << "Err:write Failed.Exit Code:1";
		return 1;
	}

	return 0;
}

int ZZ_ATPControl_Serial_Qt::RecvData(QByteArray &qbData)
{
	qbData.clear();
	qbData = m_pSerialPort->readAll();

	int iCounter = 0;
	while (qbData.size() < 4)
	{
		m_pSerialPort->waitForReadyRead(50);
		QByteArray qbTemp = m_pSerialPort->readAll();
		qbData.append(qbTemp);

		if (iCounter > 10)
		{
			qDebug() << "Err:RecvData Failed,Not Enough Data.Exit Code:1"<<qbData.size();
			return 1;
		}
		iCounter++;
	}

	if ((ZZ_U8)qbData[0] != (ZZ_U8)0xaa || (ZZ_U8)qbData[1] != (ZZ_U8)0x55)
	{
		qDebug() << "Err:RecvData Failed,Wrong Header.Exit Code:2" << qbData.size();
		return 2;
	}

	iCounter = 0;
	int iLength = qbData[2] * 256 + qbData[3] + 2;
	while (qbData.size() < iLength)
	{
		m_pSerialPort->waitForReadyRead(50);
		qbData.append(m_pSerialPort->readAll());

		if (iCounter > 100)
		{
			qDebug() << "Err:RecvData Failed,Incomplete Data.Exit Code:3" << qbData.size();
			return 3;
		}
		iCounter++;
	}

	if (qbData.size() > iLength)
	{
		qbData.remove(iLength - 1, qbData.size() - iLength);
	}
	int iCheckSumLength = iLength - 3;
	ZZ_U16 usCheckSum = 0;
	for (int i = 0; i < iCheckSumLength; i++)
	{
		usCheckSum += qbData[i+2];
	}
	usCheckSum = usCheckSum % 256;
	ZZ_U8 ucTemp = qbData[qbData.size() - 1];
	if ((ZZ_U8)usCheckSum != ucTemp)
	{
		qDebug() << "Err:RecvData Failed,Incorrect Check Sum.Exit Code:4" << qbData.size();
		qbData.clear();
		return 4;
	}

	return 0;
}

int ZZ_ATPControl_Serial_Qt::ParseData(QByteArray &qbData)
{
	if (qbData.size() < 6)
	{
		qDebug() << "Err:ParseData Failed,Not Enough Data.Exit Code:1" << qbData.size();
		return 1;
	}
	qbData.remove(0, 5);
	qbData.remove(qbData.size() - 1, 1);
	return 0;
}

int ZZ_ATPControl_Serial_Qt::PerformAutoExposure(float fMinScaleFactor, float fMaxScaleFactor, float &fPredictedExposureTime)
{
	return 0;
}

int ZZ_ATPControl_Serial_Qt::SetExtShutter(int iShutterA, int iShutterB)
{
	return 0;
}

int ZZ_ATPControl_Serial_Qt::SetExposureTime(int iExposureTimeInMS)
{
	QByteArray qbExposureTime,qbRecv;
	qbExposureTime.append(SET_INTEGRATION_TIME);
	qbExposureTime.resize(3);
	qbExposureTime[1] = iExposureTimeInMS >> 8;
	qbExposureTime[2] = iExposureTimeInMS & 0xFF;

	SendCommand(qbExposureTime);
	RecvData(qbRecv);
	ParseData(qbRecv);

	if ((ZZ_U8)qbRecv[0] != 0)
	{
		qDebug() << "Err:SetExposureTime Failed.Exit Code:1" ;
		return 1;
	}

	return 0;
}

int ZZ_ATPControl_Serial_Qt::SingleShot(ATPDataFrame &dfData)
{
	QByteArray qbSend, qbRecv;
	qbSend.clear();
	qbRecv.clear();
	qbSend.append(SYNC_GET_DATA);
	qbSend.resize(3);
	qbSend[1] = 0x00;
	qbSend[2] = 0x01;
	SendCommand(qbSend);
	RecvData(qbRecv);
	ParseData(qbRecv);

	if ((ZZ_U8)qbRecv[0] != 0)
	{
		qDebug() << "Err:SingleShot Failed.Exit Code:1";
		return 1;
	}
	else
	{
		int iDataSizeInPixel = (qbRecv.size() - 1) / 2;
		memcpy(dfData.usData, qbRecv.data() + 1, iDataSizeInPixel * 2);
		
	}

	//int isize = qbRecv.size();
	//m_adaDeviceAttr.iPixels = isize / 2;

	return 0;
}

int ZZ_ATPControl_Serial_Qt::SingleShot(int &iPixels)
{
	QByteArray qbSend, qbRecv;
	qbSend.clear();
	qbRecv.clear();
	qbSend.append(SYNC_GET_DATA);
	qbSend.resize(3);
	qbSend[1] = 0x00;
	qbSend[2] = 0x01;
	SendCommand(qbSend);
	RecvData(qbRecv);
	ParseData(qbRecv);

	if ((ZZ_U8)qbRecv[0] != 0)
	{
		qDebug() << "Err:SingleShot Failed.Exit Code:1";
		return 1;
	}
	else
	{
		iPixels = (qbRecv.size() - 1) / 2;

	}
	return 0;
}

//void ZZ_ATPControl_Serial_Qt::ReadMessage()
//{
// 	QByteArray qbTemp, qbTemp1;
// 	qbTemp = m_pSerialPort->readAll();
// 	while (qbTemp.size()<2)
// 	{
// 		m_pSerialPort->waitForReadyRead(50);
// 		qbTemp1 = m_pSerialPort->readAll();
// 		qbTemp.append(qbTemp1);
// 	}



	//return;
	// }