#include "ModelManager.h"
#include "TempImage.h"
#include "HubBase.h"
#include "WheelModel.h"
#include "modelmgrdb.h"
#include <QFile>
#include <QJsonDocument>

#define WHEEL_MODEL_FILE   "\\user\\model.json"
#define WHEEL_DB_FILE      "\\pattern\\modelTemplate.db"
#pragma execution_character_set("utf-8")
ModelManager::ModelManager(QString strRoot)
	: m_strRoot(strRoot)
{
	hubBase::mkdir(m_strRoot + "\\pattern\\");
	hubBase::mkdir(m_strRoot + "\\pattern\\template\\");
	hubBase::mkdir(m_strRoot + "\\pattern\\Models\\");
	m_pModelDB = new ModelMgrDB(strRoot + WHEEL_DB_FILE);
}

ModelManager::~ModelManager()
{
	m_pModelDB->closeDB();
	delete m_pModelDB;
	m_pModelDB = NULL;
	foreach(IWheelModel* p, m_mpModels){
		if (p){
			delete p;
			p = NULL;
		}
	}
	m_mpModels.clear();
}

IWheelModel * ModelManager::getModel(QString str)
{
	return m_mpModels.value(str);
}

QMap<QString, IWheelModel*> ModelManager::getDetectModelMap()
{
	QMap<QString, IWheelModel*> mps;
	for each (IWheelModel* var in m_mpModels) {
		if (var->getDetectState()) {
			mps.insert(var->getModelID(), var);
		}
	}
	return mps;
}

QStringList ModelManager::getDetectModelName()
{
	QStringList lst;
	for each (IWheelModel* var in m_mpModels) {
		if (var->getDetectState()){
			lst.append(var->getModelID());
		}
	}
	return lst;
}
bool ModelManager::ClearAllCount()
{
	for each (IWheelModel* var in m_mpModels) {
		var->clearCount();
	}
	return true;
}
bool ModelManager::addModel(QString str)
{
	if (m_mpModels.contains(str)) {
		return false;
	}
	IWheelModel *pModel = new WheelModel;
	m_mpModels.insert(str, pModel);

	QVariantMap map = genDbMap(pModel);
	m_pModelDB->addData(map);

	//通知界面（统计）
	//（listview）
	//UpdateListView
	return true;
}

bool ModelManager::addModel(IWheelModel *pModel)
{
	if (pModel == NULL)
		return false;
	
	if (m_mpModels.contains(pModel->getModelID()))
		return false;
	m_mpModels.insert(pModel->getModelID(), pModel);
	QVariantMap map = genDbMap(pModel);
	m_pModelDB->addData(map);
	return true;
}

bool ModelManager::init()
{
	if (!m_pModelDB) {
		return false;
	}
	if (!m_pModelDB->InitDatabase()) {
		return false;
	}
	bool bFlag = m_pModelDB->ReadOutData(m_mpModels);
	if (!m_mpModels.contains("NG"))
	{
		IWheelModel* pModel = new WheelModel();
		pModel->setModelID("NG");
		pModel->setDiameter(0);
		pModel->setDetectState(true);
		pModel->setThickness(0);
		m_mpModels.insert("NG", pModel);
		//addModel()
	}
	QJsonObject obj = readJson(m_strRoot + WHEEL_MODEL_FILE);
	for each (IWheelModel* var in m_mpModels) {
		WheelModel *pModel = (WheelModel*)var;
		pModel->initTmpImage(m_strRoot + "\\pattern\\");
		pModel->initComModel(m_strRoot + "\\pattern\\");
		pModel->readJson(&obj);
	}
	return true;
}

bool ModelManager::modModel(QString str)
{
	IWheelModel *pModel = m_mpModels.value(str);
	if (!pModel) {
		return false;
	}
	QVariantMap map = genDbMap(pModel);;
	return m_pModelDB->UpdateModelData(pModel->getModelID(), map);
}

QVariantMap ModelManager::genDbMap(IWheelModel *pModel)
{
	QVariantMap vMap;
	vMap.insert(_MD_MODEL, pModel->getModelID());//model 模型名称
	vMap.insert(_MD_DIAMETER, pModel->getDiameter());//直径
	vMap.insert(_MD_HIGHT, pModel->getThickness());//高度
	vMap.insert(_MD_PICPATH, pModel->getPicPath());
	vMap.insert(_MD_ROTATE, pModel->getRepeatNum());
	return vMap;
}

