#include "srunninglistwidget.h"
#include "sutilfunction.h"
#include "sutilclass.h"

#include <QPushButton>
#include <QString>
#include <QVector>
#include <QTableWidget>
#include <QVBoxLayout>
#include <QSqlDatabase>
#include <QSettings>
#include <QSqlQuery>
#include <QSqlError>
#include <QDebug>
#include <QDateTime>

/*
namespace
{
const QString strDatabaseName("runninglist");
}
*/

enum class SRunningListWidget::E_TABLE_HEADER
{
    COMPANY = 0,
    START_DATE,
    END_DATE,
    EVENT_NUM,
    STATUS,
    INFOMATION,
    LAST_UPDATE_TIME,
    MAX
};

SRunningListWidget::SRunningListWidget(QWidget* parent) :
    QWidget(parent),
    m_pwParent(this), m_pbtnTimerStart(new QPushButton(this)),
    m_pbtnTimerStop(new QPushButton(this)), m_pbtnForceStart(new QPushButton(this)),
    m_pbtnForceStop(new QPushButton(this)), m_ptableWidget(new QTableWidget(this)),
    m_playout(new QVBoxLayout(this)), m_pslTableHeader(new QStringList)
{
    *m_pslTableHeader << "Company" << "Start date" << "End date"
                      << "Event Num" << "Status" << "Info" << "Update Time";
    initButton();
    //initDatabase();
    initTableWidget();
    initLayout();
    resetTableHeader();
}

void SRunningListWidget::initButton()
{
    m_pbtnForceStart->setText("Force Start");
    m_pbtnForceStop->setText("Force Stop");
    m_pbtnTimerStart->setText("Timer Start");
    m_pbtnTimerStop->setText("Timer Stop");

    connect(m_pbtnForceStart, &QPushButton::released,
            this, &SRunningListWidget::slotForceStart);
    connect(m_pbtnForceStop, &QPushButton::released,
            this, &SRunningListWidget::slotForceStop);
    connect(m_pbtnTimerStart, &QPushButton::released,
            this, &SRunningListWidget::slotTimerStart);
    connect(m_pbtnTimerStop, &QPushButton::released,
            this, &SRunningListWidget::slotTimerStop);
}

/*
void SRunningListWidget::initDatabase()
{
    databaseSetting(strDatabaseName);
}
*/
void SRunningListWidget::initTableWidget()
{
    m_ptableWidget->setColumnCount(m_pslTableHeader->size());
    m_ptableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
    m_ptableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_ptableWidget->setSortingEnabled(true);
    //m_ptableWidget->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
    connect(m_ptableWidget, &QTableWidget::itemSelectionChanged,
            this, &SRunningListWidget::slotClickedItem);
}

void SRunningListWidget::initLayout()
{
    QHBoxLayout *pblbutton = new QHBoxLayout;
    pblbutton->addWidget(m_pbtnTimerStart);
    pblbutton->addWidget(m_pbtnTimerStop);
    pblbutton->addWidget(m_pbtnForceStart);
    pblbutton->addWidget(m_pbtnForceStop);

    m_playout->addWidget(m_ptableWidget);
    m_playout->addLayout(pblbutton);
}

void SRunningListWidget::slotClickedItem()
{
    emit signalClickItem();
}

QVector<int> SRunningListWidget::getSelectedList() const
{
    auto modelIndexes = m_ptableWidget->selectionModel()->selectedRows();

    QVector<int> items;

    foreach (auto& modelIndex, modelIndexes)
    {
        items.append(modelIndex.row());
    }
    return items;
}

QVector<int> SRunningListWidget::getAllList() const
{
    QVector<int> items;
    for (int i = 0; i < m_ptableWidget->rowCount(); ++i)
    {
        int num = m_ptableWidget->item(i, static_cast<int>(E_TABLE_HEADER::COMPANY))->
                data(Qt::UserRole).toInt();
        items.append(num);
    }
    return items;
}

