#include "comms.h"
#include "cJSON.h"
#include "control_fsm.h"
#include "esp_log.h"
#include "esp_system.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "power_mgmt.h"
#include "rf_433.h"
#include "rtc.h"
#include "sensors.h"
#include "storage.h"
#include "version.h"
#include <string.h>

static const char *TAG = "COMMS";

/**
 * Build a JSON object containing complete system status
 */
cJSON* comms_handle_get(void) {
    //ESP_LOGI(TAG, "GET request");
    
    rtc_reset_shutdown_timer();
    
    // Create root JSON object
    cJSON *root = cJSON_CreateObject();
    if (root == NULL) {
        ESP_LOGE(TAG, "Failed to create JSON object");
        return NULL;
    }
    
    // Add basic system info
    cJSON_AddStringToObject(root, "build_version", FIRMWARE_VERSION);
    cJSON_AddStringToObject(root, "build_date", BUILD_DATE);
    cJSON_AddNumberToObject(root, "time", (double)rtc_get_s());
    cJSON_AddBoolToObject(root, "rtc_set", rtc_is_set());
    cJSON_AddNumberToObject(root, "state", fsm_get_state());
    cJSON_AddNumberToObject(root, "voltage", get_battery_V());
    cJSON_AddNumberToObject(root, "remaining_dist", fsm_get_remaining_distance());
    cJSON_AddNumberToObject(root, "next_alarm", (double)rtc_get_next_alarm_s());
    cJSON_AddNumberToObject(root, "board_rev", hw_get_board_rev());
    cJSON_AddNumberToObject(root, "fsm_error", fsm_get_error());

    // Structured error flags (match LED error code bits)
    cJSON *errors = cJSON_CreateObject();
    bool efuse_trip = efuse_get(BRIDGE_AUX) || efuse_get(BRIDGE_JACK) || efuse_get(BRIDGE_DRIVE);
    float bat_v = get_battery_V();
    float low_v = get_param_value_t(PARAM_LOW_PROTECTION_V).f32;
    bool low_bat = (bat_v > 0 && bat_v < low_v);
    bool safety_trip = !get_is_safe();
    bool leash_hit = (fsm_get_remaining_distance() <= 0);

    cJSON_AddBoolToObject(errors, "efuse_aux",   efuse_get(BRIDGE_AUX) != 0);
    cJSON_AddBoolToObject(errors, "efuse_jack",  efuse_get(BRIDGE_JACK) != 0);
    cJSON_AddBoolToObject(errors, "efuse_drive", efuse_get(BRIDGE_DRIVE) != 0);
    cJSON_AddBoolToObject(errors, "low_battery", low_bat);
    cJSON_AddBoolToObject(errors, "rtc_not_set", !rtc_is_set());
    cJSON_AddBoolToObject(errors, "safety_trip", safety_trip);
    cJSON_AddBoolToObject(errors, "leash_hit",   leash_hit);
    // LED error code: bit0=efuse/battery, bit1=RTC, bit2=safety/leash
    uint8_t led_code = 0;
    if (efuse_trip || low_bat)      led_code |= 0b001;
    if (!rtc_is_set())              led_code |= 0b010;
    if (safety_trip || leash_hit)   led_code |= 0b100;
    if (fsm_get_error() != 0 && led_code == 0) led_code = 0b111;
    cJSON_AddNumberToObject(errors, "led_code", led_code);
    cJSON_AddItemToObject(root, "errors", errors);

    // Status message array
    cJSON *msg_array = cJSON_CreateArray();
    if (msg_array == NULL) {
        ESP_LOGE(TAG, "Failed to create msg array");
        cJSON_Delete(root);
        return NULL;
    }

    switch(fsm_get_state()) {
        case STATE_IDLE:
            cJSON_AddItemToArray(msg_array, cJSON_CreateString("IDLE"));
            break;
        case STATE_UNDO_JACK_START:
            cJSON_AddItemToArray(msg_array, cJSON_CreateString("CANCELLING MOVE"));
            break;
        default:
            cJSON_AddItemToArray(msg_array, cJSON_CreateString("MOVING..."));
            break;
    }

    if (leash_hit)
        cJSON_AddItemToArray(msg_array, cJSON_CreateString("DISTANCE LIMIT HIT"));
    if (efuse_get(BRIDGE_AUX))
        cJSON_AddItemToArray(msg_array, cJSON_CreateString("AUX EFUSE TRIP"));
    if (efuse_get(BRIDGE_JACK))
        cJSON_AddItemToArray(msg_array, cJSON_CreateString("JACK EFUSE TRIP"));
    if (efuse_get(BRIDGE_DRIVE))
        cJSON_AddItemToArray(msg_array, cJSON_CreateString("DRIVE EFUSE TRIP"));
    if (low_bat)
        cJSON_AddItemToArray(msg_array, cJSON_CreateString("LOW BATTERY"));
    if (!rtc_is_set())
        cJSON_AddItemToArray(msg_array, cJSON_CreateString("CLOCK NOT SET"));
    if (safety_trip)
        cJSON_AddItemToArray(msg_array, cJSON_CreateString("SAFETY SENSOR BREAK"));

    cJSON_AddItemToObject(root, "msg", msg_array);
    
    // Add parameters object
    cJSON *parameters = cJSON_CreateObject();
    if (parameters == NULL) {
        ESP_LOGE(TAG, "Failed to create parameters object");
        cJSON_Delete(root);
        return NULL;
    }
    
    // Add all parameters
    for (param_idx_t i = 0; i < NUM_PARAMS; i++) {
        const char *name = get_param_name(i);
        param_value_t value = get_param_value_t(i);
        
        switch (get_param_type(i)) {
            case PARAM_TYPE_f32:
                cJSON_AddNumberToObject(parameters, name, value.f32);
                break;
            case PARAM_TYPE_f64:
                cJSON_AddNumberToObject(parameters, name, value.f64);
                break;
            case PARAM_TYPE_i32:
                cJSON_AddNumberToObject(parameters, name, value.i32);
                break;
            case PARAM_TYPE_i16:
                cJSON_AddNumberToObject(parameters, name, value.i16);
                break;
            case PARAM_TYPE_u32:
                cJSON_AddNumberToObject(parameters, name, value.u32);
                break;
            case PARAM_TYPE_u16:
                cJSON_AddNumberToObject(parameters, name, value.u16);
                break;
            case PARAM_TYPE_str:
                cJSON_AddStringToObject(parameters, name, get_param_string(i));
                break;
            default:
                cJSON_AddNullToObject(parameters, name);
                break;
        }
    }
    
    cJSON_AddItemToObject(root, "parameters", parameters);
    
    return root;
}