bool ModelManager::delModel(QString str)
{
	bool bFlag = m_pModelDB->DeleteModelData(str);
	IWheelModel *pModel = m_mpModels.take(str);
	if (pModel) {
		delete pModel;
		pModel = NULL;
	}
	QString strSave = m_strRoot + "\\pattern\\template\\" + str + "\\";
	hubBase::deleteDirectory(strSave);
	QString strfilw = m_strRoot + "\\pattern\\Models\\" + str + ".jpg";
	hubBase::removeFile(strfilw);
	return true;
}

QStringList ModelManager::getAllModelName()
{
	return m_mpModels.keys();
}

//得到所有加入训练的模板名
QStringList ModelManager::getAllTrainModelName()
{
	QStringList allTrainModelNameList;
	for each (IWheelModel* var in m_mpModels) 
	{
		if (var->getAddTrainFlag()) {
			allTrainModelNameList.append(var->getModelID());
		}
	}
	return allTrainModelNameList;
}

TempImage * ModelManager::getTmpImage(QString str)
{
	if (!m_mpModels.contains(str)) {
		return NULL;
	}

	return m_mpModels.value(str)->getTempImage();
}

TempImage * ModelManager::getTrainImage(QString str)
{
	if (!m_mpModels.contains(str)) {
		return NULL;
	}
	IWheelModel *pMode = m_mpModels.value(str);
	if (pMode->getAddTrainFlag() == false)
	{
		return NULL;
	}
	return m_mpModels.value(str)->getTempImage();
}

QMap<QString, std::vector<cv::Mat>> ModelManager::getAllModelImage()
{
	QMap<QString, std::vector<cv::Mat>> mpAllImage;
	QStringList lst = getAllModelName();
	for (int i = 0; i < lst.size(); i++) {
		TempImage *pImg = getTrainImage(lst.at(i));
		if (pImg) {
			mpAllImage.insert(lst.at(i), pImg->getImgVector());
		}
	}
	return mpAllImage;
}

QMap<QString, IWheelModel*> * ModelManager::getAllModelMapPtr()
{
	return &m_mpModels;
}

std::vector<cv::Mat> ModelManager::getAllModelImageExcSelf(QString strName)
{
	std::vector<cv::Mat> mpAllImage;
	QStringList lst = getAllModelName();
	for (int i = 0; i < lst.size(); i++) {
		if (lst.at(i) == strName) {
			continue;
		}
		TempImage *pImg = getTrainImage(lst.at(i));
		if (pImg) {
			const std::vector<cv::Mat> &imgVec = pImg->getImgVector();
			mpAllImage.insert(mpAllImage.end(), imgVec.begin(), imgVec.end());
		}
	}
	return mpAllImage;
}

std::vector<modelInfo> ModelManager::getAllTarImgs(std::vector<QString> strName)
{
	std::vector<modelInfo> stack;
	for (int i = 0; i < strName.size(); i++)
	{
		modelInfo m_model;
		TempImage *pImg = getTrainImage(strName[i]);
		if (pImg)
		{
			const std::vector<cv::Mat> &imgVec = pImg->getImgVector();
			m_model.mpAllImage.insert(m_model.mpAllImage.end(), imgVec.begin(), imgVec.end());
		}
		IWheelModel *pModel = getModel(strName[i]);
		if (pModel)
		{
			m_model.md_diameter = pModel->getDiameter();
			m_model.md_height = pModel->getThickness();
		}
		stack.push_back(m_model);
	}
	return stack;
}

bool ModelManager::saveModel(QString str)
{
	IWheelModel *pModel = getModel(str);
	if (!pModel) {
		return false;
	}
	//read json
	QJsonObject obj = readJson(m_strRoot + WHEEL_MODEL_FILE);
	((WheelModel*)pModel)->saveJson(&obj);
	//save json
	writeJson(m_strRoot + WHEEL_MODEL_FILE, obj);
	
	return true;
}

bool ModelManager::saveAllModel()
{
	QJsonObject obj = readJson(m_strRoot + WHEEL_MODEL_FILE);
	for each (IWheelModel* var in m_mpModels) {
		WheelModel *pModel = (WheelModel*)var;
		pModel->saveJson(&obj);
	}
	writeJson(m_strRoot + WHEEL_MODEL_FILE, obj);

	return true;
}

