/**
 * @Author: 李建
 * @Date: 2023/12/14 11:20:56
 * @LastEditors: 李建
 * @LastEditTime: 2023/12/14 11:20:56
 * Description: 存储
 * Copyright: Copyright (©)}) 2023 永续绿建. All rights reserved.
 */

#include "miscellaneous_interface.h"
#include "esp_mac.h"
#include "esp_log.h"

#include "esp_wifi.h"
#include "nvs.h"
#include "app/include/wifi.h"
#include "esp_sntp.h"
#include "esp_system.h"
#include "esp_spiffs.h"
#include "esp_app_desc.h"
#include "esp_chip_info.h"

static const char *TAG = "storage";

uint64_t get_sys_time_ms() {
    time_t timenow;
    time(&timenow);
    return (uint64_t) timenow * 1000;
}

bool net_connect_check() {
    return get_wifi_status();
}


esp_err_t nvs_set_uint16(uint16_t code, const char *key) {
    esp_err_t err;
    nvs_handle handle;

    err = nvs_open(AC_CODE_NAMESPACE, NVS_READWRITE, &handle);
    if (err != ESP_OK) {
        printf("nvs open fail\n");
        return err;
    }
    err = nvs_set_u16(handle, key, code);
    if (err != ESP_OK) {
        return err;
    }
    // 提交
    err = nvs_commit(handle);
    if (err != ESP_OK) {
        return err;
    }
    // 记得关闭
    nvs_close(handle);
    return ESP_OK;
}

esp_err_t nvs_set_int8(int8_t code, const char *key) {
    esp_err_t err;
    nvs_handle handle;

    err = nvs_open(AC_CODE_NAMESPACE, NVS_READWRITE, &handle);
    if (err != ESP_OK) {
        printf("nvs open fail\n");
        return err;
    }
    err = nvs_set_i8(handle, key, code);
    if (err != ESP_OK) {
        return err;
    }
    // 提交
    err = nvs_commit(handle);
    if (err != ESP_OK) {
        return err;
    }
    // 记得关闭
    nvs_close(handle);
    return ESP_OK;
}

int8_t *nvs_get_int8(const char *key) {
    nvs_handle handle;
    esp_err_t err;
    int8_t *code;
    err = nvs_open(AC_CODE_NAMESPACE, NVS_READWRITE, &handle);
    if (err != ESP_OK) {
        ESP_LOGI(TAG, "nvs open fail");
        return NULL;
    }
    code = (int8_t *) malloc(sizeof(int8_t));
    // 检查存在
    err = nvs_get_i8(handle, key, code);
    if (err != ESP_OK) {
        ESP_LOGI(TAG, "get i8 error,err = %d,key = %s", err, key);
        free(code);
        return NULL;
    }
    printf("get code = %u from nvs", *code);
    nvs_close(handle);
    return code;
}


esp_err_t nvs_set_uint8(uint8_t code, const char *key) {
    esp_err_t err;
    nvs_handle handle;

    err = nvs_open(AC_CODE_NAMESPACE, NVS_READWRITE, &handle);
    if (err != ESP_OK) {
        printf("nvs open fail\n");
        return err;
    }
    err = nvs_set_u8(handle, key, code);
    if (err != ESP_OK) {
        return err;
    }
    // 提交
    err = nvs_commit(handle);
    if (err != ESP_OK) {
        return err;
    }
    // 记得关闭
    nvs_close(handle);
    return ESP_OK;
}

uint8_t *nvs_get_uint8(const char *key) {
    nvs_handle handle;
    esp_err_t err;
    uint8_t *code;
    err = nvs_open(AC_CODE_NAMESPACE, NVS_READWRITE, &handle);
    if (err != ESP_OK) {
        ESP_LOGI(TAG, "nvs open fail");
        return NULL;
    }
    code = (uint8_t *) malloc(sizeof(uint8_t));
    // 检查存在
    err = nvs_get_u8(handle, key, code);
    if (err != ESP_OK) {
        ESP_LOGI(TAG, "get u8 error,err = %d,key = %s", err, key);
        free(code);
        return NULL;
    }
    nvs_close(handle);
    return code;
}


uint16_t *nvs_get_uint16(const char *key) {
    nvs_handle handle;
    esp_err_t err;
    uint16_t *code;

    err = nvs_open(AC_CODE_NAMESPACE, NVS_READWRITE, &handle);
    if (err != ESP_OK) {
        ESP_LOGI(TAG, "nvs open fail");
        return NULL;
    }
    code = (uint16_t *) malloc(sizeof(uint16_t));
    // 检查存在
    err = nvs_get_u16(handle, key, code);
    if (err != ESP_OK) {
        ESP_LOGI(TAG, "get u8 error,err = %d,key = %s", err, key);
        free(code);
        return NULL;
    }
    printf("get code = %u from nvs", *code);
    nvs_close(handle);

    return code;
}

