/**
 * @file debugger.cpp
 * @brief Implementation of debugging functions for monitoring and diagnostics.
 *
 * This file contains the implementation of various debugging functions to monitor
 * and diagnose the system. It includes functions to print system information, WiFi
 * details, EEPROM status, dump configuration settings, dump persistence data, show
 * Diagnostic Trouble Codes (DTCs), and more.
 *
 * @author Marcel Peterkau
 * @date 09.04.2024
 */

#include "debugger.h"

DebugStatus_t DebuggerStatus[dbg_cntElements];

void processCmdDebug(String command);
void Debug_formatCFG();
void Debug_formatPersistence();
void Debug_printSystemInfo();
void Debug_printWifiInfo();
void Debug_CheckEEPOM(bool autocorrect);
void Debug_dumpConfig();
void Debug_dumpPersistance();
void Debug_ShowDTCs();
void Debug_dumpGlobals();
void Debug_printHelp();
const char *uint32_to_binary_string(uint32_t num);

/**
 * @brief Initializes the debugger by setting the initial status for different debug ports.
 *        Serial debug output is turned off.
 */
void initDebugger()
{
    // Set the initial status of debug ports
    DebuggerStatus[dbg_Serial] = disabled;
    DebuggerStatus[dbg_Webui] = disabled;

    // Disable serial debug output
    Serial.setDebugOutput(false);
}
/**
 * @brief Processes incoming debug commands from the Serial interface.
 *        It reads characters from Serial and interprets them as commands.
 *        The recognized commands are processed accordingly.
 */
void Debug_Process()
{
    // Enumeration for tracking the state of input processing
    typedef enum InputProcessed_e
    {
        IDLE,         ///< No command processing is in progress
        CMD_COMPLETE, ///< Received a complete command
        CMD_ABORT,    ///< Received an abort command (Esc)
        CMD_OVERFLOW  ///< Input buffer overflow occurred
    } InputProcessed_t;

    static unsigned int inputCnt = 0;       ///< Counter for characters in the input buffer
    static char inputBuffer[32];            ///< Buffer to store the received characters
    InputProcessed_t InputProcessed = IDLE; ///< State variable for input processing

    // Check if there are characters available in the Serial input buffer
    if (Serial.available())
    {
        char inputChar = Serial.read();

        // Process the received character based on its value
        switch (inputChar)
        {
        case '\n':
            inputBuffer[inputCnt] = 0; // terminate the String
            inputCnt = 0;
            InputProcessed = CMD_COMPLETE;
            Serial.write(inputChar);
            break;

        case 0x1B: // Esc
            inputBuffer[0] = 0;
            inputCnt = 0;
            InputProcessed = CMD_ABORT;
            break;

        case 0x21 ... 0x7E: // it's a real letter or sign and not some control-chars
            inputBuffer[inputCnt] = inputChar;
            inputCnt++;
            Serial.write(inputChar);
            break;

        default:
            break;
        }

        // Check for input buffer overflow
        if (inputCnt > sizeof(inputBuffer))
        {
            inputCnt = 0;
            inputBuffer[sizeof(inputBuffer) - 1] = 0; // terminate the String
            InputProcessed = CMD_OVERFLOW;
        }
    }

    // Process the command based on the detected state of input processing
    switch (InputProcessed)
    {
    case CMD_ABORT:
        Debug_pushMessage("Abort\n");
        break;

    case CMD_COMPLETE:
        processCmdDebug(String(inputBuffer));
        break;

    case CMD_OVERFLOW:
        Debug_pushMessage("Input buffer overflow\n");
        break;

    default:
        break;
    }

    if (InputProcessed != IDLE)
        Serial.print(">");

    InputProcessed = IDLE;
}
/**
 * @brief Sets the status of a specific debug port (Serial or WebUI).
 *        Updates the status in the DebuggerStatus array and provides debug messages.
 *
 * @param port   The debug port to set the status for (dbg_Serial or dbg_Webui).
 * @param status The status to set (enabled or disabled).
 */
void SetDebugportStatus(DebugPorts_t port, DebugStatus_t status)
{
    // Display a debug message based on the provided status
    if (status == disabled)
        Debug_pushMessage("Disable DebugPort %s\n", sDebugPorts[port]);

    // Update the status in the DebuggerStatus array
    DebuggerStatus[port] = status;

    // Display a debug message based on the updated status
    if (status == enabled)
        Debug_pushMessage("Enabled DebugPort %s\n", sDebugPorts[port]);
}

