#include <QDebug>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QVariant>
#include <QString>
#include <QStringList>
#include "sspammer.h"


void SSpammer::setInitiaizer(SInitializer &_initializer)
{
    m_pSInitializer = &_initializer;
    m_SBodySpammerMap.setInitiaizer(_initializer);
    m_SReplySpammerMap.setInitiaizer(_initializer);
    m_SStatsSpaSpammerRank.setInitiaizer(_initializer);
    m_STSpammer.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_SStatsSpaSpammerRank.uploadData(dbWeb, _companyNum))
    {
        m_pSInitializer->insertLog("Fail to upload stats_spa_spammer_rank");
        return false;
    }
    if (!m_STSpammer.uploadData(dbWeb, _companyNum))
    {
        m_pSInitializer->insertLog("Fail to upload spammer");
        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 upload spammer body map");
        return false;
    }
    if (!m_SReplySpammerMap.changeTable(dbWeb, _companyNum))
    {
        m_pSInitializer->insertLog("Fail to upload spammer reply map");
        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);
    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;
        }
    }
    stReal streal;
    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_BODY].size();
    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_REPLY].size();
    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)
{
    return true;
}

bool SSpammer::makeTable(SDatagroup &_datagroup)
{
    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 stats_spa_spammer_rank tables");
    m_SStatsSpaSpammerRank.makeTable(_datagroup, m_mapCategory);
    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);
    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();
            stspammer.id_num = iterPos1->id_num;
            stspammer.id_id = iterPos1.key().split(",").at(0);
            if (stspammer.bodycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
                    stspammer.replycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_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 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 spammer (rank,id_num,id_id,nicknamecount,bodycount,replycount,spammervalue,company_num) VALUES ("
            ":rank,:id_num,:id_id,:nicknamecount,:bodycount,:replycount,:spammervalue,:company_num)";


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

    foreach (const stSpammer& stspammer, m_listMap)
    {
        query.bindValue(":rank", stspammer.rank);
        query.bindValue(":id_num", stspammer.id_num);
        query.bindValue(":id_id", stspammer.id_id);
        query.bindValue(":nicknamecount", stspammer.nicknamecount);
        query.bindValue(":bodycount", stspammer.bodycount);
        query.bindValue(":replycount", stspammer.replycount);
        query.bindValue(":spammervalue", QString::number(stspammer.spammervalue, 'g', 3));
        query.bindValue(":company_num", _nCompany);
        if (query.exec() == 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::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
    //_db.transaction();
    QString strQuery = "delete from spammer 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 spammer (rank,id_num,id_id,nicknamecount,bodycount,replycount,spammervalue,company_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(_nCompany) + ")";

        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;
}


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();
            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 += "'" + 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;
                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;
                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)"
            " 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) + ")";
        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;
                m_listMap.append(streply);
            }

            /*
            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)"
            " 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) + ")";
        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";
    if (!query.exec(strQuery.toUtf8()))
    {
        m_pSInitializer->insertLog(query.lastQuery());
        m_pSInitializer->insertLog(query.lastError().text());
        return false;
    }
    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";
    if (!query.exec(strQuery.toUtf8()))
    {
        m_pSInitializer->insertLog(query.lastQuery());
        m_pSInitializer->insertLog(query.lastError().text());
        return false;
    }
    return true;
}