#include "storage.hpp"

#include <cstring>

#include "esp_log.h"
#include "nvs.h"

namespace {

constexpr const char *TAG = "storage";

nvs_handle_t s_handle = 0;
bool s_open = false;

} // namespace

namespace Storage {

esp_err_t begin(const char *name_space) {
    esp_err_t err = nvs_open(name_space, NVS_READWRITE, &s_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "nvs_open(%s) failed: %s", name_space, esp_err_to_name(err));
        return err;
    }
    s_open = true;
    return ESP_OK;
}

bool hasKey(const char *key) {
    if (!s_open) {
        return false;
    }
    // nvs_get_u32() requires a real output pointer, so probe with a scratch value.
    uint32_t scratch = 0;
    if (nvs_get_u32(s_handle, key, &scratch) == ESP_OK) {
        return true;
    }
    size_t len = 0;
    return nvs_get_blob(s_handle, key, nullptr, &len) == ESP_OK;
}

uint32_t getUInt(const char *key, uint32_t default_value) {
    if (!s_open) {
        return default_value;
    }
    uint32_t value = default_value;
    if (nvs_get_u32(s_handle, key, &value) != ESP_OK) {
        return default_value;
    }
    return value;
}

size_t getBytes(const char *key, void *out, size_t max_len) {
    if (!s_open || out == nullptr) {
        return 0;
    }
    size_t len = max_len;
    if (nvs_get_blob(s_handle, key, out, &len) != ESP_OK) {
        return 0;
    }
    return len;
}

esp_err_t putUInt(const char *key, uint32_t value) {
    if (!s_open) {
        return ESP_ERR_INVALID_STATE;
    }
    esp_err_t err = nvs_set_u32(s_handle, key, value);
    if (err == ESP_OK) {
        err = nvs_commit(s_handle);
    }
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "putUInt(%s) failed: %s", key, esp_err_to_name(err));
    }
    return err;
}

esp_err_t putBytes(const char *key, const void *data, size_t len) {
    if (!s_open) {
        return ESP_ERR_INVALID_STATE;
    }
    esp_err_t err = nvs_set_blob(s_handle, key, data, len);
    if (err == ESP_OK) {
        err = nvs_commit(s_handle);
    }
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "putBytes(%s) failed: %s", key, esp_err_to_name(err));
    }
    return err;
}

} // namespace Storage