IWheelModel * ModelManager::createModel()
{
	return new WheelModel;
}

QStringList ModelManager::getNoDetectModelName()
{
	QStringList lst;
	for each (IWheelModel* var in m_mpModels) {
		if (!var->getDetectState()){
			lst.append(var->getModelID());
		}
	}
	return lst;
}

bool ModelManager::setAllModelsState(bool state)
{
	for each (IWheelModel* var in m_mpModels) {
		if (var){
			var->setDetectState(state);
		}
	}
	return true;
}

bool ModelManager::setRestDetect()
{
	for each (IWheelModel* var in m_mpModels) {
		if (var){
			bool bState = var->getDetectState();
			var->setDetectState(!bState);
		}
	}
	return true;
}

QString ModelManager::getModelPicPath(QString str)
{
	return getModel(str)->getPicPath();
}

QMap<QString, cv::Mat> ModelManager::getAllImgsExcSelf(QString strName /*= QString()*/)
{
	QMap<QString, cv::Mat> mpAllImage;
	QStringList lst = getAllModelName();
	for (int i = 0; i < lst.size(); i++) {
		if (lst.at(i) == strName) {
			continue;
		}

		QString strModeName = lst.at(i);

		TempImage *pImg = getTrainImage(lst.at(i));
		if (pImg) {
			const std::vector<cv::Mat> &imgVec = pImg->getImgVector(1);
			if (imgVec.size()<=0)
				continue;
			mpAllImage.insert(lst.at(i), imgVec.front());
		}
	}
	return mpAllImage;
}

std::vector<cv::Mat> ModelManager::getFirstImgFromFalse(QString strName /*= QString()*/)
{
	std::vector<cv::Mat> mpAllImage;
	QStringList lst = getAllModelName();
	for (int i = 0; i < lst.size(); i++) {
		if (lst.at(i) == strName) {
			continue;
		}
		TempImage *pImg = getTrainImage(lst.at(i));
		if (pImg) {
			const std::vector<cv::Mat> &imgVec = pImg->getImgVector(1);
			mpAllImage.push_back(imgVec.front());
		}
	}
	return mpAllImage;
}

bool ModelManager::reName(QString strOld,QString strNew)
{
	if (m_mpModels.contains(strNew))
		return false;
	IWheelModel *pModel = m_mpModels.take(strOld);
	if (pModel) {
		m_mpModels.insert(strNew, pModel);
		pModel->setModelID(strNew);
		QString n_Pic_path = "\\pattern\\Models\\" + strNew + ".jpg";
		pModel->setPicPath(n_Pic_path);
		saveModel(strNew);
		QVariantMap map = genDbMap(pModel);
		m_pModelDB->addData(map);
		
		bool bFlag = m_pModelDB->DeleteModelData(strOld);

		QString strOldFile = m_strRoot + "\\pattern\\template\\" + strOld + "\\";
		QString strNewFile = m_strRoot + "\\pattern\\template\\" + strNew + "\\";
		hubBase::reNameDirectory(strOldFile, strNewFile);
		QString strOldPic = m_strRoot + "\\pattern\\Models\\" + strOld + ".jpg";
		QString strNewPic = m_strRoot + "\\pattern\\Models\\" + strNew + ".jpg";
		hubBase::reNameFile(strOldPic, strNewPic);
		pModel->reloadTmpImage(m_strRoot + "\\pattern\\");

	}
	else
	{
		return false;
	}
	return true;
}


QJsonObject ModelManager::readJson(QString strFile)
{
	QJsonObject rootObj;
	QFile file(strFile);
	bool b = file.open(QIODevice::ReadOnly);
	if (b == true)
	{
		QByteArray readData = file.readAll();
		QJsonDocument doc= QJsonDocument::fromBinaryData(readData);
		rootObj =  doc.object();
	}
	file.close();
	return rootObj;
}

void ModelManager::writeJson(QString strFile, QJsonObject rootObj)
{
	QJsonDocument doc(rootObj);
	QByteArray writeData = doc.toBinaryData();
	QFile file(strFile);
	bool b = file.open(QIODevice::WriteOnly);
	if (b == true)
	{
		file.write(writeData);	
	}
	file.close();
}