#include <QDebug>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QVariant>
#include <QString>
#include <QStringList>
#include <QDate>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QSet>
#include "sspammer.h"


void SSpammer::setInitiaizer(SInitializer &_initializer)
{
	m_pSInitializer = &_initializer;
	m_SBodySpammerMap.setInitiaizer(_initializer);
	m_SReplySpammerMap.setInitiaizer(_initializer);
	m_STSpammer.setInitiaizer(_initializer);
	m_SStatsJson.setInitiaizer(_initializer);
}

bool SSpammer::uploadData(int _companyNum)
{
	m_pSInitializer->insertLog("Start upload Spammer");

	QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
	m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Spammer (Start)");
	if (!m_SBodySpammerMap.uploadData(dbWeb, _companyNum))
	{
		m_pSInitializer->insertLog("Fail to upload Spammer body map");
		return false;
	}
	if (!m_SReplySpammerMap.uploadData(dbWeb, _companyNum))
	{
		m_pSInitializer->insertLog("Fail to upload Spammer reply map");
		return false;
	}
	if (!m_STSpammer.uploadData(dbWeb, _companyNum))
	{
		m_pSInitializer->insertLog("Fail to upload spammer");
		return false;
	}
	if (!m_SStatsJson.uploadData(dbWeb, _companyNum))
	{
		m_pSInitializer->insertLog("Fail to upload statsjson");
		return false;
	}
	m_pSInitializer->insertLog("End upload Spammer");
	m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Spammer (Finish)");

	return true;
}

bool SSpammer::changeTable(int _companyNum)
{
	m_pSInitializer->insertLog("Start table change spammer");
	QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
	if (!m_SBodySpammerMap.changeTable(dbWeb, _companyNum))
	{
		m_pSInitializer->insertLog("Fail to change spammer body map");
		return false;
	}
	if (!m_SReplySpammerMap.changeTable(dbWeb, _companyNum))
	{
		m_pSInitializer->insertLog("Fail to change spammer reply map");
		return false;
	}
	if (!m_STSpammer.changeTable(dbWeb, _companyNum))
	{
		m_pSInitializer->insertLog("Fail to change spammer");
		return false;
	}
	return true;
}

