#include <inttypes.h>  // Include for PRI macros

#include "evse_config.h"
#include "board_config.h"
#include "evse_limits.h"
#include "esp_log.h"
#include "nvs.h"

static const char *TAG = "evse_config";

static nvs_handle_t nvs;

// Configurable parameters
static uint8_t  max_charging_current = MAX_CHARGING_CURRENT_LIMIT;
static uint8_t  grid_max_current = MAX_GRID_CURRENT_LIMIT;
static uint16_t charging_current;
static bool     socket_outlet;
static bool     rcm;
static uint8_t  temp_threshold = 60;
static bool     require_auth;

esp_err_t evse_config_init(void) {
    ESP_LOGD(TAG, "Initializing NVS configuration...");
    ESP_LOGI(TAG, "Opening NVS namespace");
    return nvs_open("evse", NVS_READWRITE, &nvs);
}

void evse_check_defaults(void) {
    esp_err_t err;
    uint8_t u8;
    uint16_t u16;
    uint32_t u32;
    bool needs_commit = false;

    ESP_LOGD(TAG, "Checking default parameters...");

    // Max charging current
    err = nvs_get_u8(nvs, "max_chrg_curr", &u8);
    ESP_LOGD(TAG, "Max charging current read: %d", u8);
    if (err != ESP_OK || u8 < MIN_CHARGING_CURRENT_LIMIT || u8 > MAX_CHARGING_CURRENT_LIMIT) {
        max_charging_current = MAX_CHARGING_CURRENT_LIMIT;
        nvs_set_u8(nvs, "max_chrg_curr", max_charging_current);
        needs_commit = true;
        ESP_LOGD(TAG, "Max charging current adjusted to: %d", max_charging_current);
    } else {
        max_charging_current = u8;
    }

    // Grid max current
    err = nvs_get_u8(nvs, "grid_max_curr", &u8);
    ESP_LOGD(TAG, "Grid max current read: %d", u8);
    if (err != ESP_OK || u8 < MIN_GRID_CURRENT_LIMIT || u8 > MAX_GRID_CURRENT_LIMIT) {
        grid_max_current = MAX_GRID_CURRENT_LIMIT;
        nvs_set_u8(nvs, "grid_max_curr", grid_max_current);
        needs_commit = true;
        ESP_LOGD(TAG, "Grid max current adjusted to: %d", grid_max_current);
    } else {
        grid_max_current = u8;
    }

    // Charging current (decA)
    err = nvs_get_u16(nvs, "def_chrg_curr", &u16);
    ESP_LOGD(TAG, "Charging current read: %d", u16);
    if (err != ESP_OK || u16 < (MIN_CHARGING_CURRENT_LIMIT * 10) || u16 > (max_charging_current * 10)) {
        charging_current = max_charging_current * 10;
        nvs_set_u16(nvs, "def_chrg_curr", charging_current);
        needs_commit = true;
        ESP_LOGD(TAG, "Charging current adjusted to: %d", charging_current);
    } else {
        charging_current = u16;
    }

    err = nvs_get_u8(nvs, "require_auth", &u8);
    require_auth = (err == ESP_OK && u8 <= 1) ? u8 : false;
    if (err != ESP_OK) {
        nvs_set_u8(nvs, "require_auth", require_auth);
        needs_commit = true;
        ESP_LOGD(TAG, "Require auth adjusted to: %d", require_auth);
    }

    err = nvs_get_u8(nvs, "socket_outlet", &u8);
    socket_outlet = (err == ESP_OK && u8) && board_config.proximity;
    if (err != ESP_OK) {
        nvs_set_u8(nvs, "socket_outlet", socket_outlet);
        needs_commit = true;
        ESP_LOGD(TAG, "Socket outlet adjusted to: %d", socket_outlet);
    }

    err = nvs_get_u8(nvs, "rcm", &u8);
    rcm = (err == ESP_OK && u8) && board_config.rcm;
    if (err != ESP_OK) {
        nvs_set_u8(nvs, "rcm", rcm);
        needs_commit = true;
        ESP_LOGD(TAG, "RCM adjusted to: %d", rcm);
    }

    err = nvs_get_u8(nvs, "temp_threshold", &u8);
    temp_threshold = (err == ESP_OK && u8 >= 40 && u8 <= 80) ? u8 : 60;
    if (err != ESP_OK) {
        nvs_set_u8(nvs, "temp_threshold", temp_threshold);
        needs_commit = true;
        ESP_LOGD(TAG, "Temp threshold adjusted to: %d", temp_threshold);
    }

    // Additional limits
    if (nvs_get_u32(nvs, "def_cons_lim", &u32) == ESP_OK) {
        evse_set_consumption_limit(u32);
        ESP_LOGD(TAG, "Consumption limit read and applied: %" PRIu32, u32);  // Updated to PRIu32
    }

    if (nvs_get_u32(nvs, "def_ch_time_lim", &u32) == ESP_OK) {
        evse_set_charging_time_limit(u32);
        ESP_LOGD(TAG, "Charging time limit read and applied: %" PRIu32, u32);  // Updated to PRIu32
    }

    if (nvs_get_u16(nvs, "def_un_pwr_lim", &u16) == ESP_OK) {
        evse_set_under_power_limit(u16);
        ESP_LOGD(TAG, "Under power limit read and applied: %d", u16);
    }

    if (needs_commit) {
        nvs_commit(nvs);
        ESP_LOGD(TAG, "Changes committed to NVS.");
    }
}

// Current
uint8_t evse_get_max_charging_current(void) {
    ESP_LOGI(TAG, "Max charging current read: %d", max_charging_current);
    return max_charging_current;
}

