#include "QueueManager.h"

QM::QueueManager::QueueManager(wxEvtHandler *eventHandler, std::string jobsdir)
{
    // need to send events into the mainwindow by the threads...
    this->eventHandler = eventHandler;
    this->eventHandler->Bind(wxEVT_THREAD, &QueueManager::OnThreadMessage, this);
    this->jobsDir = jobsdir;
}

int QM::QueueManager::AddItem(QM::QueueItem item)
{
    if (!item.id)
    {
        item.id = this->GetCurrentUnixTimestamp();
    }
    this->QueueList[item.id] = item;
    this->SendEventToMainWindow(QM::QueueEvents::ITEM_ADDED, item);
    return item.id;
}

int QM::QueueManager::AddItem(sd_gui_utils::SDParams *params)
{
    QM::QueueItem item;
    item.params = *params;
    item.created_at = item.id = this->GetCurrentUnixTimestamp();
    this->AddItem(item);
    return item.id;
}

int QM::QueueManager::AddItem(sd_gui_utils::SDParams params)
{
    QM::QueueItem item;
    item.params = params;
    item.created_at = item.id = this->GetCurrentUnixTimestamp();
    this->AddItem(item);
    return item.id;
}

QM::QueueItem QM::QueueManager::GetItem(int id)
{
    if (this->QueueList.find(id) == this->QueueList.end())
    {
        return QM::QueueItem();
    }
    else
    {
        return this->QueueList.at(id);
    }
}

QM::QueueItem QM::QueueManager::GetItem(QM::QueueItem item)
{
    return this->GetItem(item.id);
}

const std::map<int, QM::QueueItem> QM::QueueManager::getList()
{
    return this->QueueList;
}

int QM::QueueManager::Duplicate(QM::QueueItem item)
{
    if (this->QueueList.find(item.id) == this->QueueList.end())
    {
        return -1;
    }
    else
    {
        return this->AddItem(this->QueueList.at(item.id).params);
    }
}

int QM::QueueManager::Duplicate(int id)
{
    return this->AddItem(this->GetItem(id).params);
}

void QM::QueueManager::SetStatus(QM::QueueStatus status, int id)
{
    // todo, start - stop - pause
    auto item = this->GetItem(id);
    item.status = status;
    this->SendEventToMainWindow(QM::QueueEvents::ITEM_STATUS_CHANGED, item);
}

void QM::QueueManager::PauseAll()
{
    for (auto &[key, value] : this->QueueList)
    {
        if (value.status == QM::QueueStatus::PENDING)
        {
            this->SetStatus(QM::PAUSED, key);
            this->SendEventToMainWindow(QM::QueueEvents::ITEM_STATUS_CHANGED);
        }
    }
}

void QM::QueueManager::SendEventToMainWindow(QM::QueueEvents eventType, QM::QueueItem item)
{
    wxThreadEvent *e = new wxThreadEvent();
    // e->SetString(wxString::Format("MODEL_LOAD_START:%s", this->sd_params->model_path));
    e->SetString(wxString("QUEUE:" + (int)eventType));
    e->SetPayload(item);
    wxQueueEvent(this->eventHandler, e);
}

void QM::QueueManager::OnThreadMessage(wxThreadEvent &e)
{
    auto msg = e.GetString().ToStdString();

    std::string token = msg.substr(0, msg.find(":"));
    std::string content = msg.substr(msg.find(":") + 1);
    // only numbers here...
    QM::QueueEvents event = (QM::QueueEvents)std::stoi(content);
    // only handle the QUEUE messages, what this class generate
}

int QM::QueueManager::GetCurrentUnixTimestamp()
{
    const auto p1 = std::chrono::system_clock::now();
    return static_cast<int>(std::chrono::duration_cast<std::chrono::seconds>(p1.time_since_epoch()).count());
}

void QM::QueueManager::onItemAdded(QM::QueueItem item)
{
    // this->parent->m_joblist
    // auto dataTable = this->parent->m_joblist;
}