#include <cronjobs.h>
#include <chrono>
#include <fsmount.h>

#define STACK_DEPTH 4096
#define PRIORITY 3

const bool Cron::loadEvents()
{
    FSmount fs;
    File cronFile = FFat.open("/cronjobs.json", FILE_READ, false);
    if (!cronFile)
    {
        LOG_ERROR("Cron failed to open cronjobs.json");
        return false;
    }
    ArduinoJson::JsonDocument cronFileContent;
    if (ArduinoJson::deserializeJson(cronFileContent, cronFile) != ArduinoJson::DeserializationError::Ok)
    {
        LOG_ERROR("Cron unable to deserialize cronjobs.json");
        return false;
    }

    std::string buf;
    ArduinoJson::serializeJsonPretty(cronFileContent, buf);
    LOG_INFO("Cron loadEvents loaded cronjobs.json\n", buf.c_str());

    ArduinoJson::JsonArray cronjobList = cronFileContent.as<JsonArray>();
    LOG_INFO("Cron loadEvents loaded [", cronjobList.size(), "] events");
    for (const auto &job : cronjobList)
    {
        const auto &eventName = job["name"].as<std::string>();
        const auto &cronExpr = job["cronExpr"].as<std::string>();
        const auto status = c_statusStr2Enum.at(job["status"].as<std::string>());
        ArduinoJson::JsonDocument action(job["action"]);
        if (!addEvent(eventName, cronExpr, action, status))
            LOG_ERROR("Cron failed to load event [", eventName.c_str(), "]");
        else
            LOG_INFO("Cron loaded event [", eventName.c_str(), "]");
        delay(10);
    }
    cronFile.close();
    return true;
}

const bool Cron::storeEvents()
{
    FSmount fs;
    std::lock_guard<std::mutex> lock(m_mutex);
    File cronFile = FFat.open("/cronjobs.json", FILE_WRITE, true);
    if (!cronFile)
    {
        LOG_ERROR("Cron failed to open cronjobs.json");
        return false;
    }

    ArduinoJson::JsonDocument cronFileContent;
    ArduinoJson::JsonArray cronFileArray = cronFileContent.to<JsonArray>();

    for (const auto &[eventName, eventParams] : m_cronMap) // convert cron events map to json file
    {
        ArduinoJson::JsonDocument thisJob;
        thisJob["name"] = eventName;
        thisJob["cronExpr"] = cron::to_cronstr(eventParams.cronExpr);
        thisJob["status"] = c_statusEnum2Str.at(eventParams.status);
        thisJob["action"]["cmd"] = eventParams.cmd;
        thisJob["action"]["params"] = eventParams.cmdParams;
        cronFileArray.add(thisJob);
    }

    std::string buf;
    ArduinoJson::serializeJsonPretty(cronFileContent, buf);
    LOG_INFO("Cron storeEvents generated cronjobs.json\n", buf.c_str());

    ArduinoJson::serializeJson(cronFileContent, cronFile);
    cronFile.close();
    return true;
}

const bool Cron::addEvent(const std::string &name, const std::string &expr, const ArduinoJson::JsonDocument action, const CronStatus status)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_cronMap.contains(name))
    {
        LOG_ERROR("Cron event [", name.c_str(), "] already scheduled");
        return false;
    }
    if (name.empty() || expr.empty() || action.isNull())
    {
        LOG_ERROR("Cron event invalid parameters");
        return false;
    }

    try
    {
        const auto cmd = action["cmd"].as<std::string>();
        const auto params = action["params"];
        const auto cronExpr(cron::make_cron(expr));
        if (!commands::s_commandMap.contains(cmd))
        {
            LOG_ERROR("Cron unknown command [", cmd.c_str(), "]");
            return false;
        }
        drivers::PCF85063::datetime_t now;
        if (!m_dev.rtc.readDatetime(now))
        {
            LOG_ERROR("Cron unable to update current time");
            return false;
        }
        const std::tm nowTm = drivers::PCF85063::datetime2tm(now);
        const std::tm next = cron::cron_next(cronExpr, nowTm);
        JsonDocument cmdParams(params); // create a copy of command parameters
        LOG_INFO("Cron adding event [", name.c_str(), "] next execution [", drivers::PCF85063::tm2str(next).c_str(), "]");
        m_cronMap[name] = CronEvent(cmd, cmdParams, cronExpr, next, status);
    }
    catch (cron::bad_cronexpr const &ex)
    {
        LOG_ERROR("Cron failed to parse expression [", expr.c_str(), "] ->", ex.what());
        return false;
    }
    return true;
}