esp_err_t evse_set_max_charging_current(uint8_t value) {
    ESP_LOGI(TAG, "Attempting to set max charging current: %d", value);
    if (value < MIN_CHARGING_CURRENT_LIMIT || value > MAX_CHARGING_CURRENT_LIMIT)
        return ESP_ERR_INVALID_ARG;
    max_charging_current = value;
    nvs_set_u8(nvs, "max_chrg_curr", value);
    nvs_commit(nvs);
    ESP_LOGD(TAG, "Max charging current adjusted to: %d", max_charging_current);
    return ESP_OK;
}

uint8_t grid_get_max_current(void) {
    ESP_LOGD(TAG, "Grid max current read: %d", grid_max_current);
    return grid_max_current;
}

esp_err_t grid_set_max_current(uint8_t value) {
    ESP_LOGD(TAG, "Attempting to set grid max current: %d", value);
    if (value < MIN_GRID_CURRENT_LIMIT || value > MAX_GRID_CURRENT_LIMIT)
        return ESP_ERR_INVALID_ARG;
    grid_max_current = value;
    nvs_set_u8(nvs, "grid_max_curr", value);
    nvs_commit(nvs);
    ESP_LOGD(TAG, "Grid max current adjusted to: %d", grid_max_current);
    return ESP_OK;
}

uint16_t evse_get_charging_current(void) {
    ESP_LOGD(TAG, "Charging current read: %d", charging_current);
    return charging_current;
}

esp_err_t evse_set_charging_current(uint16_t value) {
    ESP_LOGD(TAG, "Attempting to set charging current: %d", value);
    if (value < (MIN_CHARGING_CURRENT_LIMIT * 10) || value > (max_charging_current * 10))
        return ESP_ERR_INVALID_ARG;
    charging_current = value;
    nvs_set_u16(nvs, "def_chrg_curr", value);
    nvs_commit(nvs);
    ESP_LOGD(TAG, "Charging current adjusted to: %d", charging_current);
    return ESP_OK;
}

uint16_t evse_get_default_charging_current(void) {
    uint16_t value;
    nvs_get_u16(nvs, "def_chrg_curr", &value);
    ESP_LOGD(TAG, "Default charging current read: %d", value);
    return value;
}

esp_err_t evse_set_default_charging_current(uint16_t value) {
    ESP_LOGD(TAG, "Attempting to set default charging current: %d", value);
    if (value < (MIN_CHARGING_CURRENT_LIMIT * 10) || value > (max_charging_current * 10))
        return ESP_ERR_INVALID_ARG;
    nvs_set_u16(nvs, "def_chrg_curr", value);
    nvs_commit(nvs);
    ESP_LOGD(TAG, "Default charging current adjusted to: %d", value);
    return ESP_OK;
}

// Socket outlet
bool evse_get_socket_outlet(void) {
    ESP_LOGD(TAG, "Socket outlet read: %d", socket_outlet);
    return socket_outlet;
}

esp_err_t evse_set_socket_outlet(bool value) {
    ESP_LOGD(TAG, "Attempting to set socket outlet: %d", value);
    if (value && !board_config.proximity) return ESP_ERR_INVALID_ARG;
    socket_outlet = value;
    nvs_set_u8(nvs, "socket_outlet", value);
    nvs_commit(nvs);
    ESP_LOGD(TAG, "Socket outlet adjusted to: %d", socket_outlet);
    return ESP_OK;
}

// RCM
bool evse_is_rcm(void) {
    ESP_LOGD(TAG, "RCM read: %d", rcm);
    return rcm;
}

esp_err_t evse_set_rcm(bool value) {
    ESP_LOGD(TAG, "Attempting to set RCM: %d", value);
    if (value && !board_config.rcm) return ESP_ERR_INVALID_ARG;
    rcm = value;
    nvs_set_u8(nvs, "rcm", value);
    nvs_commit(nvs);
    ESP_LOGD(TAG, "RCM adjusted to: %d", rcm);
    return ESP_OK;
}

// Temperature
uint8_t evse_get_temp_threshold(void) {
    ESP_LOGD(TAG, "Temp threshold read: %d", temp_threshold);
    return temp_threshold;
}

esp_err_t evse_set_temp_threshold(uint8_t value) {
    ESP_LOGI(TAG, "Attempting to set temp threshold: %d", value);
    if (value < 40 || value > 80) return ESP_ERR_INVALID_ARG;
    temp_threshold = value;
    nvs_set_u8(nvs, "temp_threshold", value);
    nvs_commit(nvs);
    ESP_LOGI(TAG, "Temp threshold adjusted to: %d", temp_threshold);
    return ESP_OK;
}

// Authentication
bool evse_is_require_auth(void) {
    ESP_LOGD(TAG, "Require auth read: %d", require_auth);
    return require_auth;
}

void evse_set_require_auth(bool value) {
    ESP_LOGI(TAG, "Attempting to set require auth: %d", value);
    require_auth = value;
    nvs_set_u8(nvs, "require_auth", value);
    nvs_commit(nvs);
    ESP_LOGI(TAG, "Require auth adjusted to: %d", require_auth);
}

// Availability
static bool is_available = true;

bool evse_config_is_available(void) {
    ESP_LOGD(TAG, "Checking availability: %d", is_available);
    return is_available;
}

void evse_config_set_available(bool available) {
    ESP_LOGD(TAG, "Setting availability to: %d", available);
    is_available = available;
}

// Enable/Disable
static bool is_enabled = true;

bool evse_config_is_enabled(void) {
    ESP_LOGD(TAG, "Checking if enabled: %d", is_enabled);
    return is_enabled;
}

void evse_config_set_enabled(bool enabled) {
    ESP_LOGD(TAG, "Setting enabled state to: %d", enabled);
    is_enabled = enabled;
}