#include "seffectlogic.h"
#include "sadddelwidget.h"
#include "srunninglistwidget.h"
#include "srunningprocess.h"
#include "slogwidget.h"
#include "stimer.h"
#include <QDebug>

namespace
{
const int RETRY = 2;
}


SEffectLogic::SEffectLogic(): m_pSAddDelWidget(nullptr), m_pSRunningProcess(nullptr),
    m_pSTimer(nullptr), m_pSRunningListWidget(nullptr), m_pSLogWidget(nullptr), nRetry(RETRY)
{

}

void SEffectLogic::setSRunningProcess(SRunningProcess *_p)
{
    m_pSRunningProcess = _p;
}

void SEffectLogic::setSRunningWidget(SRunningListWidget *_p)
{
    m_pSRunningListWidget = _p;
}

void SEffectLogic::setSTimer(STimer *_p)
{
    m_pSTimer = _p;
}

void SEffectLogic::setSLogWidget(SLogWidget *_p)
{
    m_pSLogWidget = _p;
}

void SEffectLogic::setSAddDelWidget(SAddDelWidget *_p)
{
    m_pSAddDelWidget = _p;
}

void SEffectLogic::initConnect()
{
    QObject::connect(m_pSRunningProcess, &SRunningProcess::signalLog,
                     m_pSLogWidget, &SLogWidget::slotWriteLog);

    QObject::connect(m_pSTimer, &STimer::timeout, this, &SEffectLogic::slotStartByTimer);

    QObject::connect(m_pSRunningListWidget, &SRunningListWidget::signalTimerStart,
                     this, &SEffectLogic::slotClickTimerStart);
    QObject::connect(m_pSRunningListWidget, &SRunningListWidget::signalTimerStop,
                     this, &SEffectLogic::slotClickTimerStop);
    QObject::connect(m_pSRunningListWidget, &SRunningListWidget::signalForceStart,
                     this, &SEffectLogic::slotClickForceStart);
    QObject::connect(m_pSRunningListWidget, &SRunningListWidget::signalForceStop,
                     this, &SEffectLogic::slotClickForceStop);

    QObject::connect(m_pSRunningProcess, &SRunningProcess::signalUserAbort,
                     this, &SEffectLogic::slotUserAbort);
    QObject::connect(m_pSRunningProcess, &SRunningProcess::signalTerminateError,
                     this, &SEffectLogic::slotTerminateError);
    QObject::connect(m_pSRunningProcess, &SRunningProcess::signalTerminateNormal,
                     this, &SEffectLogic::slotTerminateNormal);
    QObject::connect(m_pSRunningProcess, &SRunningProcess::signalSuccessErrorCompany,
                     this, &SEffectLogic::slotSuccessErrorCompany);
    QObject::connect(m_pSRunningProcess, &SRunningProcess::signalCompanyComplete,
                     this, &SEffectLogic::slotCompleteCompany);
    QObject::connect(m_pSRunningProcess, &SRunningProcess::signalCompanyOutDated,
                     this, &SEffectLogic::slotCompanyOutdated);

    m_pSRunningListWidget->enableBtnForceStop(false);
    m_pSRunningListWidget->enableBtnTimerStop(false);
}


void SEffectLogic::slotClickForceStart()
{
    if (!(m_pSRunningProcess->isRunning()) && !(m_pSTimer->isActive()))
    {
        nRetry = RETRY;
        m_pSRunningListWidget->enableBtnForceStart(false);
        m_pSRunningListWidget->enableBtnForceStop(true);
        m_pSRunningListWidget->enableBtnTimerStart(false);
        m_pSRunningListWidget->enableBtnTimerStop(false);
        m_pSAddDelWidget->enableBtnAdd(false);
        m_pSAddDelWidget->enableBtnDel(false);
        QVector<int> allList = m_pSRunningListWidget->getAllList();
        foreach (auto i, allList)
            m_pSRunningListWidget->setWaiting(i);


        m_pSRunningProcess->setList(allList);
        m_pSRunningProcess->start();
    }
}

void SEffectLogic::slotClickForceStop()
{
    if (m_pSTimer->isActive())
        m_pSTimer->stop();
    if (m_pSRunningProcess->isRunning())
    {
        m_pSLogWidget->writeLog("Stopping Process");
        m_pSRunningProcess->stop();
    }
    else
    {
        m_pSAddDelWidget->enableBtnAdd(true);
        m_pSAddDelWidget->enableBtnDel(true);
        m_pSRunningListWidget->enableBtnForceStart(true);
        m_pSRunningListWidget->enableBtnForceStop(false);
        m_pSRunningListWidget->enableBtnTimerStart(true);
        m_pSRunningListWidget->enableBtnTimerStop(false);
    }
}

void SEffectLogic::slotClickTimerStart()
{
    if (!m_pSRunningProcess->isRunning() && !m_pSTimer->isActive())
    {
        m_pSRunningListWidget->enableBtnForceStart(false);
        m_pSRunningListWidget->enableBtnForceStop(false);
        m_pSRunningListWidget->enableBtnTimerStart(false);
        m_pSRunningListWidget->enableBtnTimerStop(true);
        m_pSTimer->start();
    }
}