/**
 * Process a POST request with JSON data
 */
esp_err_t comms_handle_post(cJSON *root, cJSON **response_json) {
    //ESP_LOGI(TAG, "POST request");
    
    if (root == NULL || response_json == NULL) {
        ESP_LOGE(TAG, "Invalid arguments to comms_handle_post");
        return ESP_FAIL;
    }
    
    rtc_reset_shutdown_timer();
    
    bool cmd_executed = false;
    bool sleep_requested = false;
    bool reboot_requested = false;
    bool wifi_params_changed = false;
    bool wifi_restart_requested = false;
    const char *error_msg = NULL;
    int params_updated = 0;
    int params_failed = 0;
    
    // Process time if present
    cJSON *time = cJSON_GetObjectItem(root, "time");
    if (cJSON_IsNumber(time)) {
        int64_t new_time = (int64_t)cJSON_GetNumberValue(time);
        ESP_LOGI(TAG, "Setting time to %lld", (long long)new_time);
        rtc_set_s(new_time);
    }
    
    // Process remaining_dist if present
    cJSON *remaining_dist = cJSON_GetObjectItem(root, "remaining_dist");
    if (cJSON_IsNumber(remaining_dist)) {
        int64_t new_dist = (int64_t)cJSON_GetNumberValue(remaining_dist);
        ESP_LOGI(TAG, "Setting remaining_dist to %lld", new_dist);
        fsm_set_remaining_distance(new_dist);
    }
    
    // Process command if present
    cJSON *cmd = cJSON_GetObjectItem(root, "cmd");
    if (cJSON_IsString(cmd)) {
        const char *cmd_str = cmd->valuestring;
       // ESP_LOGI(TAG, "Executing command: %s", cmd_str);
        
        if (strcmp(cmd_str, "start") == 0) {
            fsm_request(FSM_CMD_START);
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "stop") == 0) {
            fsm_request(FSM_CMD_STOP);
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "undo") == 0) {
            fsm_request(FSM_CMD_UNDO);
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "fwd") == 0) {
            pulse_override(FSM_OVERRIDE_DRIVE_FWD);
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "rev") == 0) {
            pulse_override(FSM_OVERRIDE_DRIVE_REV);
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "up") == 0) {
            pulse_override(FSM_OVERRIDE_JACK_UP);
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "down") == 0) {
            pulse_override(FSM_OVERRIDE_JACK_DOWN);
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "aux") == 0) {
            pulse_override(FSM_OVERRIDE_AUX);
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "reboot") == 0) {
            reboot_requested = true;
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "sleep") == 0) {
            sleep_requested = true;
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "rf_clear_temp") == 0) {
            rf_433_clear_temp_keycodes();
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "rf_disable") == 0) {
            rf_433_disable_controls();
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "rf_enable") == 0) {
            rf_433_enable_controls();
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "rf_learn") == 0) {
            // Start learning for a specific channel
            cJSON *channel = cJSON_GetObjectItem(root, "channel");
            if (cJSON_IsNumber(channel)) {
                int ch = (int)cJSON_GetNumberValue(channel);
                if (ch >= 0 && ch < NUM_RF_BUTTONS) {
                    rf_433_learn_keycode(ch);
                    cmd_executed = true;
                } else if (ch == -1) {
                    rf_433_cancel_learn_keycode();
                    cmd_executed = true;
                } else {
                    error_msg = "Invalid channel number";
                }
            } else {
                error_msg = "rf_learn requires channel parameter";
            }
        }
        else if (strcmp(cmd_str, "rf_set_temp") == 0) {
            cJSON *index = cJSON_GetObjectItem(root, "index");
            cJSON *code = cJSON_GetObjectItem(root, "code");
            if (cJSON_IsNumber(index) && cJSON_IsNumber(code)) {
                int idx = (int)cJSON_GetNumberValue(index);
                int32_t rf_code = (int32_t)cJSON_GetNumberValue(code);
                rf_433_set_temp_keycode(idx, rf_code);
                cmd_executed = true;
            } else {
                error_msg = "rf_set_temp requires index and code parameters";
            }
        }
        else if (strcmp(cmd_str, "rf_status") == 0) {
            // Return current temp keycodes
            cJSON *response = cJSON_CreateObject();
            cJSON *codes_array = cJSON_CreateArray();
            
            for (int i = 0; i < 4; i++) {  // Only return first 4 for web UI
                int32_t code = rf_433_get_temp_keycode(i);
                cJSON_AddItemToArray(codes_array, cJSON_CreateNumber(code));
            }
            
            cJSON_AddItemToObject(response, "codes", codes_array);
            *response_json = response;
            return ESP_OK;
        }
        else if (strcmp(cmd_str, "cal_jack_start") == 0) {
            fsm_request(FSM_CMD_CALIBRATE_JACK_PREP);
            ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_JACK_PREP");
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "cal_drive_start") == 0) {
            fsm_request(FSM_CMD_CALIBRATE_DRIVE_PREP);
            ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_DRIVE_PREP");
            cmd_executed = true;
        }
        else if (strcmp(cmd_str, "cal_get") == 0) {
            ESP_LOGI(TAG, "CAL_GET");
            
            // Build JSON response with calibration values
            cJSON *response = cJSON_CreateObject();
            cJSON_AddItemToObject(response, "e", cJSON_CreateNumber(fsm_get_cal_e()));
            cJSON_AddItemToObject(response, "t", cJSON_CreateNumber(fsm_get_cal_t()));
            
            *response_json = response;
            return ESP_OK;
        }
        else if (strcmp(cmd_str, "set_board_rev") == 0) {
            cJSON *rev = cJSON_GetObjectItem(root, "board_rev");
            if (cJSON_IsNumber(rev)) {
                uint16_t r = (uint16_t)cJSON_GetNumberValue(rev);
                if (hw_set_board_rev(r) == ESP_OK) {
                    ESP_LOGI(TAG, "Board rev set to %u", r);
                    cmd_executed = true;
                } else {
                    error_msg = "Failed to write board_rev to NVS";
                }
            } else {
                error_msg = "set_board_rev requires board_rev parameter";
            }
        }
        else {
            ESP_LOGW(TAG, "Unknown command: %s", cmd_str);
            error_msg = "Unknown command";
        }
    }
    
    // Process batch parameter updates if present
    cJSON *parameters = cJSON_GetObjectItem(root, "parameters");
    if (cJSON_IsObject(parameters)) {
        // Process individual parameter updates (direct key-value pairs)
        cJSON *item = NULL;
        cJSON_ArrayForEach(item, parameters) {
            const char *key = item->string;
            ESP_LOGI(TAG, "Processing parameter: %s", key);
            
            // Find parameter index by name
            param_idx_t param_idx = NUM_PARAMS;
            for (param_idx_t i = 0; i < NUM_PARAMS; i++) {
                if (strcmp(get_param_name(i), key) == 0) {
                    param_idx = i;
                    break;
                }
            }
            
            if (param_idx == NUM_PARAMS) {
                ESP_LOGW(TAG, "Unknown parameter: %s", key);
                params_failed++;
                continue;
            }

            if (param_idx == PARAM_WIFI_SSID ||
                param_idx == PARAM_WIFI_PASS ||
                param_idx == PARAM_WIFI_CHANNEL ||
                param_idx == PARAM_NET_SSID  ||
                param_idx == PARAM_NET_PASS) {
                wifi_params_changed = true;
            }
            
            cJSON *value_json = cJSON_GetObjectItem(parameters, key);
            
            // Set parameter value based on type
            switch (get_param_type(param_idx)) {
                case PARAM_TYPE_f32:
                    if (cJSON_IsNumber(value_json)) {
                        set_param_value_t(param_idx, (param_value_t){.f32 = value_json->valuedouble});
                        params_updated++;
                    } else {
                        ESP_LOGW(TAG, "Type mismatch for parameter: %s", key);
                        params_failed++;
                    }
                    break;
                case PARAM_TYPE_f64:
                    if (cJSON_IsNumber(value_json)) {
                        set_param_value_t(param_idx, (param_value_t){.f64 = value_json->valuedouble});
                        params_updated++;
                    } else {
                        ESP_LOGW(TAG, "Type mismatch for parameter: %s", key);
                        params_failed++;
                    }
                    break;
                case PARAM_TYPE_i32:
                    if (cJSON_IsNumber(value_json)) {
                        set_param_value_t(param_idx, (param_value_t){.i32 = value_json->valueint});
                        params_updated++;
                    } else {
                        ESP_LOGW(TAG, "Type mismatch for parameter: %s", key);
                        params_failed++;
                    }
                    break;
                case PARAM_TYPE_i16:
                    if (cJSON_IsNumber(value_json)) {
                        set_param_value_t(param_idx, (param_value_t){.i16 = value_json->valueint});
                        params_updated++;
                    } else {
                        ESP_LOGW(TAG, "Type mismatch for parameter: %s", key);
                        params_failed++;
                    }
                    break;
                case PARAM_TYPE_u32:
                    if (cJSON_IsNumber(value_json)) {
                        set_param_value_t(param_idx, (param_value_t){.u32 = value_json->valueint});
                        params_updated++;
                    } else {
                        ESP_LOGW(TAG, "Type mismatch for parameter: %s", key);
                        params_failed++;
                    }
                    break;
                case PARAM_TYPE_u16:
                    if (cJSON_IsNumber(value_json)) {
                        set_param_value_t(param_idx, (param_value_t){.u16 = value_json->valueint});
                        params_updated++;
                    } else {
                        ESP_LOGW(TAG, "Type mismatch for parameter: %s", key);
                        params_failed++;
                    }
                    break;
                case PARAM_TYPE_str:
                    if (cJSON_IsString(value_json)) {
                        set_param_string(param_idx, value_json->valuestring);
                        params_updated++;
                    } else {
                        ESP_LOGW(TAG, "Type mismatch for parameter: %s", key);
                        params_failed++;
                    }
                    break;
                default:
                    ESP_LOGW(TAG, "Unknown type for parameter: %s", key);
                    params_failed++;
                    break;
            }
        }
        
        if (params_updated > 0) {
            rtc_schedule_next_alarm();
            commit_params();
            if (wifi_params_changed) {
                ESP_LOGI(TAG, "WiFi params changed — restarting WiFi AP");
                wifi_restart_requested = true;
            }
        }
    }
    
    // Build response
    cJSON *response = cJSON_CreateObject();
    if (response == NULL) {
        ESP_LOGE(TAG, "Failed to create response JSON");
        return ESP_FAIL;
    }
    
    if (wifi_restart_requested) {
        cJSON_AddStringToObject(response, "status", "ok");
        cJSON_AddStringToObject(response, "message", "Restarting WiFi AP...");
        cJSON_AddBoolToObject(response, "wifi_restart", true);
        *response_json = response;
        return ESP_OK;
    }

    if (reboot_requested) {
        cJSON_AddStringToObject(response, "status", "ok");
        cJSON_AddStringToObject(response, "message", "Rebooting...");
        cJSON_AddBoolToObject(response, "reboot", true);
        *response_json = response;
        return ESP_OK;
    }
    
    if (sleep_requested) {
        cJSON_AddStringToObject(response, "status", "ok");
        cJSON_AddStringToObject(response, "message", "Sleeping...");
        cJSON_AddBoolToObject(response, "sleep", true);
        *response_json = response;
        return ESP_OK;
    }
    
    if (error_msg != NULL) {
        cJSON_AddStringToObject(response, "status", "error");
        cJSON_AddStringToObject(response, "message", error_msg);
        *response_json = response;
        return ESP_FAIL;
    }
    
    cJSON_AddStringToObject(response, "status", "ok");
    cJSON_AddNumberToObject(response, "params_updated", params_updated);
    cJSON_AddNumberToObject(response, "params_failed", params_failed);
    cJSON_AddBoolToObject(response, "cmd_executed", cmd_executed);
    
    *response_json = response;
    return ESP_OK;
}