#include "scompanyprocess.h"
#include "sutilfunction.h"
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QString>
#include <QDate>
#include <QStringList>
#include <QDebug>
#include <iostream>

namespace
{
const QString strDatabaseName("processlist");
}

SCompanyProcess::SCompanyProcess():SParentProcess(),
    m_iterEffectRow(nullptr), m_iterRunOrderList(nullptr), m_bDoneCompany(false)
{
    databaseSetting(strDatabaseName);
    QObject::connect(this, &SCompanyProcess::signalTerminateEachEvent,
                     this, &SCompanyProcess::slotTerminateEachEvent);
}

void SCompanyProcess::setList(const QVector<int>& _list)
{
    clear();
    m_vecRunList = _list;
}

void SCompanyProcess::setList(QVector<int>&& _list)
{
    clear();
    m_vecRunList = std::move(_list);
}

void SCompanyProcess::setList(const QVector<SEffectRow>& _list)
{

}

void SCompanyProcess::setList(QVector<SEffectRow>&& _list)
{

}

void SCompanyProcess::runInit()
{
    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_INIT);

    if (m_vecRunList.empty())
    {
        setError(SError(E_ERROR_CODE::UNKNOWN_ERROR, "Empty Running List"));
        emit signalTerminateError(getError());
        return;
    }

    QSqlDatabase db = QSqlDatabase::database(strDatabaseName);
    if (!db.open())
    {
        setError(SError(E_ERROR_CODE::DB_OPEN_ERROR, db.lastError().text()));
        emit signalTerminateError(getError());
        return;
    }

    QString strQuery("select num, company_num from eventgroup where adddate(curdate(), interval -1 month) <= enddate and company_num in (");
    foreach (auto num, m_vecRunList)
    {
        strQuery += (QString::number(num) + ",");
    }
    strQuery = strQuery.left(strQuery.length() - 1);
    strQuery += ")";

    QSqlQuery query(db);
    if (!query.exec(strQuery))
    {
        setError(SError(E_ERROR_CODE::DB_QUERY_ERROR, query.lastQuery() + "\n" + query.lastError().text()));
        emit signalTerminateError(getError());
        return;
    }
    QSet<int> setGroup;

    while (query.next())
    {
        setGroup.insert(query.value(0).toInt());
        if (!m_vecRunOrderList.contains(query.value(1).toInt()))
            m_vecRunOrderList.append(query.value(1).toInt());
    }
    // qDebug() << m_vecRunOrderList;
    /*
    while (query.next())
    {

        QDate enddate = QDate::fromString(query.value(1).toString(), "yyyy-MM-dd");
        QDate today = QDate::currentDate();
        if (today <= enddate.addMonths(1))

        {
            m_vecRunOrderList.push_back(query.value(0).toInt());
        }
    }
    */

    strQuery = "select company.num, name, eventgroup.startdate, eventgroup.enddate, t.eventgroupnum, "
               "t.date, t.url, t.num, t.platformname_num "
               "from company "
               "join (select company_num, company_event_map.eventgroup_num as eventgroupnum, event.date, event.url, event.num, "
               "event.platformname_num from company_event_map join event on company_event_map.event_num = event.num) "
               "as t on company.num = t.company_num "
               "inner join eventgroup on eventgroup.company_num = company.num "
               "where company.num in (";

    foreach (auto &num, m_vecRunOrderList)
    {
        strQuery += (QString::number(num) + ",");
    }

    strQuery = strQuery.left(strQuery.length() - 1);
    strQuery += ")";
    if (!query.exec(strQuery))
    {
        setError(SError(E_ERROR_CODE::DB_QUERY_ERROR, query.lastQuery() + "\n" + query.lastError().text()));
        emit signalTerminateError(getError());
        return;
    }
    /*
    foreach (auto &num, m_vecRunOrderList)
    {
        m_vecRunOrderList.insert(num, QVector<SEffectRow>());
    }
    */
    QMap<int, SReportSummary> mapSummary;
    qDebug() << setGroup;

    foreach (auto company, m_vecRunList)
    {
        if (!m_mapEffectRow.contains(company))
            m_mapEffectRow.insert(company, QVector<SEffectRow>());

        if (!mapSummary.contains(company))
            mapSummary.insert(company, SReportSummary());
    }

    while (query.next())
    {
        int nCompany = query.value(0).toInt();
        //qDebug() << query.value(4).toInt();
        if (!m_mapEffectRow.contains(nCompany))
            m_mapEffectRow.insert(nCompany, QVector<SEffectRow>());

        if (!mapSummary.contains(nCompany))
            mapSummary.insert(nCompany, SReportSummary());

        mapSummary[nCompany].nTotal++;

        if (setGroup.contains(query.value(4).toInt()))
        {
            mapSummary[nCompany].nAllGroupEvent++;
            if (!query.value(6).toString().trimmed().isEmpty())
            {
                mapSummary[nCompany].nActiveEventCode++;
                SEffectRow row(query.value(0).toInt(),
                               query.value(1).toString().trimmed(),
                               QDate::fromString(query.value(2).toString().trimmed(), "yyyy-MM-dd"),
                               QDate::fromString(query.value(3).toString().trimmed(), "yyyy-MM-dd"),
                               query.value(4).toInt(),
                               QDate::fromString(query.value(5).toString().trimmed(), "yyyy-MM-dd"),
                               query.value(6).toString().trimmed(),
                               query.value(7).toString().trimmed(),
                               query.value(8).toInt()
                               );

                m_mapEffectRow[nCompany].append(row);
            }
        }
    }
    setReportSummary(mapSummary);

    int totalEffectNum = 0;
    for (auto iterPos = m_mapEffectRow.begin(); iterPos != m_mapEffectRow.end(); ++iterPos)
    {
        totalEffectNum += iterPos.value().size();
        if (iterPos.value().size() == 0)
            emit signalTerminateCompany(iterPos.key());
    }

    if (totalEffectNum == 0)
    {
        setError(SError(E_ERROR_CODE::UNKNOWN_ERROR, "There is no valid Urls"));
        emit signalTerminateError(getError());
        return;
    }

    initIterator();
    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
    db.close();
}