void SRunningListWidget::removeSelectedList()
{
    QModelIndexList selectedList = m_ptableWidget->selectionModel()->selectedRows();
    for (int i = selectedList.size() - 1; i >= 0; --i)
    {
        m_setNumber.remove(selectedList[i].data(Qt::UserRole).toInt());
        m_ptableWidget->removeRow(selectedList[i].row());
    }
}

QVBoxLayout* SRunningListWidget::getLayout() const
{
    return m_playout;
}

void SRunningListWidget::delList(int _id)
{
    if (m_setNumber.contains(_id))
    {
        m_setNumber.remove(_id);
        for (int i = 0; i < m_ptableWidget->rowCount(); ++i)
        {
            auto item = m_ptableWidget->item(i, static_cast<int>(E_TABLE_HEADER::COMPANY));
            if (item->data(Qt::UserRole).toInt() == _id)
            {
                m_ptableWidget->removeRow(i);
                break;
            }
        }
    }
}

void SRunningListWidget::delList(QVector<int> _ids)
{
    foreach (auto& id, _ids)
    {
        delList(id);
    }
}

void SRunningListWidget::resetTableHeader()
{
    m_ptableWidget->clear();
    m_ptableWidget->setHorizontalHeaderLabels(*m_pslTableHeader);
}

SRunningListWidget::~SRunningListWidget()
{
    /*
    if (m_pwParent == nullptr)
    {
        disconnect(m_pbtnForceStart, &QPushButton::released,
                this, &SRunningListWidget::slotForceStart);
        disconnect(m_pbtnForceStop, &QPushButton::released,
                this, &SRunningListWidget::slotForceStop);
        disconnect(m_pbtnTimerStart, &QPushButton::released,
                this, &SRunningListWidget::slotTimerStart);
        disconnect(m_pbtnTimerStop, &QPushButton::released,
                this, &SRunningListWidget::slotTimerStop);
        disconnect(m_ptableWidget, &QTableWidget::itemSelectionChanged,
                this, &SRunningListWidget::slotClickedItem);

        delete m_pbtnForceStart;
        delete m_pbtnForceStop;
        delete m_pbtnTimerStart;
        delete m_pbtnTimerStop;
        delete m_ptableWidget;
        delete m_playout;
    }
    */
}


void SRunningListWidget::addList(QVector<QVector<QTableWidgetItem>> items)
{
    foreach (auto& item, items)
    {
        int num = item[static_cast<int>(E_TABLE_HEADER::COMPANY)].data(Qt::UserRole).toInt();
        if (m_setNumber.contains(num))
            continue;
        m_setNumber.insert(num);
        m_ptableWidget->insertRow(m_ptableWidget->rowCount());
        m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                static_cast<int>(E_TABLE_HEADER::COMPANY),
                                new QTableWidgetItem(item[static_cast<int>(E_TABLE_HEADER::COMPANY)]));
        m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                static_cast<int>(E_TABLE_HEADER::START_DATE),
                                new QTableWidgetItem(item[static_cast<int>(E_TABLE_HEADER::START_DATE)]));
        m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                static_cast<int>(E_TABLE_HEADER::END_DATE),
                                new QTableWidgetItem(item[static_cast<int>(E_TABLE_HEADER::END_DATE)]));
        m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                static_cast<int>(E_TABLE_HEADER::EVENT_NUM),
                                new STableWidgetItem(item[static_cast<int>(E_TABLE_HEADER::EVENT_NUM)]));
        m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                static_cast<int>(E_TABLE_HEADER::STATUS),
                                new QTableWidgetItem(""));
        m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                static_cast<int>(E_TABLE_HEADER::INFOMATION),
                                new QTableWidgetItem(""));
        m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                static_cast<int>(E_TABLE_HEADER::LAST_UPDATE_TIME),
                                new QTableWidgetItem(""));
    }
}

