#include "srunprocess.h"
#include "sutilclass.h"
#include "sutilfunction.h"
#include <QProcess>
#include <QTimer>
#include <QString>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>


namespace
{
const QString strDatabaseName("processlist");
const int ONE_SECOND = 1000; // 1 second
const int HALF_SECOND = 500; // 0.5 second
}

enum class SRunProcess::E_INNER_RUN_MODE:unsigned short
{
    MODE_WAIT = 0,
    MODE_RUN_INIT,
    MODE_RUN_EVENTCODE,
    MODE_WAIT_INIT,
    MODE_WAIT_EVENTCODE,
    MODE_FINISH = MODE_WAIT
};


SRunProcess::SRunProcess():m_eRunMode(E_RUN_MODE::MODE_WAIT),
    m_pTimer(new QTimer(this)), m_pProcess(new QProcess(this)),
    m_eListMode(E_LIST_MODE::MODE_COMPANY), m_bRun(false),
    m_eInnerRunMode(E_INNER_RUN_MODE::MODE_WAIT)
{
    initDatabase();
    connect(m_pTimer.get(), &QTimer::timeout, this, &SRunProcess::update);
}

void SRunProcess::initDatabase()
{
    databaseSetting(strDatabaseName);
}

bool SRunProcess::isRunning()
{
    return m_eRunMode == E_RUN_MODE::MODE_RUN;
}

void SRunProcess::setList(const QVector<int> &_runList)
{
    init();
    m_eListMode = E_LIST_MODE::MODE_COMPANY;
    m_vecRunList = _runList;
}

void SRunProcess::setList(QVector<int> &&_runList)
{
    init();
    m_eListMode = E_LIST_MODE::MODE_COMPANY;
    m_vecRunList = std::move(_runList);
}

void SRunProcess::setList(const QVector<SError> &_errorList)
{
    init();
    m_eListMode = E_LIST_MODE::MODE_ERROR;
    m_vecErrorList = _errorList;
}

void SRunProcess::setList(QVector<SError> &&_errorList)
{
    init();
    m_eListMode = E_LIST_MODE::MODE_ERROR;
    m_vecErrorList = std::move(_errorList);
}


void SRunProcess::init()
{
    m_vecRunList.clear();
    m_vecErrorList.clear();
    m_vecRunOrderList.clear();
    m_mapEffectRow.clear();
}


void SRunProcess::stop()
{
    if (m_pTimer->isActive())
        m_pTimer->stop();
    m_bRun = false;
}


template <typename T>
void SRunProcess::start(QVector<T>&& _list)
{
    setList(std::forward<T>(_list));
    start();
}


void SRunProcess::start()
{
    if (!m_pTimer->isActive())
        m_pTimer->start(ONE_SECOND);
    m_bRun = true;
}


SReportSummary SRunProcess::getReportSummary()
{
    SReportSummary a;
    return a;
}


QVector<SError> SRunProcess::getErrorList()
{
    QVector<SError> hahaha;
    return hahaha;
}


void SRunProcess::update()
{
    switch (m_eListMode)
    {
    case E_LIST_MODE::MODE_COMPANY:
    {
        updateCompany();
        break;
    }
    case E_LIST_MODE::MODE_ERROR:
    {
        updateError();
        break;
    }
    }
}


void SRunProcess::updateCompany()
{
    switch(m_eInnerRunMode)
    {
    case E_INNER_RUN_MODE::MODE_WAIT:
    {
        m_eInnerRunMode = E_INNER_RUN_MODE::MODE_RUN_INIT;
        break;
    }
    case E_INNER_RUN_MODE::MODE_RUN_INIT:
    {
        runInitCompany();
        break;
    }
    case E_INNER_RUN_MODE::MODE_RUN_EVENTCODE:
    {
        runEventcodeCompany();
        break;
    }
    case E_INNER_RUN_MODE::MODE_WAIT_INIT:
    case E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE:
    {
        break;
    }
    }
}