void SCompanyProcess::initIterator()
{
    m_iterRunOrderList = m_vecRunOrderList.begin();

    while (m_iterRunOrderList != m_vecRunOrderList.end())
    {
        if (m_mapEffectRow.contains(*m_iterRunOrderList))
        {
            m_iterEffectRow = m_mapEffectRow[*m_iterRunOrderList].begin();
            break;
        }
        else
        {
            ++m_iterRunOrderList;
        }
    }
}

void SCompanyProcess::nextIterator()
{
    ++m_iterEffectRow;
    if (m_iterEffectRow == m_mapEffectRow[*m_iterRunOrderList].end())
    {
        m_bDoneCompany = true;
        while (++m_iterRunOrderList != m_vecRunOrderList.end())
        {
            if (m_mapEffectRow.contains(*m_iterRunOrderList))
            {
                m_iterEffectRow = m_mapEffectRow[*m_iterRunOrderList].begin();
                break;
            }
            /*
            else
            {
                ++m_iterRunOrderList;
            }
            */
        }
    }
    else
        m_bDoneCompany = false;
}

bool SCompanyProcess::isDone()
{
    return m_iterRunOrderList == m_vecRunOrderList.end();
}

void SCompanyProcess::runEventCode()
{
    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE);
    if (isUserAbort())
    {
        setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_TERMINATE);
        emit signalUserAbort();
        return;
    }

    if (isDone())
    {
        qDebug() << "Done";
        setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_TERMINATE);
        emit signalTerminateNormal();
        return;
    }

    SEffectRow row = *m_iterEffectRow;
    setCurrentEffectRow(row);
    nextIterator();

    emit signalCompanyStart(row.company_num);

    runProcess(getProcessArguments(row));
}

void SCompanyProcess::clear()
{
    SParentProcess::clear();
    m_vecRunList.clear();
    m_vecRunOrderList.clear();
    m_mapEffectRow.clear();
    m_bDoneCompany = false;
    m_iterEffectRow = nullptr;
    m_iterRunOrderList = nullptr;
}

void SCompanyProcess::slotTerminateEachEvent(int _num, E_CRAWL_STATE _state)
{
    if (m_bDoneCompany)
        emit signalTerminateCompany(_num);
}