void get_device_serial(char *serial_buf) {
    u_int8_t mapAddr[6];
    esp_read_mac(mapAddr, ESP_MAC_WIFI_STA);
    sprintf(serial_buf, "%02X%02X%02X%02X%02X%02X", mapAddr[0], mapAddr[1], mapAddr[2], mapAddr[3], mapAddr[4],
            mapAddr[5]);
}

char *yx_data_get(char *key) {

    nvs_handle_t nvsHandle;
    ESP_ERROR_CHECK(nvs_open(YX_NVS_NAME_SPACE, NVS_READWRITE, &nvsHandle));
    size_t required_size;
    nvs_get_str(nvsHandle, key, NULL, &required_size);
    if (required_size == 0)
        return NULL;
    char *result = malloc(required_size);
    nvs_get_str(nvsHandle, key, result, &required_size);
    nvs_close(nvsHandle);
    return result;
}

/**
 * 获取本地保存的按键原始码
 * @param key 按键Id
 * @param out_value 原始码数组
 * @return
 */
esp_err_t nvs_get_study_code(const char *key, uint16_t *out_value, size_t *out_len) {
    esp_err_t err;
    nvs_handle handle;

    err = nvs_open(YX_NVS_NAME_SPACE, NVS_READWRITE, &handle);
    if (err != ESP_OK) {
        printf("nvs open fail\n");
        return err;
    }
    err = nvs_get_blob(handle, key, out_value, out_len);
    if (err != ESP_OK) {
        return err;
    }
    nvs_close(handle);
    return err;
}

/**
 * 保存红外学习的按键原始数据
 * @param code 原始码
 * @param key 按键Id
 * @param len 原始码长度
 * @return
 */
esp_err_t nvs_save_study_code(uint16_t *code, size_t len, const char *key) {
    esp_err_t err;
    nvs_handle handle;

    err = nvs_open(YX_NVS_NAME_SPACE, NVS_READWRITE, &handle);
    if (err != ESP_OK) {
        printf("nvs open fail, %s", esp_err_to_name(err));
        return err;
    }
    printf("code len :%d\n", len);
    err = nvs_set_blob(handle, key, code, len);
    if (err != ESP_OK) {
        printf("nvs set fail, %s", esp_err_to_name(err));
        return err;
    }
    // 提交
    err = nvs_commit(handle);
    if (err != ESP_OK) {
        return err;
    }
    // 记得关闭
    nvs_close(handle);
    return ESP_OK;
}

void yx_data_set(char *key, char *value) {
    nvs_handle_t nvsHandle;
    ESP_ERROR_CHECK(nvs_open(YX_NVS_NAME_SPACE, NVS_READWRITE, &nvsHandle));
    ESP_ERROR_CHECK(nvs_set_str(nvsHandle, key, value));
    ESP_ERROR_CHECK(nvs_commit(nvsHandle));
    nvs_close(nvsHandle);
}

void yx_data_clear(char * key) {
    nvs_handle_t nvsHandle;
    ESP_ERROR_CHECK(nvs_open(YX_NVS_NAME_SPACE, NVS_READWRITE, &nvsHandle));
    nvs_erase_key(nvsHandle, key);
    nvs_commit(nvsHandle);
    nvs_close(nvsHandle);
}

// 获取网关系统信息
void get_sys_info(gateway_sys_info *info) {
    if (info == NULL)
        return;
    size_t total = 0, used = 0;
    esp_err_t ret = esp_spiffs_info(NULL, &total, &used);
    if (ret == ESP_OK) {
        info->used = used;
        info->total = total;
    }
    u_int8_t mapAddr[6];
    esp_read_mac(mapAddr, ESP_MAC_WIFI_STA);
    char str_device_serial[21];
    sprintf(str_device_serial, "%02X:%02X:%02X:%02X:%02X:%02X", mapAddr[0], mapAddr[1], mapAddr[2], mapAddr[3],
            mapAddr[4], mapAddr[5]);

    strcpy(info->mac, str_device_serial);
    esp_chip_info_t chip_info = {0};
    esp_chip_info(&chip_info);

    info->cores = chip_info.cores;
    info->revision = chip_info.revision;
    const esp_app_desc_t *desc = esp_app_get_description();
    strcpy(info->idf_version, desc->idf_ver);
    strcpy(info->version, desc->version);
}