void SRunProcess::updateError()
{
    switch(m_eInnerRunMode)
    {
    case E_INNER_RUN_MODE::MODE_WAIT:
    {
        m_eInnerRunMode = E_INNER_RUN_MODE::MODE_RUN_INIT;
        break;
    }
    case E_INNER_RUN_MODE::MODE_RUN_INIT:
    {
        runInitCompany();
        break;
    }
    case E_INNER_RUN_MODE::MODE_RUN_EVENTCODE:
    {
        runEventcodeCompany();
        break;
    }
    case E_INNER_RUN_MODE::MODE_WAIT_INIT:
    case E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE:
    {
        break;
    }
    }
}


void SRunProcess::setInnerMode(E_INNER_RUN_MODE _inner_mode)
{
    m_eInnerRunMode = _inner_mode;
}


void SRunProcess::runInitCompany()
{
    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_INIT);

    QSqlDatabase db = QSqlDatabase::database(strDatabaseName);
    if (!db.open())
    {
        processError(SError(E_ERROR_CODE::DB_OPEN_ERROR));
        return;
    }
    //select company.num, name, startdate, enddate, t.event_num, t.date, t.url, t.eventcode, t.platformname_num from company join (select company_num, event_num, event.date, event.url, event.eventcode, 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 where company.num in (71, 72, 73)
    QString strQuery("select num, enddate from company where enddate in (");
    foreach (auto& num, m_vecRunList)
    {
        strQuery += (QString::number(num) + ",");
    }
    strQuery = strQuery.left(strQuery.length() - 1);
    strQuery += ")";

    QSqlQuery query(db);
    if (!query.exec(strQuery))
    {
        SError err(E_ERROR_CODE::DB_QUERY_ERROR, query.lastQuery() + "\n" + query.lastError().text());
        //processError(std::move(err));
        processError(err);
        return;
    }

    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, startdate, enddate, t.event_num, "
               "t.date, t.url, t.eventcode, t.platformname_num from company "
               "join (select company_num, event_num, event.date, event.url, event.eventcode, "
               "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 where company.num in (";

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

    strQuery = strQuery.left(strQuery.length() - 1);
    strQuery += ")";
    if (!query.exec(strQuery))
    {
        SError err(E_ERROR_CODE::DB_QUERY_ERROR, query.lastQuery() + "\n" + query.lastError().text());
        //processError(std::move(err));
        processError(err);
        return;
    }

    while (query.next())
    {
        if (!m_mapEffectRow.contains(query.value(0).toInt()))
            m_mapEffectRow.insert(query.value(0).toInt(), QVector<SEffectRow>());

        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[query.value(0).toInt()].append(row);
    }

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


void SRunProcess::processError(const SError& _error)
{
    m_pTimer->stop();
    m_eInnerRunMode = E_INNER_RUN_MODE::MODE_WAIT;
    m_eRunMode = E_RUN_MODE::MODE_WAIT;
    m_errError = _error;
    emit signalError();
}


void SRunProcess::processError(SError&& _error)
{
    m_pTimer->stop();
    m_eInnerRunMode = E_INNER_RUN_MODE::MODE_WAIT;
    m_eRunMode = E_RUN_MODE::MODE_WAIT;
    m_errError = std::move(_error);
    emit signalError();
}


SError SRunProcess::gerError()
{
    return m_errError;
}

void SRunProcess::userAbort()
{

}

void SRunProcess::runInitError()
{
    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_INIT);

    for (int i = 0; i < m_vecRunOrderList.size(); ++i)
    {
        if (!m_bRun)
        {
            userAbort();
            return;
        }

        for (auto iterPos = m_mapEffectRow[m_vecRunOrderList.at(i)].cbegin();
             iterPos != m_mapEffectRow[m_vecRunOrderList.at(i)].cend(); ++iterPos)
        {
            if (!m_bRun)
            {
                userAbort();
                return;
            }

            //execute process;

        }

        emit signalTerminateCompany();
    }

    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
}


void SRunProcess::runEventcodeCompany()
{
    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE);

    for (int i = 0; i < m_vecErrorList.size(); ++i)
    {
        if (!m_bRun)
        {
            userAbort();
            return;
        }
    }

}


void SRunProcess::runEventcodeError()
{
    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE);



    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
}


SRunProcess::~SRunProcess()
{

}