QTableWidgetItem* SRunningListWidget::findWidgetItembyID(int _id, E_TABLE_HEADER _header) const
{
    QTableWidgetItem* item = nullptr;

    for (int i = 0; i < m_ptableWidget->rowCount(); ++i)
    {
        QTableWidgetItem* temp = m_ptableWidget->item(i, static_cast<int>(E_TABLE_HEADER::COMPANY));
        if (temp->data(Qt::UserRole).toInt() == _id)
        {
            item = m_ptableWidget->item(i, static_cast<int>(_header));
            break;
        }
    }
    return item;
}

void SRunningListWidget::enableBtnTimerStart(bool _enable)
{
    m_pbtnTimerStart->setEnabled(_enable);
}

void SRunningListWidget::enableBtnTimerStop(bool _enable)
{
    m_pbtnTimerStop->setEnabled(_enable);
}

void SRunningListWidget::enableBtnForceStart(bool _enable)
{
    m_pbtnForceStart->setEnabled(_enable);
}

void SRunningListWidget::enableBtnForceStop(bool _enable)
{
    m_pbtnForceStop->setEnabled(_enable);
}

void SRunningListWidget::enableTableWidget(bool _enable)
{
    m_ptableWidget->setEnabled(_enable);
}

void SRunningListWidget::setRunning(int _id)
{
    QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::STATUS);
    if (item)
        item->setText("Running");
}

void SRunningListWidget::setWaiting(int _id)
{
    QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::STATUS);
    if (item)
        item->setText("Wating");
}

void SRunningListWidget::setComplete(int _id)
{
    if (QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::LAST_UPDATE_TIME))
        item->setText(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));

    if (QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::STATUS))
        item->setText("Complete");

}

void SRunningListWidget::setOutDate(int _id)
{
    QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::STATUS);
    if (item)
        item->setText("OutDate");
}

void SRunningListWidget::setInfo(int _id, int _ok, int _error, int _active_event, int _all_active_group, int _total)
{
    QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::INFOMATION);
    if (item)
        item->setText(QString::number(_ok) + "/"
                      + QString::number(_error) + "/"
                      + QString::number(_active_event) + "/"
                      + QString::number(_all_active_group) + "/"
                      + QString::number(_total));
}

void SRunningListWidget::setInfoErrortoOk(int _id)
{
    QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::INFOMATION);
    if (item)
    {
        QStringList slInfo = item->text().split("/");
        if (slInfo.size() <= static_cast<int>(E_INFO::TOTAL))
            return;
        int nOk = slInfo.at(static_cast<int>(E_INFO::OK)).toInt();
        int nError = slInfo.at(static_cast<int>(E_INFO::ERROR)).toInt();

        ++nOk;
        --nError;

        item->setText(QString::number(nOk) + "/"
                      + QString::number(nError) + "/"
                      + slInfo.at(static_cast<int>(E_INFO::ACTIVE_EVENT)) + "/"
                      + slInfo.at(static_cast<int>(E_INFO::ALL_ACTIVE_GROUP)) + "/"
                      + slInfo.at(static_cast<int>(E_INFO::TOTAL)));
    }
}

QString SRunningListWidget::getCompanyName(int _company_num)
{
    QTableWidgetItem* item = findWidgetItembyID(_company_num, E_TABLE_HEADER::COMPANY);
    if (item)
        return item->text();
    else
        return QString::number(_company_num);
}



void SRunningListWidget::slotTimerStart()
{
    qDebug() << "clicked TimerStart()";
    emit signalTimerStart();
}

void SRunningListWidget::slotTimerStop()
{
    qDebug() << "clicked slotTimerStop()";
    emit signalTimerStop();
}

void SRunningListWidget::slotForceStart()
{
    qDebug() << "clicked slotForceStart()";
    emit signalForceStart();
}

void SRunningListWidget::slotForceStop()
{
    qDebug() << "clicked slotForceStop()";
    emit signalForceStop();
}