/**
 * @brief Pushes a formatted debug message to the enabled debug ports (Serial or WebUI).
 *
 * @param format The format string for the debug message.
 * @param ...    Additional arguments for formatting the message.
 */
void Debug_pushMessage(const char *format, ...)
{
    // Check if either the Serial or WebUI debug port is enabled
    if ((DebuggerStatus[dbg_Serial] == enabled) || (DebuggerStatus[dbg_Webui] == enabled))
    {
        char buff[128]; // Buffer to hold the formatted message
        va_list arg;    // Variable argument list for vsnprintf
        va_start(arg, format);

        // Format the message and store it in the buffer
        vsnprintf(buff, sizeof(buff), format, arg);
        va_end(arg);

        // Send the message to the Serial debug port if enabled
        if (DebuggerStatus[dbg_Serial] == enabled)
        {
            Serial.print(buff);
        }

        // Push the message to the WebUI debug port if enabled
        if (DebuggerStatus[dbg_Webui] == enabled)
        {
            Websocket_PushLiveDebug(String(buff));
        }
    }
}

/**
 * @brief Processes a debug command and performs corresponding actions.
 *
 * @param command The debug command to be processed.
 */
void processCmdDebug(String command)
{
    // Check the received command and execute corresponding actions
    if (command == "help")
        Debug_printHelp();
    else if (command == "sysinfo")
        Debug_printSystemInfo();
    else if (command == "netinfo")
        Debug_printWifiInfo();
    else if (command == "formatCFG")
        Debug_formatCFG();
    else if (command == "formatPDS")
        Debug_formatPersistence();
    else if (command == "checkEE")
        Debug_CheckEEPOM(false);
    else if (command == "checkEEfix")
        Debug_CheckEEPOM(true);
    else if (command == "dumpEE1k")
        dumpEEPROM(0, 1024);
    else if (command == "dumpEE")
        dumpEEPROM(0, EEPROM_SIZE_BYTES);
    else if (command == "killEE")
        writeSequentialToEEPROM(0, 1024);
    else if (command == "zeroEE")
        writeZeroToEEPROM(0, 1024);
    else if (command == "resetPageEE")
        MovePersistencePage_EEPROM(true);
    else if (command == "dumpCFG")
        Debug_dumpConfig();
    else if (command == "dumpPDS")
        Debug_dumpPersistance();
    else if (command == "saveEE")
        globals.requestEEAction = EE_ALL_SAVE;
    else if (command == "dumpGlobals")
        Debug_dumpGlobals();
    else if (command == "sdbg")
        SetDebugportStatus(dbg_Serial, enabled);
    else if (command == "dtc_show")
        Debug_ShowDTCs();
    else if (command == "dtc_clear")
        ClearAllDTC();
    else if (command == "dtc_crit")
        MaintainDTC(DTC_FAKE_DTC_CRIT, true, millis());
    else if (command == "dtc_warn")
        MaintainDTC(DTC_FAKE_DTC_WARN, true, millis());
    else if (command == "dtc_info")
        MaintainDTC(DTC_FAKE_DTC_INFO, true, millis());
    else if (command == "notify_error")
        Websocket_PushNotification("Debug Error Notification", error);
    else if (command == "notify_warning")
        Websocket_PushNotification("Debug Warning Notification", warning);
    else if (command == "notify_success")
        Websocket_PushNotification("Debug Success Notification", success);
    else if (command == "notify_info")
        Websocket_PushNotification("Debug Info Notification", info);
    else
        Debug_pushMessage("unknown Command\n");
}

/**
 * @brief Formats the Config-EEPROM and resets it to default values.
 *        Prints a debug message after formatting.
 */
void Debug_formatCFG()
{
    Debug_pushMessage("Formatting Config-EEPROM and resetting to default\n");
    FormatConfig_EEPROM();
}

/**
 * @brief Formats the Persistence-EEPROM and resets it to default values.
 *        Prints a debug message after formatting.
 */
void Debug_formatPersistence()
{
    Debug_pushMessage("Formatting Persistence-EEPROM and resetting to default\n");
    FormatPersistence_EEPROM();
}

/**
 * @brief Prints system information and status to the debug output.
 */