void SEffectLogic::slotClickTimerStop()
{
    if (m_pSTimer->isActive())
    {
        m_pSLogWidget->writeLog("Stopping Process");
        m_pSTimer->stop();
        if (m_pSRunningProcess->isRunning())
        {
            m_pSRunningProcess->stop();
        }
        else
        {
            m_pSAddDelWidget->enableBtnAdd(true);
            m_pSAddDelWidget->enableBtnDel(true);
            m_pSRunningListWidget->enableBtnForceStart(true);
            m_pSRunningListWidget->enableBtnForceStop(false);
            m_pSRunningListWidget->enableBtnTimerStart(true);
            m_pSRunningListWidget->enableBtnTimerStop(false);
        }
    }
}

void SEffectLogic::slotStartByTimer()
{
    if (!m_pSRunningProcess->isRunning())
    {
        nRetry = RETRY;
        m_pSAddDelWidget->enableBtnAdd(false);
        m_pSAddDelWidget->enableBtnDel(false);
        QVector<int> allList = m_pSRunningListWidget->getAllList();

        foreach (auto i, allList)
            m_pSRunningListWidget->setWaiting(i);

        m_pSRunningProcess->setList(allList);
        m_pSRunningProcess->start();
    }
}


void SEffectLogic::slotUserAbort()
{
    if (!m_pSRunningProcess->isRunning())
    {
        m_pSAddDelWidget->enableBtnAdd(true);
        m_pSAddDelWidget->enableBtnDel(true);
        m_pSRunningListWidget->enableBtnForceStart(true);
        m_pSRunningListWidget->enableBtnForceStop(false);
        m_pSRunningListWidget->enableBtnTimerStart(true);
        m_pSRunningListWidget->enableBtnTimerStop(false);
        m_pSLogWidget->writeLog("Stopped");
    }
}

void SEffectLogic::slotTerminateError()
{
    if (!m_pSRunningProcess->isRunning())
    {
        if (!m_pSTimer->isActive())
        {
            m_pSRunningListWidget->enableBtnForceStart(true);
            m_pSRunningListWidget->enableBtnForceStop(false);
            m_pSRunningListWidget->enableBtnTimerStart(true);
            m_pSRunningListWidget->enableBtnTimerStop(false);
        }
        m_pSAddDelWidget->enableBtnAdd(true);
        m_pSAddDelWidget->enableBtnDel(true);
        m_pSLogWidget->writeLog("Error Occurs. Stopped");
    }
}

void SEffectLogic::slotCompleteCompany(int _companyNum, const SReportSummary& _reportSummary)
{
    m_pSRunningListWidget->setInfo(_companyNum, _reportSummary.nOk, _reportSummary.nError,
                                   _reportSummary.nActiveEventCode, _reportSummary.nAllGroupEvent,
                                   _reportSummary.nTotal);
    if (_reportSummary.nAllGroupEvent == 0)
        m_pSRunningListWidget->setOutDate(_companyNum);
    else
        m_pSRunningListWidget->setComplete(_companyNum);
}

void SEffectLogic::slotSuccessErrorCompany(int _companyNum)
{
    m_pSRunningListWidget->setInfoErrortoOk(_companyNum);
}

void SEffectLogic::slotCompanyStart(int _companyNum)
{
    m_pSRunningListWidget->setRunning(_companyNum);
}

void SEffectLogic::slotCompanyOutdated(const QVector<int>& _vecCompany)
{
    foreach (auto i, _vecCompany)
    {
        m_pSRunningListWidget->setOutDate(i);
    }
}

void SEffectLogic::slotTerminateNormal(const QVector<SEffectRow>& _error,
                                       const QMap<int, SReportSummary>& _report)
{
    // qDebug() << "slotTerminateNormal";
    m_pSLogWidget->writeLog("Number of Erros : " + QString::number(_error.size()));
    m_pSLogWidget->writeLog(" ");

    for (auto iterPos = _report.cbegin(); iterPos != _report.cend(); ++iterPos)
    {
        QString str;
        //str += QString::number(iterPos.key()) + ":";
        str += m_pSRunningListWidget->getCompanyName(iterPos.key()) + ":";
        str += QString::number(iterPos.value().nOk) + "/";
        str += QString::number(iterPos.value().nError) + "/";
        str += QString::number(iterPos.value().nActiveEventCode) + "/";
        str += QString::number(iterPos.value().nAllGroupEvent) + "/";
        str += QString::number(iterPos.value().nTotal);
        m_pSLogWidget->writeLog(str);
    }
    // qDebug() << "Error size : " << _error.size();
    // qDebug() << "nRetry : " << nRetry;
    if ((_error.size() > 0) && (nRetry-- > 0))
    {
        m_pSLogWidget->writeLog("");
        m_pSLogWidget->writeLog("");
        m_pSLogWidget->writeLog("Error Retry : " + QString::number(nRetry + 1));
        m_pSLogWidget->writeLog("Start Error Process");
        m_pSRunningProcess->setList(_error);
        m_pSRunningProcess->start();
    }
    else
    {
        if (!m_pSTimer->isActive())
        {
            m_pSRunningListWidget->enableBtnForceStart(true);
            m_pSRunningListWidget->enableBtnForceStop(false);
            m_pSRunningListWidget->enableBtnTimerStart(true);
            m_pSRunningListWidget->enableBtnTimerStop(false);
        }
        m_pSAddDelWidget->enableBtnAdd(true);
        m_pSAddDelWidget->enableBtnDel(true);

        nRetry = RETRY;
        m_pSLogWidget->writeLog("Complete");
    }
}