#include "WheelCtrl.h"
#include "ChannelInfo.h"
#include "ModelManager.h"
#include "DetectState.h"
#include "Result2Ui.h"
#include "InfoFile.h"
#include <QFile>
#include "WheelNet.h"
#include "timemgrctrl.h"
#include "QDebug"
#include "CamConfig.h"
#include "QThread"
#include "qsaveresult.h"

#include "QLibrary"
#include "databasesql.h"
#include "DetectDataDB.h"
#include "ComConfig.h"
#include "HubBase.h"
#pragma execution_character_set("utf-8")
#define _QSQLITE_WHEELHUBWF_NAME    "wheelhubwf.db"
WheelCtrl::WheelCtrl(QString strPath, QMySplashScreen* pScreen)
	: m_strPath(strPath)
{
	qRegisterMetaType<Result2Ui*>("Result2Ui*");
	QString strChannelPath = strPath + "\\user\\channels.json.dat";
	hubBase::mkdir(strPath + "\\user\\");
	ShowInitMsg(pScreen, tr("加载通道模块 ...."));
	m_pChannel = new CChannelInfo(strChannelPath, pScreen);
	ShowInitMsg(pScreen, tr("加载模板库 ...."));
	m_pModelMgr = new ModelManager(strPath);
	m_pModelMgr->init();
	ShowInitMsg(pScreen, tr("加载检测设置模块 ...."));

	DetectState::instance()->init(strPath);
	QString strDbPath = strPath + "\\" + _QSQLITE_WHEELHUBWF_NAME;
	ShowInitMsg(pScreen, tr("加载数据库 ...."));
	m_db = new DetectDataDB(strDbPath);
	((DetectDataDB*)m_db)->InitDatabase();
	ShowInitMsg(pScreen, tr("加载班次管理模块 ...."));
	m_pTimeMgr = new TimeMgrCtrl((DetectDataDB*)m_db);
	m_pNet = new CWheelNet(strPath);
	ShowInitMsg(pScreen, tr("加载其他模块 ...."));
	m_pCamConfig = new CamConfig(strPath);
	m_pComConfig = new ComConfig(m_strPath);

	ShowInitMsg(pScreen, tr("创建子线程 ...."));
	saveResultThread = new QThread(this);
	QSaveResult *pSaveResult = new QSaveResult;
	pSaveResult->setDBPtr((DetectDataDB*)m_db, m_pChannel);
	pSaveResult->moveToThread(saveResultThread);
	pSaveResult->setAppRootPath(strPath);

	ShowInitMsg(pScreen, tr("加载光栅通讯模块 ...."));
	qDebug() << "loadLibRasterSDG20";
	loadLibRasterSDG20(strPath);
	qDebug() << "loadLibRasterSDG20 end";
	connect(saveResultThread, &QThread::finished, pSaveResult, &QObject::deleteLater);
	connect(this, SIGNAL(operate(Result2Ui*)), pSaveResult, SLOT(doWork(Result2Ui*)),Qt::QueuedConnection);
	connect(pSaveResult, SIGNAL(resultReady(Result2Ui *)), this, SLOT(handleResult(Result2Ui *)));
	//connect(saveResultThread, SIGNAL(started()), pSaveResult, SLOT(doTest()));
	saveResultThread->start();
	qDebug() << "start thread saveResultThread";
	ShowInitMsg(pScreen, tr("模块加载完成，启动线程 ...."));
}

WheelCtrl::~WheelCtrl()
{
	delete m_pChannel;
	delete m_pModelMgr;
	delete m_db;
	delete m_pComConfig;
	delete m_pCamConfig;
	m_db = NULL;
	delete m_pTimeMgr;
	delete m_pNet;
	m_pNet = NULL;
	m_pTimeMgr = NULL;
	m_pChannel = NULL;
	m_pModelMgr = NULL;
	m_pComConfig = NULL;
	m_pCamConfig = NULL;
	if (saveResultThread){
		qDebug() << "delete saveResultThread";
		if (saveResultThread->isRunning())
		{
			saveResultThread->quit();
		}
		saveResultThread->wait(50);
		delete saveResultThread;
		saveResultThread = NULL;
		qDebug() << "delete saveResultThread end";
	}
	if (m_pRasterSDG20){
		delete m_pRasterSDG20;
		m_pRasterSDG20 = NULL;
	}
}

void WheelCtrl::loadLibRasterSDG20(QString strPath)
{
#ifdef _DEBUG
	QLibrary lib("RasterSDG20d");
#else
	QLibrary lib("RasterSDG20");
#endif
	if (lib.load()){
		_RasterSDG20Create func = (_RasterSDG20Create)lib.resolve("RasterSDG20Create");
		m_pRasterSDG20 = func(strPath + "\\raster.json");
		GetDiaParaFunc getfunc = std::bind(&WheelCtrl::getDiaParam, this);
		m_pRasterSDG20->setGetDiaParaFunc(getfunc);
		SetDiaParaFunc setfunc = std::bind(&WheelCtrl::setDiaParam, this, std::placeholders::_1);
		m_pRasterSDG20->setSetDiaParaFunc(setfunc);
		m_pRasterSDG20->onStartSampling();
	}
}

ModelManager * WheelCtrl::getModelMgr() const
{
	return m_pModelMgr;
}