void Debug_printSystemInfo()
{
    Debug_pushMessage("Hostname: %s\n", globals.DeviceName);

    FlashMode_t ideMode = ESP.getFlashChipMode();
    Debug_pushMessage("Sdk version: %s\n", ESP.getSdkVersion());
    Debug_pushMessage("Core Version: %s\n", ESP.getCoreVersion().c_str());
    Debug_pushMessage("Boot Version: %u\n", ESP.getBootVersion());
    Debug_pushMessage("Boot Mode: %u\n", ESP.getBootMode());
    Debug_pushMessage("CPU Frequency: %u MHz\n", ESP.getCpuFreqMHz());
    Debug_pushMessage("Reset reason: %s\n", ESP.getResetReason().c_str());
    Debug_pushMessage("Flash Size: %d\n", ESP.getFlashChipRealSize());
    Debug_pushMessage("Flash Size IDE: %d\n", ESP.getFlashChipSize());
    Debug_pushMessage("Flash ide mode:  %s\n", (ideMode == FM_QIO ? "QIO" : ideMode == FM_QOUT ? "QOUT"
                                                                        : ideMode == FM_DIO    ? "DIO"
                                                                        : ideMode == FM_DOUT   ? "DOUT"
                                                                                               : "UNKNOWN"));
    Debug_pushMessage("OTA-Pass: %s\n", QUOTE(ADMIN_PASSWORD));
    Debug_pushMessage("Git-Revision: %s\n", constants.GitHash);
    Debug_pushMessage("Sw-Version: %d.%02d\n", constants.FW_Version_major, constants.FW_Version_minor);
}

/**
 * @brief Dumps the current configuration parameters to the debug output.
 */
void Debug_dumpConfig()
{
    Debug_pushMessage("batteryType: %d\n", ConfigData.batteryType);
    Debug_pushMessage("Faction_1_Name: %s\n", ConfigData.Faction_1_Name);
    Debug_pushMessage("Faction_1_Name: %s\n", ConfigData.Faction_2_Name);
    Debug_pushMessage("Faction_1_Name: %s\n", ConfigData.Faction_3_Name);
    Debug_pushMessage("active_faction_on_reboot: %d\n", ConfigData.active_faction_on_reboot);
    Debug_pushMessage("wifi_autoconnect: %d\n", ConfigData.wifi_autoconnect);
    Debug_pushMessage("wifi_ap_password: %s\n", ConfigData.wifi_ap_password);
    Debug_pushMessage("wifi_ap_ssid: %s\n", ConfigData.wifi_ap_ssid);
    Debug_pushMessage("wifi_client_ssid: %s\n", ConfigData.wifi_client_ssid);
    Debug_pushMessage("wifi_client_password: %s\n", ConfigData.wifi_client_password);
    Debug_pushMessage("EEPROM_Version: %d\n", ConfigData.EEPROM_Version);
    Debug_pushMessage("checksum: 0x%08X\n", ConfigData.checksum);
}

/**
 * @brief Dumps the global variables and their values to the debug output.
 */
void Debug_dumpGlobals()
{
    Debug_pushMessage("systemStatus: %d\n", globals.systemStatus);
    Debug_pushMessage("battery_level: %d\n", globals.battery_level);
    Debug_pushMessage("loadvoltage_mV: %d\n", globals.loadvoltage_mV);
    Debug_pushMessage("requestEEAction: %d\n", globals.requestEEAction);
    Debug_pushMessage("DeviceName: %s\n", globals.DeviceName);
    Debug_pushMessage("FlashVersion: %s\n", globals.FlashVersion);
    Debug_pushMessage("eePersistanceAdress: %d\n", globals.eePersistanceAdress);
    Debug_pushMessage("hasDTC: %d\n", globals.hasDTC);
}

/**
 * @brief Dumps the persistence data variables and their values to the debug output.
 */
void Debug_dumpPersistance()
{
    Debug_pushMessage("writeCycleCounter: %d\n", PersistenceData.writeCycleCounter);
    Debug_pushMessage("activeFaction: %d\n", PersistenceData.activeFaction);
    Debug_pushMessage("faction_1_timer: %d\n", PersistenceData.faction_1_timer);
    Debug_pushMessage("faction_2_timer: %d\n", PersistenceData.faction_2_timer);
    Debug_pushMessage("faction_3_timer: %d\n", PersistenceData.faction_3_timer);
    Debug_pushMessage("checksum: %d\n", PersistenceData.checksum);
    Debug_pushMessage("PSD Adress: 0x%04X\n", globals.eePersistanceAdress);
}

/**
 * @brief Prints information related to WiFi to the debug output.
 */
void Debug_printWifiInfo()
{
    Debug_pushMessage("IP Adress: %s\n", WiFi.localIP().toString().c_str());
}

/**
 * @brief Checks the EEPROM data integrity by calculating and comparing checksums.
 *        Prints the result to the debug output.
 */