const bool Cron::setEvent(const std::string &name, const CronStatus status)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    if (!m_cronMap.contains(name))
    {
        LOG_ERROR("Cron event [", name.c_str(), "] does not exist");
        return false;
    }
    LOG_INFO("Cron set event [", name.c_str(), "] status [", c_statusEnum2Str.at(status).c_str(), "]");
    m_cronMap.at(name).status = status;
    return true;
}

const bool Cron::getEvent(const std::string &name, CronEvent &event)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    if (!m_cronMap.contains(name))
    {
        LOG_ERROR("Cron event [", name.c_str(), "] does not exist");
        return false;
    }
    LOG_INFO("Cron get event [", name.c_str(), "]");
    event = m_cronMap.at(name);
    return true;
}

const bool Cron::delEvent(const std::string &name)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    if (!m_cronMap.contains(name))
    {
        LOG_WARN("Cron event [", name.c_str(), "] does not exist");
        return false;
    }
    m_cronMap.erase(name);
    LOG_INFO("Cron removed event [", name.c_str(), "]");
    return true;
}

const Cron::CronEventMap &Cron::getAllEvents()
{
    return m_cronMap;
}

void cronLoop(void *cronPtr)
{
    auto &cron = *(Cron *)cronPtr;
    while (true)
    {
        cron.processEvents();
        delay(1000);
    }
}

void Cron::startCron()
{
    if (!m_cronTaskHandle)
    {
        LOG_INFO("Cron starting loop");
        xTaskCreate(cronLoop, "cronLoop", STACK_DEPTH, this, PRIORITY, &m_cronTaskHandle);
    }
}

void Cron::stopCron()
{
    if (m_cronTaskHandle)
    {
        LOG_WARN("Cron stopping loop");
        vTaskDelete(m_cronTaskHandle);
        m_cronTaskHandle = NULL;
    }
}

const bool Cron::processEvents()
{
    std::lock_guard<std::mutex> lock(m_mutex);
    LOG_DEBUG("Cron processEvents [", m_cronMap.size(), "]");

    drivers::PCF85063::datetime_t now;
    if (!m_dev.rtc.readDatetime(now))
    {
        LOG_ERROR("Cron unable to update current time");
        return false;
    }

    std::tm nowTm = drivers::PCF85063::datetime2tm(now);

    for (auto &[eventName, eventParams] : m_cronMap)
    {
        const auto nowPoint = std::chrono::system_clock::from_time_t(std::mktime(&nowTm));
        const auto nextEventPoint = std::chrono::system_clock::from_time_t(std::mktime(&eventParams.next));

        LOG_DEBUG("Cron current time [", std::asctime(&nowTm), "]");
        LOG_DEBUG("Cron checking event [", eventName.c_str(), "] executionTime [", drivers::PCF85063::tm2str(eventParams.next).c_str(), "]");

        if (nextEventPoint <= nowPoint) // execution time hs passed, run event
        {
            ArduinoJson::JsonDocument resp;
            ArduinoJson::JsonDocument action;
            eventParams.next = cron::cron_next(eventParams.cronExpr, nowTm); // update next execution time only if event was executed, otherwise time tracking is lost
            resp["cmd"] = "logCronJob";
            resp["values"]["name"] = eventName;
            resp["values"]["now"] = drivers::PCF85063::tm2str(nowTm).c_str();
            resp["values"]["next"] = drivers::PCF85063::tm2str(eventParams.next).c_str();
            resp["values"]["status"] = c_statusEnum2Str.at(eventParams.status).c_str();
            switch (eventParams.status)
            {
            case CronStatus::ACTIVE:
                LOG_INFO("Cron running ACTIVE event  [", eventName.c_str(), "] next execution time [", drivers::PCF85063::tm2str(eventParams.next).c_str(), "]");
                action = commands::s_commandMap.at(eventParams.cmd)(m_dev, eventParams.cmdParams); // here the magic happens
                resp["values"]["action"] = action;
                break;
            case CronStatus::INACTIVE:
                LOG_INFO("Cron skipping INACTIVE event  [", eventName.c_str(), "] next execution time [", drivers::PCF85063::tm2str(eventParams.next).c_str(), "]");
                break;
            case CronStatus::SKIP:
                LOG_INFO("Cron skipping 1 time ACTIVE event  [", eventName.c_str(), "] next execution time [", drivers::PCF85063::tm2str(eventParams.next).c_str(), "]");
                eventParams.status = CronStatus::ACTIVE;
                break;
            default:
                break;
            }
            if (m_callback)
                m_callback(resp); // execute cronLog callback action
        }
    }
    return true;
}