CChannelInfo * WheelCtrl::getChannelInfo() const
{
	return m_pChannel;
}

QString WheelCtrl::getThicknessStr() const
{
	if (m_pRasterSDG20)
		return m_pRasterSDG20->getThicknessValueStr();
	else
		return QString();
}
double WheelCtrl::getThickness() const
{
	if (m_pRasterSDG20)
		return m_pRasterSDG20->getThicknessValue();
	else
		return 0;
}

void WheelCtrl::appendThicknessValue(double nValue)
{
	if (m_pRasterSDG20)
		m_pRasterSDG20->addThicknessValue(nValue);
}

QString WheelCtrl::appRoot() const
{
	return m_strPath;
}

void WheelCtrl::addLog(QString msg, int nType)
{
	WarnMessage m_warning;
	m_warning.m_Date = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
	m_warning.m_Message = msg;
	m_warning.m_class = QString::number(nType);
	if (m_db)
		m_db->AddOneWarningMessage(m_warning);
}

void WheelCtrl::saveResult(Result2Ui *m_Res)
{
	Result2Ui* pRes = new Result2Ui();
	*pRes = *m_Res;
	emit(operate(pRes));//启动线程保存检测结果
}
DataBaseSql *WheelCtrl::getDB() const
{
	return m_db;
}

TimeMgrCtrl * WheelCtrl::getTimeMgr() const
{
	return m_pTimeMgr;
}

bool WheelCtrl::onStart()
{
	/*把检测的库信息按照对应的序号插入map中并发送至PLC*/
	m_pNet->sendLight(1, 3, 1000, 500);//黄灯
	m_pNet->sendLight(0, 3, 1000, 500);//红灯
	m_pNet->sendLight(2, 3, 1000, 500);//绿灯
	//m_pNet->sendLight(3, 3, 1000, 500);//蜂鸣
	return true;
}

bool WheelCtrl::onFinish()
{
	m_pNet->sendLight(2, 2, 1000, 400);
	m_pNet->sendLight(0, 2, 1000, 400);
	m_pNet->sendLight(1, 2, 1000, 400);
	//m_pNet->sendLight(3, 3, 1000, 400);//蜂鸣
	return true;
}

/*统计清零*/
bool WheelCtrl::onClear()
{
	DetectState::instance()->totalDetectNum = 0;
	DetectState::instance()->totalUnDetectNum = 0;
	getModelMgr()->ClearAllCount();
	return true;
}

IWheelModel * WheelCtrl::getModel(QString str)
{
	return m_pModelMgr->getModel(str);
}

QMap<QString, IWheelModel*>* WheelCtrl::getAllModelMapPtr()
{
	return m_pModelMgr->getAllModelMapPtr();
}

QString WheelCtrl::getUserName() const
{
// 	QString name, lev;
// 	m_pCallBack->IGetUserInfo(name, lev);
// 	if (name.isEmpty()) {
// 		return "无用户";
// 	}
	if (m_currentUserName.isEmpty())
		return tr("未登录");
	return m_currentUserName;
}

int WheelCtrl::getUserLevel() const
{
// 	QString name, lev;
// 	m_pCallBack->IGetUserInfo(name, lev);
// 	int nLevel = lev.toInt();
// 	if (nLevel < 0 || name.isEmpty() || nLevel > 9) {
// 		nLevel = 9;
// 	}
	return m_level;
}

void WheelCtrl::setUser(QString strName, int nlevel)
{
	m_currentUserName = strName;
	m_level = nlevel;
}


QString WheelCtrl::getCurrentBan() const
{
	if (m_pTimeMgr)
		return m_pTimeMgr->GetCurrentBan();
	else
		return QString();
}

bool WheelCtrl::sendModelLib()
{
	if (m_pNet)
		m_pNet->sendClearLib();
	return true;
}

CamConfig * WheelCtrl::getCamConfig() const
{
	return m_pCamConfig;
}

Q_SLOT void WheelCtrl::handleResult(Result2Ui *pResult)
{
	delete pResult;
	pResult = NULL;
	qDebug() << "end thread save Result to DataBase";
}

bool WheelCtrl::onShowRaster(QWidget* parent)
{
	if (m_pRasterSDG20){
		m_pRasterSDG20->onShowWidget(parent);
		return true;
	}
	return false;
}

QStringList WheelCtrl::getAllModelName()
{
	return m_pModelMgr->getAllModelName();
}

QStringList WheelCtrl::getAllTrainModelName()
{
	return m_pModelMgr->getAllTrainModelName();
}

QMap<QString, TimeStruct>* WheelCtrl::getAllTimePtr() const
{
	return m_pTimeMgr->getAllTimePtr();
}

ComConfig * WheelCtrl::getComConfig() const
{
	return m_pComConfig;
}

void WheelCtrl::ShowInitMsg(QMySplashScreen* p, QString str){
	if (p){
		p->ShowMsg(str);
	}
}

void WheelCtrl::setDiaParam(Dia2ThPara st)
{
	DetectState::instance()->setDia2ThPara(st.mk_, st.mb_);
	DetectState::instance()->save();
}
Dia2ThPara WheelCtrl::getDiaParam()
{
	Dia2ThPara st;
	DetectState::instance()->getDia2ThPara(st.mk_, st.mb_);
	return st;
}