void Debug_CheckEEPOM(bool autocorrect)
{
    // Check PersistenceData EEPROM checksum
    uint32_t checksum = PersistenceData.checksum;
    PersistenceData.checksum = 0;

    if (Checksum_EEPROM((uint8_t *)&PersistenceData, sizeof(PersistenceData)) == checksum)
    {
        Debug_pushMessage("PersistenceData EEPROM Checksum OK\n");
    }
    else
    {
        Debug_pushMessage("PersistenceData EEPROM Checksum BAD\n");
    }

    PersistenceData.checksum = checksum;

    // Check ConfigData EEPROM checksum
    checksum = ConfigData.checksum;
    ConfigData.checksum = 0;

    if (Checksum_EEPROM((uint8_t *)&ConfigData, sizeof(ConfigData)) == checksum)
    {
        Debug_pushMessage("ConfigData EEPROM Checksum OK\n");
    }
    else
    {
        Debug_pushMessage("ConfigData EEPROM Checksum BAD\n");
    }
    ConfigData.checksum = checksum;

    uint32_t sanitycheck = ConfigSanityCheck(autocorrect);

    if (sanitycheck == 0)
    {
        Debug_pushMessage("ConfigData Sanity Check OK\n");
    }
    else
    {
        Debug_pushMessage("ConfigData Sanity Check BAD: %s\n", uint32_to_binary_string(sanitycheck));
    }
}

/**
 * @brief Displays Diagnostic Trouble Codes (DTCs) along with their timestamps,
 *        status, and severity in a formatted manner.
 */
void Debug_ShowDTCs()
{
    char buff_timestamp[16]; // Format: DD-hh:mm:ss:xxx
    char buff_active[9];

    // Header for the DTC display
    Debug_pushMessage("\n      timestamp | DTC-Nr. |   status | severity\n");

    // Iterate through DTCStorage and display each entry
    for (uint32_t i = 0; i < MAX_DTC_STORAGE; i++)
    {
        if (DTCStorage[i].Number < DTC_LAST_DTC)
        {
            // Format timestamp
            sprintf(buff_timestamp, "%02d-%02d:%02d:%02d:%03d",
                    DTCStorage[i].timestamp / 86400000,    // Days
                    DTCStorage[i].timestamp / 360000 % 24, // Hours
                    DTCStorage[i].timestamp / 60000 % 60,  // Minutes
                    DTCStorage[i].timestamp / 1000 % 60,   // Seconds
                    DTCStorage[i].timestamp % 1000);       // Milliseconds

            // Determine DTC status
            if (DTCStorage[i].active == DTC_ACTIVE)
                strcpy(buff_active, "active");
            else if (DTCStorage[i].active == DTC_PREVIOUS)
                strcpy(buff_active, "previous");
            else
                strcpy(buff_active, "none");

            // Display DTC information
            Debug_pushMessage("%s   %7d   %8s   %8d\n", buff_timestamp, DTCStorage[i].Number, buff_active);
        }
    }
}

/**
 * @brief Displays the help commands for debugging through Serial or WebUI.
 *        Each command is printed individually in a formatted manner.
 */
void Debug_printHelp()
{
    char buff[64];

    // Iterate through helpCmd and display each command
    for (unsigned int i = 0; i < sizeof(helpCmd) / 63; i++)
    {
        // Copy a portion of helpCmd to buff for display
        memcpy_P(buff, (helpCmd + (i * 63)), 63);
        buff[63] = 0;

        // Display the help command
        Debug_pushMessage(buff);
    }
}

/**
 * @brief Convert a uint32_t value to a binary string with nibbles separated by a space.
 *
 * This function takes a uint32_t value and converts it to a binary string
 * representation. The binary string is stored in a static buffer and returned
 * as a const char pointer. Each nibble (4 bits) in the binary representation
 * is separated by a space. The buffer is overwritten on subsequent calls to
 * this function.
 *
 * @param num The uint32_t value to convert.
 * @return A pointer to a const char string containing the binary representation
 * of the input number with nibbles separated by a space.
 */
const char *uint32_to_binary_string(uint32_t num)
{
    static char binary_str[65]; // 32 bits + 31 spaces + null terminator
    int i, j;
    for (i = 31, j = 0; i >= 0; i--, j++)
    {
        binary_str[j] = ((num >> i) & 1) ? '1' : '0';
        if (i % 4 == 0 && i != 0)
        {
            binary_str[++j] = ' '; // Insert space after every nibble
        }
    }
    binary_str[j] = '\0'; // Null terminator
    return binary_str;
}