bool SSpammer::makeCategory(SDatagroup &_datagroup, int _nCategory, const QList<SInitializer::stFilter> &_listFilter)
{
	QVector<QStringList> vecData[SInitializer::E_ARTICLE_MAX];
	bool bFiltered[SInitializer::E_ARTICLE_MAX];

	for (int i = 0; i < SInitializer::E_ARTICLE_MAX; i++)
		bFiltered[i] = false;
	_datagroup.copyData(vecData);
	m_pSInitializer->insertDebugLog(QString("Spammer Category: ") + m_pSInitializer->getCategoryName(_nCategory));
	foreach (const SInitializer::stFilter& filter, _listFilter)
	{
		switch(filter.m_nType)
		{
		case E_FILTER_TYPE_DATE://Date
			m_SFilterAlgorithm.FilterDate(vecData, bFiltered, filter.m_vData.toString(),
										  m_pSInitializer->getColumnIntArray()[SInitializer::E_DATA_article_date]);

			break;
		case E_FILTER_TYPE_SEARCH:
			m_SFilterAlgorithm.FilterSearch(vecData, bFiltered, filter.m_vData.toString());

			break;
		case E_FILTER_TYPE_LENGTH:
			m_SFilterAlgorithm.FilterLength(vecData, bFiltered, filter.m_vData.toString());
			break;
		case E_FILTER_TYPE_REPLACE:
			m_SFilterAlgorithm.FilterReplace(vecData, bFiltered, filter.m_vData.toString());
			break;
		case E_FILTER_TYPE_COUNTER:
			m_SFilterAlgorithm.FilterCounter(vecData, bFiltered, filter.m_vData.toString());
			break;
		}
		m_pSInitializer->insertDebugLog("Body: " + QString::number(vecData[SInitializer::E_ARTICLE_BODY].size()) + ", " +
				"Reply: " + QString::number(vecData[SInitializer::E_ARTICLE_REPLY].size()) + ", " +
				SService::convertJsonToStr(filter.m_nType, filter.m_vData.toString()));
	}
	stReal streal;
	m_pSInitializer->insertLog(QString("Category:") + m_pSInitializer->getCategoryName(_nCategory) + ",(" +
							   QString::number(vecData[SInitializer::E_ARTICLE_BODY].size()) + '/' + QString::number(vecData[SInitializer::E_ARTICLE_REPLY].size()) + ")" + "(Body/Reply)" );
	m_pSInitializer->insertDebugLog(QString("Category:") + m_pSInitializer->getCategoryName(_nCategory) + ",(" +
									QString::number(vecData[SInitializer::E_ARTICLE_BODY].size()) + '/' + QString::number(vecData[SInitializer::E_ARTICLE_REPLY].size()) + ")" + "(Body/Reply)" );
	m_pSInitializer->insertDebugLog("");
	const int *anColumn = m_pSInitializer->getColumnIntArray();
	if (bFiltered[SInitializer::E_ARTICLE_BODY])
	{
		foreach (const QStringList& strlist, vecData[SInitializer::E_ARTICLE_BODY])
		{
			streal.m_setRealAllUrl.insert(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
			streal.m_setRealBodyUrl.insert(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
			_datagroup.addRealUrl(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
		}
	}

	if (bFiltered[SInitializer::E_ARTICLE_REPLY])
	{
		foreach (const QStringList& strlist, vecData[SInitializer::E_ARTICLE_REPLY])
		{
			streal.m_setRealAllUrl.insert(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
			streal.m_mapRealReplyUniqueUrl.insertMulti(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed(),
					strlist[anColumn[SInitializer::E_DATA_article_order]].trimmed().toInt());
			_datagroup.addRealUrl(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
		}
	}

	m_mapCategory.insert(_nCategory, streal);
	return true;
}

bool SSpammer::makeOverallCategory(int _categoryNum)
{
	if (m_mapCategory.size() < 1)
		return true;

	stReal streal;
	for (QMap<int, stReal>::iterator iterPos = m_mapCategory.begin(); iterPos != m_mapCategory.end(); iterPos++ )
	{
		stReal& val = iterPos.value();
		foreach (const QString& _strurl, val.m_setRealBodyUrl )
			streal.m_setRealBodyUrl.insert(_strurl);
		foreach (const QString& _strurl, val.m_setRealAllUrl )
			streal.m_setRealAllUrl.insert(_strurl);

		for (QMap<QString, int>::iterator iterPos1 = val.m_mapRealReplyUniqueUrl.begin(); iterPos1 != val.m_mapRealReplyUniqueUrl.end();
			 iterPos1++)
		{
			if (streal.m_mapRealReplyUniqueUrl.contains(iterPos1.key()) && streal.m_mapRealReplyUniqueUrl.values(iterPos1.key()).contains(iterPos1.value()))
				continue;
			else
				streal.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
		}
	}

	m_mapCategory.insert(_categoryNum, streal);
	return true;
}

bool SSpammer::makeTable(SDatagroup &_datagroup)
{
	if (m_mapCategory.size() > 0)
	{
		m_pSInitializer->insertLog("Make spammer tables");
		m_pSInitializer->insertLog("Make spammer spammer");
		m_STSpammer.makeTable(_datagroup, m_mapCategory, m_setSpammer);
		m_pSInitializer->insertLog("Make spammer body tables");
		m_SBodySpammerMap.makeTable(_datagroup, m_mapCategory, m_setSpammer);
		m_pSInitializer->insertLog("Make spammer reply tables");
		m_SReplySpammerMap.makeTable(_datagroup, m_mapCategory, m_setSpammer);
		m_pSInitializer->insertLog("Make sstatsjson table");
		m_SStatsJson.makeTable(_datagroup, m_mapCategory);
	}

	return true;
}

void SSpammer::STSpammer::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory, QSet<int> &setSpammer)
{
	const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
	const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
	const int* anColumn = m_pSInitializer->getColumnIntArray();


	for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
	{
		QMap<QString, stSpammerScore> mapScore;
		const stReal& streal = iterPos.value();
		foreach (const QString& _url, streal.m_setRealBodyUrl)
		{
			QString strKey = (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
			strKey += (*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",";
			strKey += (*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
			if (!mapScore.contains(strKey))
			{
				mapScore.insert(strKey, stSpammerScore());
				mapScore[strKey].id_num = _datagroup.getstBody(_url)->id_num;
			}
			mapScore[strKey].body++;
			mapScore[strKey].nickname.insert((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
		}

		for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
		{
			QString strKey = (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
			strKey += (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",";
			strKey += (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
			if (!mapScore.contains(strKey))
			{
				mapScore.insert(strKey, stSpammerScore());
				mapScore[strKey].id_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num;
			}
			mapScore[strKey].reply++;
			mapScore[strKey].nickname.insert((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
		}


		QList<stSpammer> listSpammer;

		for (QMap<QString, stSpammerScore>::iterator iterPos1 = mapScore.begin(); iterPos1 != mapScore.end(); iterPos1++)
		{
			stSpammer stspammer;
			stspammer.bodycount = iterPos1->body;
			stspammer.replycount = iterPos1->reply;
			stspammer.nicknamecount = iterPos1->nickname.size() - 1;
			stspammer.id_num = iterPos1->id_num;
			stspammer.id_id = iterPos1.key().split(",").at(0);
			stspammer.category_num = iterPos.key();
			stspammer.platformname_name = iterPos1.key().split(",").at(1);
			stspammer.platformname_num = m_pSInitializer->getPlatformName(stspammer.platformname_name);
			if (stspammer.bodycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
					stspammer.replycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_CUT] ||
					iterPos1->nickname.size() > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT])
			{

				stspammer.spammervalue = stspammer.bodycount * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_RATIO]
						+ stspammer.replycount * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_RATIO]
						+ iterPos1->nickname.size() * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_RATIO];
				listSpammer.push_back(stspammer);
			}
		}
		qSort(listSpammer.begin(), listSpammer.end(), isGreaterSpammerValue());

		int i = 1;

		for (QList<stSpammer>::iterator iterPos1 = listSpammer.begin(); iterPos1 != listSpammer.end(); iterPos1++)
		{
			iterPos1->rank = i++;
			setSpammer.insert(iterPos1->id_num);
			m_listMap.push_back(*iterPos1);

		}
	}
}

bool SSpammer::STSpammer::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
	//_db.transaction();
	QString strQuery = "delete from spammer_" + QString::number(_nCompany) + "_update";
	QSqlQuery query(_db);
	if (query.exec(strQuery.toUtf8()) == false)
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	//_db.commit();
	//_db.transaction();
	strQuery = "insert into spammer_" + QString::number(_nCompany) + "_update (rank,id_num,id_id,nicknamecount,bodycount,replycount,spammervalue,category_num,platformname_name,platformname_num) VALUES (";

	query.clear();

	foreach (const stSpammer& stspammer, m_listMap)
	{
		QString str = strQuery;
		str += QString::number(stspammer.rank) + ",";
		str += QString::number(stspammer.id_num) + ",";
		str += "'" + sqlString(stspammer.id_id) + "',";
		str += QString::number(stspammer.nicknamecount) + ",";
		str += QString::number(stspammer.bodycount) + ",";
		str += QString::number(stspammer.replycount) + ",";
		str += QString::number(stspammer.spammervalue, 'g', 3) + ",";
		str += QString::number(stspammer.category_num) + ",";
		str += "'" + sqlString(stspammer.platformname_name) + "',";
		str += QString::number(stspammer.platformname_num) + ")";

		if (query.exec(str.toUtf8()) == false)
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}
	//_db.commit();

	strQuery = "update dbinfo set spammercount = " + QString::number(m_listMap.size()) + " where company_num = "
			+ QString::number(_nCompany);
	query.exec(strQuery);

	return true;
}


bool SSpammer::STSpammer::changeTable(QSqlDatabase &_db, const int &_nCompany)
{
	QString strQuery;
	QSqlQuery query(_db);
	strQuery = "RENAME TABLE ";
	strQuery += "spammer_" + QString::number(_nCompany) + " TO " + "spammer_" + QString::number(_nCompany) + "_temp" + ",";
	strQuery += "spammer_" + QString::number(_nCompany) + "_update" + " TO " + "spammer_" + QString::number(_nCompany) + ",";
	strQuery += "spammer_" + QString::number(_nCompany) + "_temp" + " TO " + "spammer_" + QString::number(_nCompany) + "_update";
	m_pSInitializer->insertLog("spammer_" + QString::number(_nCompany) + " rename table start");
	if (!query.exec(strQuery.toUtf8()))
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	m_pSInitializer->insertLog("spammer_" + QString::number(_nCompany) + " rename table end");
	return true;
}




void SSpammer::SStatsSpaSpammerRank::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
{
	const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
	const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
	const int* anColumn = m_pSInitializer->getColumnIntArray();

	for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
	{
		QMap<QString, stSpammerScore> mapScore;
		const stReal& streal = iterPos.value();
		foreach (const QString& _url, streal.m_setRealBodyUrl)
		{
			QString strKey = (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
			strKey += ((*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",");
			strKey += (*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
			if (!mapScore.contains(strKey))
			{
				mapScore.insert(strKey, stSpammerScore());
				mapScore[strKey].id_num = _datagroup.getstBody(_url)->id_num;
			}
			mapScore[strKey].body++;
			mapScore[strKey].nickname.insert((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
		}

		for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
		{
			QString strKey = (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
			strKey += ((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",");
			strKey += (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
			if (!mapScore.contains(strKey))
			{
				mapScore.insert(strKey, stSpammerScore());
				mapScore[strKey].id_num = _datagroup.getstBody(iterPos1.key())->id_num;
			}
			mapScore[strKey].reply++;
			mapScore[strKey].nickname.insert((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
		}


		QList<stStatsSpaSpammerRank> listSpammer;

		for (QMap<QString, stSpammerScore>::iterator iterPos1 = mapScore.begin(); iterPos1 != mapScore.end(); iterPos1++)
		{
			stStatsSpaSpammerRank ststats;
			ststats.bodycount = iterPos1->body;
			ststats.replycount = iterPos1->reply;
			ststats.id_num = iterPos1->id_num;
			ststats.nicknamecount = iterPos1->nickname.size() - 1;
			ststats.id_id = iterPos1.key().split(",").at(0);
			ststats.platformname_name = iterPos1.key().split(",").at(1);
			ststats.subject = "spammervalue";
			if (ststats.bodycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
					ststats.replycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT] ||
					iterPos1->nickname.size() > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT])
			{

				ststats.spammervalue = ststats.bodycount * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_RATIO]
						+ ststats.replycount * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_RATIO]
						+ iterPos1->nickname.size() * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_RATIO];
				listSpammer.push_back(ststats);
			}
		}

		qSort(listSpammer.begin(), listSpammer.end(), isGreaterSpammerValue());
		QMap<QString, int> mapRank;

		for (QList<stStatsSpaSpammerRank>::iterator iterPos1 = listSpammer.begin(); iterPos1 != listSpammer.end(); iterPos1++)
		{
			if (!mapRank.contains(iterPos1->platformname_name))
				mapRank.insert(iterPos1->platformname_name, 1);

			if (mapRank[iterPos1->platformname_name] <= 10)
			{
				iterPos1->rank = mapRank[iterPos1->platformname_name]++;
				m_listMap.push_back(*iterPos1);
			}
		}
	}
}

/*
bool SSpammer::SStatsSpaSpammerRank::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
	//_db.transaction();
	QString strQuery = "delete from stats_spa_spammer_rank where company_num = " + QString::number(_nCompany);
	QSqlQuery query(_db);
	if (query.exec(strQuery.toUtf8()) == false)
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	//_db.commit();
	//_db.transaction();
	strQuery = "insert into stats_spa_spammer_rank (rank,id_num,id_id,nicknamecount,bodycount,replycount,spammervalue,company_num,platformname_name,subject) VALUES ("
			":rank,:id_num,:id_id,:nicknamecount,:bodycount,:replycount,:spammervalue,:company_num,:platformname_name,:subject)";

	query.clear();
	query.prepare(strQuery.toUtf8());

	foreach (const stStatsSpaSpammerRank& ststats, m_listMap)
	{
		query.bindValue(":rank", ststats.rank);
		query.bindValue(":id_num", ststats.id_num);
		query.bindValue(":id_id", ststats.id_id);
		query.bindValue(":nicknamecount", ststats.nicknamecount);
		query.bindValue(":bodycount", ststats.bodycount);
		query.bindValue(":replycount", ststats.replycount);
		query.bindValue(":spammervalue", QString::number(ststats.spammervalue, 'g', 3));
		query.bindValue(":company_num", _nCompany);
		query.bindValue(":platformname_name", ststats.platformname_name);
		query.bindValue(":subject", ststats.subject);
		if (query.exec() == false)
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}
	//_db.commit();
	return true;
}
*/

bool SSpammer::SStatsSpaSpammerRank::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
	//_db.transaction();
	QString strQuery = "delete from stats_spa_spammer_rank where company_num = " + QString::number(_nCompany);
	QSqlQuery query(_db);
	if (query.exec(strQuery.toUtf8()) == false)
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	//_db.commit();
	//_db.transaction();
	strQuery = "insert into stats_spa_spammer_rank (rank,id_num,id_id,nicknamecount,bodycount,replycount,"
			   "spammervalue,company_num,platformname_name,subject) VALUES (";
	query.clear();

	foreach (const stStatsSpaSpammerRank& ststats, m_listMap)
	{
		QString str = strQuery;
		str += QString::number(ststats.rank) + ",";
		str += QString::number(ststats.id_num) + ",";
		str += "'" + sqlString(ststats.id_id) + "',";
		str += QString::number(ststats.nicknamecount) + ",";
		str += QString::number(ststats.bodycount) + ",";
		str += QString::number(ststats.replycount) + ",";
		str += QString::number(ststats.spammervalue, 'g', 3) + ",";
		str += QString::number(_nCompany) + ",";
		str += "'" + sqlString(ststats.platformname_name) + "',";
		str += "'" + ststats.subject + "')";

		if (query.exec(str.toUtf8()) == false)
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}
	//_db.commit();
	return true;
}


void SSpammer::SBodySpammerMap::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory, QSet<int>& setSpammer)
{
	int num = 1;
	const QStringList* orderedUrl = _datagroup.getOrderedUrl();
	for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
	{
		const stReal& streal = iterPos.value();
		foreach (const QString& strUrl, *orderedUrl)
		{
			if (streal.m_setRealBodyUrl.contains(strUrl))
			{
				if (!setSpammer.contains(_datagroup.getstBody(strUrl)->id_num))
					continue;

				stBodySpammerMap stbody;
				stbody.num = num++;
				stbody.body_num = _datagroup.getstBodyNum(strUrl);
				stbody.id_num = _datagroup.getstBody(strUrl)->id_num;
				stbody.category_num = iterPos.key();
				stbody.realin |= REAL_BODY;
				stbody.platformname_num = _datagroup.getstBody(strUrl)->platformname_num;
				stbody.date = _datagroup.getstBody(strUrl)->date;
				if (streal.m_mapRealReplyUniqueUrl.contains(strUrl))
				{
					stbody.realin |= REAL_REPLY;

					foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
					{
						_datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
					}

				}
				m_listMap.append(stbody);
				_datagroup.addRealBodyCategory(strUrl, iterPos.key());
			}

			else if (streal.m_mapRealReplyUniqueUrl.contains(strUrl))
			{
				stBodySpammerMap stbody;
				stbody.num = num++;
				stbody.body_num = _datagroup.getstBodyNum(strUrl);
				stbody.category_num = iterPos.key();
				stbody.id_num = _datagroup.getstBody(strUrl)->id_num;
				stbody.realin |= REAL_REPLY;
				stbody.platformname_num = _datagroup.getstBody(strUrl)->platformname_num;
				stbody.date = _datagroup.getstBody(strUrl)->date;

				foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
				{
					_datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
				}
				m_listMap.append(stbody);
			}

		}
	}
}

/*
bool SSpammer::SBodySpammerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
	QString strQuery = "truncate body_spammer_map_" + QString::number(_nCompany) + "_update";

	QSqlQuery query(_db);
	if (query.exec(strQuery.toUtf8()) == false)
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	strQuery = "insert into body_spammer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,realin)"
			" values (:num,:category_num,:id_num,:body_num,:realin)";
	query.clear();
	query.prepare(strQuery.toUtf8());

	foreach (const stBodySpammerMap& stmap, m_listMap)
	{
		query.bindValue(":num", stmap.num);
		query.bindValue(":category_num", stmap.category_num);
		query.bindValue(":id_num", stmap.id_num);
		query.bindValue(":body_num", stmap.body_num);
		query.bindValue(":realin", stmap.realin);
		if (query.exec() == false)
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}
	return true;
}
*/

bool SSpammer::SBodySpammerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
	QString strQuery = "truncate body_spammer_map_" + QString::number(_nCompany) + "_update";

	QSqlQuery query(_db);
	if (query.exec(strQuery.toUtf8()) == false)
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	strQuery = "insert into body_spammer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,realin,date,platformname_num)"
																			  " values (";
	query.clear();

	foreach (const stBodySpammerMap& stmap, m_listMap)
	{
		QString str = strQuery;
		str += QString::number(stmap.num) + ",";
		str += QString::number(stmap.category_num) + ",";
		str += QString::number(stmap.id_num) + ",";
		str += QString::number(stmap.body_num) + ",";
		str += QString::number(stmap.realin) + ",";
		str += "'" + sqlString(stmap.date) + "',";
		str += QString::number(stmap.platformname_num) + ")";
		if (query.exec(str.toUtf8()) == false)
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}
	return true;
}


void SSpammer::SReplySpammerMap::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory, QSet<int>& setSpammer)
{
	int num = 1;
	//const QStringList* orderedUrl = _datagroup.getOrderedUrl();
	for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
	{
		const stReal& streal = iterPos.value();
		//foreach (const QString& strUrl, *orderedUrl)
		{
			for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
			{
				if (!setSpammer.contains(_datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num))
					continue;

				stReplySpammerMap streply;
				streply.num = num++;
				streply.category_num = iterPos.key();
				streply.body_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->body_num;
				streply.id_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num;
				streply.reply_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->num;
				streply.body_date = _datagroup.getstBody(iterPos1.key())->date;
				m_listMap.append(streply);


				_datagroup.addRealReplyCategory(iterPos1.key(), iterPos1.value(), iterPos.key());

			}

			/*
			if (streal.m_setRealAllUrl.contains(strUrl))
			{
				if (_datagroup.getstBody(strUrl)->reply_count == 0)
					continue;

				const QMap<int, SDatagroup::stReply>* mapReply = _datagroup.getstReply(strUrl);

				for(QMap<int, SDatagroup::stReply>::const_iterator iterPos1 = mapReply->constBegin(); iterPos1 != mapReply->constEnd(); iterPos1++)
				{
					stReplySpammerMap streply;
					streply.num = num++;
					streply.category_num = iterPos.key();
					streply.body_num = iterPos1.value().body_num;
					streply.id_num = iterPos1.value().id_num;
					streply.reply_num = iterPos1.value().num;
					m_listMap.append(streply);
				}
			}
			*/
		}
	}
}
/*
bool SSpammer::SReplySpammerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
	QString strQuery = "truncate reply_spammer_map_" + QString::number(_nCompany) + "_update";
	QSqlQuery query(_db);
	if (query.exec(strQuery.toUtf8()) == false)
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	strQuery = "insert into reply_spammer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,reply_num)"
			" values (:num,:category_num,:id_num,:body_num,:reply_num)";
	query.clear();
	query.prepare(strQuery.toUtf8());

	foreach (const stReplySpammerMap& stmap, m_listMap)
	{
		query.bindValue(":num", stmap.num);
		query.bindValue(":category_num", stmap.category_num);
		query.bindValue(":id_num", stmap.id_num);
		query.bindValue(":body_num", stmap.body_num);
		//query.bindValue(":realin", stmap.realin);
		query.bindValue(":reply_num", stmap.reply_num);
		if (query.exec() == false)
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}
	return true;
}
*/

bool SSpammer::SReplySpammerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
	QString strQuery = "truncate reply_spammer_map_" + QString::number(_nCompany) + "_update";
	QSqlQuery query(_db);
	if (query.exec(strQuery.toUtf8()) == false)
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	strQuery = "insert into reply_spammer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,reply_num,body_date)"
																			   " values (";
	query.clear();

	foreach (const stReplySpammerMap& stmap, m_listMap)
	{
		QString str = strQuery;
		str += QString::number(stmap.num) + ",";
		str += QString::number(stmap.category_num) + ",";
		str += QString::number(stmap.id_num) + ",";
		str += QString::number(stmap.body_num) + ",";
		str += QString::number(stmap.reply_num) + ",";
		str += "'" + sqlString(stmap.body_date) + "')";
		if (query.exec(str.toUtf8()) == false)
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}
	return true;
}

bool SSpammer::SBodySpammerMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
{
	QString strQuery;
	QSqlQuery query(_db);
	strQuery = "RENAME TABLE ";
	strQuery += "body_spammer_map_" + QString::number(_nCompany) + " TO " + "body_spammer_map_" + QString::number(_nCompany) + "_temp" + ",";
	strQuery += "body_spammer_map_" + QString::number(_nCompany) + "_update" + " TO " + "body_spammer_map_" + QString::number(_nCompany) + ",";
	strQuery += "body_spammer_map_" + QString::number(_nCompany) + "_temp" + " TO " + "body_spammer_map_" + QString::number(_nCompany) + "_update";
	m_pSInitializer->insertLog("body_spammer_map_" + QString::number(_nCompany) + " rename table start");
	if (!query.exec(strQuery.toUtf8()))
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	m_pSInitializer->insertLog("body_spammer_map_" + QString::number(_nCompany) + " rename table end");
	return true;
}


bool SSpammer::SReplySpammerMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
{
	QString strQuery;
	QSqlQuery query(_db);
	strQuery = "RENAME TABLE ";
	strQuery += "reply_spammer_map_" + QString::number(_nCompany) + " TO " + "reply_spammer_map_" + QString::number(_nCompany) + "_temp" + ",";
	strQuery += "reply_spammer_map_" + QString::number(_nCompany) + "_update" + " TO " + "reply_spammer_map_" + QString::number(_nCompany) + ",";
	strQuery += "reply_spammer_map_" + QString::number(_nCompany) + "_temp" + " TO " + "reply_spammer_map_" + QString::number(_nCompany) + "_update";
	m_pSInitializer->insertLog("reply_spammer_map_" + QString::number(_nCompany) + " rename table start");
	if (!query.exec(strQuery.toUtf8()))
	{
		m_pSInitializer->insertLog(query.lastQuery());
		m_pSInitializer->insertLog(query.lastError().text());
		return false;
	}
	m_pSInitializer->insertLog("reply_spammer_map_" + QString::number(_nCompany) + " rename table end");
	return true;
}

void SSpammer::SStatsJson::makeTableBuzz(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
{
	const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
	const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
	const int* anColumn = m_pSInitializer->getColumnIntArray();

	QDate dateStart(2100,1,1),dateEnd(2000,1,1);
	QDate dateStartBody(2100,1,1),dateEndBody(2000,1,1);
	QDate dateStartReply(2100,1,1),dateEndReply(2000,1,1);

	QList<stBuzzy> listBuzzy;
	stReal allCategory;
	// filtered
	{
		for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
		{
			stBuzzy stbuzzy;
			stbuzzy.m_nCategory = iterPos.key();
			const stReal &streal = iterPos.value();
			foreach (const QString& strUrl, streal.m_setRealBodyUrl)
			{
				allCategory.m_setRealBodyUrl.insert(strUrl);
				allCategory.m_setRealAllUrl.insert(strUrl);
				QDate date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
				//if (date.isNull())
				//    date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed(), "yyyy-MM-dd HH:mm:ss").date();
				if (date.year() == 1990)
					continue;
				dateStart = (date < dateStart ) ? date : dateStart;
				dateEnd = (date > dateEnd ) ? date : dateEnd;
				dateStartBody = (date < dateStartBody ) ? date : dateStartBody;
				dateEndBody = (date > dateEndBody ) ? date : dateEndBody;


				if (stbuzzy.m_mapBodyBuzz.contains(date))
					stbuzzy.m_mapBodyBuzz[date]++;
				else
					stbuzzy.m_mapBodyBuzz.insert(date, 1);
			}

			for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
			{
				const QStringList &slReply = (*mapReply)[iterPos1.key()][iterPos1.value()];
				if (!allCategory.m_mapRealReplyUniqueUrl.contains(iterPos1.key()) || !allCategory.m_mapRealReplyUniqueUrl.values(iterPos1.key()).contains(iterPos1.value()))
					allCategory.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
				allCategory.m_setRealAllUrl.insert(iterPos1.key());

				QDate date = QDateTime::fromString(slReply[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
				if (date.year() == 1990)
					continue;
				//dateStart = (date < dateStart ) ? date : dateStart;
				dateEnd = (date > dateEnd ) ? date : dateEnd;
				dateStartReply = (date < dateStartReply ) ? (date < dateStart ? dateStart : date) : dateStartReply;
				dateEndReply = (date > dateEndReply ) ? date : dateEndReply;

				if (stbuzzy.m_mapReplyBuzz.contains(date))
					stbuzzy.m_mapReplyBuzz[date]++;
				else
					stbuzzy.m_mapReplyBuzz.insert(date, 1);
			}

			listBuzzy.append(stbuzzy);
		}
	}
	//all filtered category
	{
		stBuzzy stbuzzy;
		stbuzzy.m_nCategory = -1;
		foreach (const QString& strUrl, allCategory.m_setRealBodyUrl)
		{
			QDate date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
			if (date.year() == 1990)
				continue;

			if (stbuzzy.m_mapBodyBuzz.contains(date))
				stbuzzy.m_mapBodyBuzz[date]++;
			else
				stbuzzy.m_mapBodyBuzz.insert(date, 1);
		}

		for (QMap<QString, int>::const_iterator iterPos1 = allCategory.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != allCategory.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
		{
			const QStringList &slReply = (*mapReply)[iterPos1.key()][iterPos1.value()];
			QDate date = QDateTime::fromString(slReply[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
			if (date.year() == 1990)
				continue;

			if (stbuzzy.m_mapReplyBuzz.contains(date))
				stbuzzy.m_mapReplyBuzz[date]++;
			else
				stbuzzy.m_mapReplyBuzz.insert(date, 1);
		}
		listBuzzy.append(stbuzzy);
	}


	//all buzzy
	{
		stBuzzy stbuzzy;
		stbuzzy.m_nCategory = 0;
		for (QMap<QString, QStringList>::const_iterator iterPos = mapBody->constBegin(); iterPos != mapBody->constEnd(); iterPos++)
		{
			QDate date = QDateTime::fromString(iterPos.value()[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
			if (date.year() == 1990)
				continue;

			if (stbuzzy.m_mapBodyBuzz.contains(date))
				stbuzzy.m_mapBodyBuzz[date]++;
			else
				stbuzzy.m_mapBodyBuzz.insert(date, 1);
		}

		for (QMap<QString, QMap<int, QStringList> >::const_iterator iterPos = mapReply->constBegin(); iterPos != mapReply->constEnd(); iterPos++)
		{
			for (QMap<int, QStringList>::const_iterator iterPos1 = iterPos.value().constBegin(); iterPos1 != iterPos.value().constEnd(); iterPos1++)
			{
				QDate date = QDateTime::fromString(iterPos1.value()[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
				if (date.year() == 1990)
					continue;

				if (stbuzzy.m_mapReplyBuzz.contains(date))
					stbuzzy.m_mapReplyBuzz[date]++;
				else
					stbuzzy.m_mapReplyBuzz.insert(date, 1);
			}
		}
		listBuzzy.append(stbuzzy);
	}

	int nTotalCount = 0, nTotalBodyCount = 0, nTotalReplyCount = 0;

	{
		foreach (const QString& strUrl, allCategory.m_setRealAllUrl)
		{
			nTotalBodyCount++;
			nTotalReplyCount += (*mapReply)[strUrl].size();
		}
		nTotalCount = nTotalBodyCount + nTotalReplyCount;
	}


	{
		QJsonArray jsArrayAll;
		QJsonArray jsArrayReply;
		QJsonArray jsArrayBody;

		foreach (const stBuzzy &stbuzzy, listBuzzy)
		{
			QJsonArray jsValueAll;
			QJsonArray jsValueBody;
			QJsonArray jsValueReply;

			for (QDate i = dateStart; i <= dateEnd; i = i.addDays(1))
			{
				QJsonObject jsoBody;
				QJsonObject jsoAll;
				QJsonObject jsoReply;

				jsoAll["date"] = jsoReply["date"] = jsoBody["date"] = i.toString("yyyyMMdd");
				jsoBody["count"] = stbuzzy.m_mapBodyBuzz[i];
				jsoReply["count"] = stbuzzy.m_mapReplyBuzz[i];
				jsoAll["count"] = stbuzzy.m_mapBodyBuzz[i] + stbuzzy.m_mapReplyBuzz[i];

				jsValueAll.append(jsoAll);
				jsValueBody.append(jsoBody);
				jsValueReply.append(jsoReply);
			}

			QJsonObject jsNameReply;
			QJsonObject jsNameAll;
			QJsonObject jsNameBody;

			if (stbuzzy.m_nCategory > 0)
				jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = m_pSInitializer->getCategoryName(stbuzzy.m_nCategory);
			else if (stbuzzy.m_nCategory == 0)
				jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = "ALL";
			else
				jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = "ALLCATEGORY";

			jsNameAll["value"] = jsValueAll;
			jsNameBody["value"] = jsValueBody;
			jsNameReply["value"] = jsValueReply;

			jsArrayAll.append(jsNameAll);
			jsArrayBody.append(jsNameBody);
			jsArrayReply.append(jsNameReply);
		}
		stStatsJson stbodybuzz;
		stStatsJson streplybuzz;
		stStatsJson stallbuzz;

		stallbuzz.title = streplybuzz.title = stbodybuzz.title = "buzz";

		stbodybuzz.subtitle = "body";
		streplybuzz.subtitle = "reply";
		stallbuzz.subtitle = "all";

		QJsonObject jobjAll;
		QJsonObject jobjBody;
		QJsonObject jobjReply;

		jobjAll["data"] = jsArrayAll;
		jobjBody["data"] = jsArrayBody;
		jobjReply["data"] = jsArrayReply;

		jobjAll["mindate"] = dateStart.toString("yyyy.MM.dd");
		jobjBody["mindate"] = dateStartBody.toString("yyyy.MM.dd");
		jobjReply["mindate"] = dateStartReply.toString("yyyy.MM.dd");

		jobjAll["maxdate"] = dateEnd.toString("yyyy.MM.dd");
		jobjBody["maxdate"] = dateEndBody.toString("yyyy.MM.dd");
		jobjReply["maxdate"] = dateEndReply.toString("yyyy.MM.dd");

		jobjAll["totalcount"] = nTotalCount;
		jobjBody["totalcount"] = nTotalBodyCount;
		jobjReply["totalcount"] = nTotalReplyCount;

		QJsonDocument jdAll(jobjAll);
		QJsonDocument jdBody(jobjBody);
		QJsonDocument jdReply(jobjReply);

		stbodybuzz.jdata = jdBody.toJson(QJsonDocument::Compact);
		streplybuzz.jdata = jdReply.toJson(QJsonDocument::Compact);
		stallbuzz.jdata = jdAll.toJson(QJsonDocument::Compact);

		stallbuzz.platformname_num = stbodybuzz.platformname_num = streplybuzz.platformname_num = 1;
		m_listMap.append(stbodybuzz);
		m_listMap.append(streplybuzz);
		m_listMap.append(stallbuzz);
	}

	/*

	{
		for (QDate i = dateStart; i <= dateEnd; i = i.addDays(1))
		{
			//body
			stStatsJson stbodybuzz;
			stStatsJson streplybuzz;
			stStatsJson stallbuzz;
			foreach (const stBuzzy& stbuzzy, listBuzzy)
			{
				if (stbuzzy.m_mapBodyBuzz.contains(i))
				{
					stbodybuzz.category[stbuzzy.m_nCategory] = stbuzzy.m_mapBodyBuzz[i];
					stallbuzz.category[stbuzzy.m_nCategory] += stbuzzy.m_mapBodyBuzz[i];
				}

				if (stbuzzy.m_mapReplyBuzz.contains(i))
				{
					streplybuzz.category[stbuzzy.m_nCategory] = stbuzzy.m_mapReplyBuzz[i];
					stallbuzz.category[stbuzzy.m_nCategory] += stbuzzy.m_mapReplyBuzz[i];
				}
			}
			stallbuzz.date = streplybuzz.date = stbodybuzz.date = i;
			stbodybuzz.subtitle = "body";
			streplybuzz.subtitle = "reply";
			stallbuzz.subtitle = "all";
			m_listMap.append(stallbuzz);
			m_listMap.append(stbodybuzz);
			m_listMap.append(streplybuzz);
		}
	}
	*/
}

void SSpammer::SStatsJson::makeTableRank(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
{
	const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
	const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
	const int* anColumn = m_pSInitializer->getColumnIntArray();

	stReal allCategory;

	for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
	{
		QMap<QString, stSpammerScore> mapScore;
		const stReal& streal = iterPos.value();
		QDate dateStart(2030, 1, 1);
		QDate dateEnd(2000, 1, 1);

		foreach (const QString& _url, streal.m_setRealBodyUrl)
		{
			allCategory.m_setRealBodyUrl.insert(_url);
			allCategory.m_setRealAllUrl.insert(_url);

			QString strKey = (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
			strKey += ((*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",");
			strKey += (*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
			if (!mapScore.contains(strKey))
			{
				mapScore.insert(strKey, stSpammerScore());
				mapScore[strKey].id_num = _datagroup.getstBody(_url)->id_num;
			}
			mapScore[strKey].body++;
			mapScore[strKey].nickname.insert((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
			QDate dateThis = QDateTime::fromString((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd hh:mm:ss").date();
			if (dateThis.isValid() && dateThis.year() > 1990)
			{
				dateStart = (dateStart < dateThis) ? dateStart : dateThis;
				dateEnd = (dateEnd > dateThis) ? dateEnd : dateThis;
			}
		}

		for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
		{
			allCategory.m_setRealAllUrl.insert(iterPos1.key());
			if (!allCategory.m_mapRealReplyUniqueUrl.contains(iterPos1.key()) || !allCategory.m_mapRealReplyUniqueUrl.values(iterPos1.key()).contains(iterPos1.value()))
				allCategory.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
			QString strKey = (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
			strKey += ((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",");
			strKey += (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
			if (!mapScore.contains(strKey))
			{
				mapScore.insert(strKey, stSpammerScore());
				mapScore[strKey].id_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num;
			}
			mapScore[strKey].reply++;
			mapScore[strKey].nickname.insert((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
			QDate dateThis = QDateTime::fromString((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd hh:mm:ss").date();
			if (dateThis.isValid() && dateThis.year() > 1990)
			{
				dateStart = (dateStart < dateThis) ? dateStart : dateThis;
				dateEnd = (dateEnd > dateThis) ? dateEnd : dateThis;
			}
		}

		//QList<stSpammerRank> listSpammer;
		QMap<int, stSpammerRank> mapSpammer;
		for (QMap<QString, stSpammerScore>::iterator iterPos1 = mapScore.begin(); iterPos1 != mapScore.end(); iterPos1++)
		{
			if (iterPos1->body >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
					iterPos1->reply >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT] ||
					iterPos1->nickname.size() >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT])
			{
				double value = iterPos1->body * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_RATIO]
						+ iterPos1->reply * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_RATIO]
						+ iterPos1->nickname.size() * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_RATIO];
				stSpammerRank rank;
				rank.value = value;
				rank.id = iterPos1.key().split(",").at(0);
				rank.platformform_num = m_pSInitializer->getPlatformName(iterPos1.key().split(",").at(1));
				rank.id_num = iterPos1.value().id_num;
				mapSpammer.insertMulti(rank.platformform_num, rank);
			}
		}

		QList<int> keys = mapSpammer.keys().toSet().toList();

		QJsonArray jsonArray;
		stStatsJson stjsonRank;
		{
			stjsonRank.category_num = iterPos.key();
			stjsonRank.servicenum = 3;
			stjsonRank.title = "rank";
			stjsonRank.subtitle = "";
			stjsonRank.platformname_num = 1;
		}
		int nTotalCount = 0;

		for (QList<int>::iterator iterPos1 = keys.begin(); iterPos1 != keys.end(); iterPos1++)
		{
			QList<stSpammerRank> values = mapSpammer.values(*iterPos1);
			qSort(values.begin(), values.end(), isGreaterSpammerValue());
			int nRankLimit = (values.size() <= 10) ? values.size() : 10;
			QJsonObject jsonObj;
			jsonObj["platformname_num"] = *iterPos1;
			QJsonArray jsonSubArray;
			for (int i = 0; i < nRankLimit; i++)
			{
				QJsonObject jsonSubObj;
				jsonSubObj["rank"] = i + 1;
				jsonSubObj["value"] = values.at(i).value;
				jsonSubObj["id"] = values.at(i).id;
				jsonSubObj["id_num"] = values.at(i).id_num;
				jsonSubArray.append(jsonSubObj);
			}
			jsonObj["data"] = jsonSubArray;
			jsonArray.append(jsonObj);

			nTotalCount += values.size();
		}
		QJsonObject jObj;
		jObj["data"] = jsonArray;
		jObj["mindate"] = dateStart.toString("yyyy.MM.dd");
		jObj["maxdate"] = dateEnd.toString("yyyy.MM.dd");
		jObj["totalcount"] = nTotalCount;
		QJsonDocument jsonDoc(jObj);
		stjsonRank.jdata = jsonDoc.toJson();
		m_listMap.append(stjsonRank);
	}


	//all filtered Category
	{
		QMap<QString, stSpammerScore> mapScore;
		const stReal& streal = allCategory;
		QDate dateStart(2030, 1, 1);
		QDate dateEnd(2000, 1, 1);

		foreach (const QString& _url, streal.m_setRealBodyUrl)
		{
			QString strKey = (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
			strKey += ((*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",");
			strKey += (*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
			if (!mapScore.contains(strKey))
			{
				mapScore.insert(strKey, stSpammerScore());
				mapScore[strKey].id_num = _datagroup.getstBody(_url)->id_num;
			}
			mapScore[strKey].body++;
			mapScore[strKey].nickname.insert((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
			QDate dateThis = QDateTime::fromString((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd hh:mm:ss").date();
			if (dateThis.isValid() && dateThis.year() > 1990)
			{
				dateStart = (dateStart < dateThis) ? dateStart : dateThis;
				dateEnd = (dateEnd > dateThis) ? dateEnd : dateThis;
			}
		}

		for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
		{
			QString strKey = (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
			strKey += ((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",");
			strKey += (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
			if (!mapScore.contains(strKey))
			{
				mapScore.insert(strKey, stSpammerScore());
				mapScore[strKey].id_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num;
			}
			mapScore[strKey].reply++;
			mapScore[strKey].nickname.insert((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
			QDate dateThis = QDateTime::fromString((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd hh:mm:ss").date();
			if (dateThis.isValid() && dateThis.year() > 1990)
			{
				dateStart = (dateStart < dateThis) ? dateStart : dateThis;
				dateEnd = (dateEnd > dateThis) ? dateEnd : dateThis;
			}
		}

		//QList<stSpammerRank> listSpammer;
		QMap<int, stSpammerRank> mapSpammer;
		for (QMap<QString, stSpammerScore>::iterator iterPos1 = mapScore.begin(); iterPos1 != mapScore.end(); iterPos1++)
		{
			if (iterPos1->body >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
					iterPos1->reply >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT] ||
					iterPos1->nickname.size() >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT])
			{
				double value = iterPos1->body * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_RATIO]
						+ iterPos1->reply * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_RATIO]
						+ iterPos1->nickname.size() * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_RATIO];
				stSpammerRank rank;
				rank.value = value;
				rank.id = iterPos1.key().split(",").at(0);
				rank.platformform_num = m_pSInitializer->getPlatformName(iterPos1.key().split(",").at(1));
				rank.id_num = iterPos1.value().id_num;
				mapSpammer.insertMulti(rank.platformform_num, rank);
			}
		}

		QList<int> keys = mapSpammer.keys().toSet().toList();

		QJsonArray jsonArray;
		stStatsJson stjsonRank;
		{
			stjsonRank.category_num = -1;
			stjsonRank.servicenum = 3;
			stjsonRank.title = "rank";
			stjsonRank.subtitle = "";
			stjsonRank.platformname_num = 1;
		}
		int nTotalCount = 0;

		for (QList<int>::iterator iterPos1 = keys.begin(); iterPos1 != keys.end(); iterPos1++)
		{
			QList<stSpammerRank> values = mapSpammer.values(*iterPos1);
			qSort(values.begin(), values.end(), isGreaterSpammerValue());
			int nRankLimit = (values.size() <= 10) ? values.size() : 10;
			QJsonObject jsonObj;
			jsonObj["platformname_num"] = *iterPos1;
			QJsonArray jsonSubArray;
			for (int i = 0; i < nRankLimit; i++)
			{
				QJsonObject jsonSubObj;
				jsonSubObj["rank"] = i + 1;
				jsonSubObj["value"] = values.at(i).value;
				jsonSubObj["id"] = values.at(i).id;
				jsonSubObj["id_num"] = values.at(i).id_num;
				jsonSubArray.append(jsonSubObj);
			}
			jsonObj["data"] = jsonSubArray;
			jsonArray.append(jsonObj);

			nTotalCount += values.size();
		}
		QJsonObject jObj;
		jObj["data"] = jsonArray;
		jObj["mindate"] = dateStart.toString("yyyy.MM.dd");
		jObj["maxdate"] = dateEnd.toString("yyyy.MM.dd");
		jObj["totalcount"] = nTotalCount;
		QJsonDocument jsonDoc(jObj);
		stjsonRank.jdata = jsonDoc.toJson();
		m_listMap.append(stjsonRank);
	}
}


void SSpammer::SStatsJson::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
{
	makeTableBuzz(_datagroup, _mapCategory);
	makeTableRank(_datagroup, _mapCategory);
}


bool SSpammer::SStatsJson::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
	QSqlQuery query(_db);
	{
		QString strQuery = "delete from stats_json where company_num = " + QString::number(_nCompany) + " and servicenum = 3";
		if (!query.exec(strQuery.toUtf8()))
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}

	foreach (const stStatsJson& ststats, m_listMap)
	{
		QString strQuery = "insert into stats_json (company_num, servicenum, title, subtitle, category_num, platformname_num, jdata) values (";
		strQuery += QString::number(_nCompany) + ",";
		strQuery += QString::number(ststats.servicenum) + ",";
		strQuery += "'" + ststats.title + "',";
		strQuery += "'" + ststats.subtitle + "',";
		strQuery += QString::number(ststats.category_num) + ",";
		strQuery += QString::number(ststats.platformname_num) + ",";
		strQuery += "'" + ststats.jdata +"')";

		if (!query.exec(strQuery.toUtf8()))
		{
			m_pSInitializer->insertLog(query.lastQuery());
			m_pSInitializer->insertLog(query.lastError().text());
			return false;
		}
	}
	return true;
}