#pragma once
#define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG

// Serial debug flag
// #define DEBUG

// Arduino Libraries
#include <Arduino.h>
#include <DebugLog.h>
#include "utils.h"
#include <memory>
#include <mutex>
#include <filesystem>
#include <FS.h>
#include <LittleFS.h>
#include <datasave.h>
#include <functional>

// ISR
#include "isr.h"

// DEVICES
#include "devices.h"

// Global Variables and Flags
const uint32_t spark_timeout_max = 500; // in microseconds

// Debug Variables
#ifdef DEBUG
static const std::map<const uint32_t, const char *> names = {
    {TRIG_FLAG_12P, "TRIG_FLAG_12P"},
    {TRIG_FLAG_12N, "TRIG_FLAG_12N"},
    {TRIG_FLAG_34P, "TRIG_FLAG_34P"},
    {TRIG_FLAG_34N, "TRIG_FLAG_34N"},
    {SPARK_FLAG_12, "SPARK_FLAG_12"},
    {SPARK_FLAG_34, "SPARK_FLAG_34"},
    {SPARK_FLAG_TIMEOUT, "SPARK_FLAG_TIMEOUT"},
};
#endif

class rtIgnitionTask
{
    using PSHistory = PSRAMVector<ignitionBoxStatus>;

public:
    // RT task Interrupt parameters
    struct rtTaskInterruptParams
    {
        void (*isr_ptr)(void *);
        const uint8_t trig_pin_12p;
        const uint8_t trig_pin_12n;
        const uint8_t trig_pin_34p;
        const uint8_t trig_pin_34n;
        const uint8_t spark_pin_12;
        const uint8_t spark_pin_34;
    };

    // RT Task Peak Detector Reset pins
    struct rtTaskIOParams
    {
        const uint32_t expander_addr;
        const uint32_t pot_cs_12;
        const uint32_t pot_cs_34;
        const uint32_t ss_force;
        const uint32_t ss_inhibit_12;
        const uint32_t ss_inhibit_34;
        const uint32_t sh_disch_12;
        const uint32_t sh_disch_34;
        const uint32_t sh_arm_12;
        const uint32_t sh_arm_34;
        const uint32_t relay_in_12;
        const uint32_t relay_in_34;
        const uint32_t relay_out_12;
        const uint32_t relay_out_34;
    };

    // RT task parameters
    struct rtTaskParams
    {
        bool rt_running; // run flag, false to terminate
        const std::string name;
        const uint32_t rt_stack_size;
        const uint32_t rt_priority;
        const rtTaskInterruptParams rt_int; // interrupt pins to attach
        const rtTaskIOParams rt_io;         // reset ping for peak detectors
        QueueHandle_t rt_queue;             // queue for task io
        Devices *dev;
    };

    enum rtTaskStatus
    {
        INIT,
        OK,
        ERROR,
        RUNNING,
        IDLE,
        STOPPED
    };

public:
    rtIgnitionTask(const rtTaskParams params, const uint32_t history_size, const uint32_t queue_size, const uint8_t core, std::mutex &fs_mutex, fs::FS &filesystem = LittleFS);
    ~rtIgnitionTask();

    void run();
    const bool start();
    const bool stop();

    const ignitionBoxStatus getLast() const;
    const ignitionBoxStatusFiltered getFiltered() const;

    const rtTaskStatus getStatus() const;

    void enableSave(const bool enable, const std::filesystem::path filename);

    void onMessage(std::function<void(ignitionBoxStatusFiltered)> callaback);

private:
    void saveHistory(const rtIgnitionTask::PSHistory &history, const std::filesystem::path &file_name);

private: // static functions for FreeRTOS
    static void rtIgnitionTask_manager(void *pvParameters);
    static void rtIgnitionTask_realtime(void *pvParameters);

private:
    bool m_running = true;
    rtTaskStatus m_manager_status = INIT;
    std::string m_name;

    rtTaskParams m_params;
    const uint8_t m_core;

    TaskHandle_t m_rt_handle = nullptr;
    TaskHandle_t m_manager_handle = nullptr;
    QueueHandle_t m_queue = nullptr;

    bool m_enable_save = false;
    std::filesystem::path m_history_path;
    const uint32_t m_max_history;
    PSHistory m_history_0;
    PSHistory m_history_1;
    std::unique_ptr<PSHistory> m_active_history;
    std::unique_ptr<PSHistory> m_save_history;
    fs::FS &m_filesystem;
    std::mutex &m_fs_mutex;

    bool m_partial_save = false;
    bool m_first_save = true;

    uint32_t m_counter_status = 0;
    uint32_t m_last_data = 0;
    ignitionBoxStatus m_last_status;
    ignitionBoxStatusFiltered m_info_filtered;

    std::function<void(ignitionBoxStatusFiltered)> m_on_message_cb = nullptr;

    static const uint32_t c_idle_time = 10000;       // in mS
    static const uint32_t c_spark_timeout_max = 500; // uS
    static const uint8_t c_adc_time = 4;             // in mS
    static const uint8_t c_io_time = 2;              // in mS
};