// Copyright (2025) Beijing Volcano Engine Technology Ltd.
// SPDX-License-Identifier: Apache-2.0

// 火山引擎平台适配层 - 实现ESP32平台相关的硬件抽象层函数
// 高性能版本针对ESP32平台的内存管理和线程调度进行了优化

#include "volc_platform.h"

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <esp_netif.h>
#include <esp_timer.h>
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>

// 内存分配函数 - 使用SPIRAM进行内存分配，优化大内存使用场景
void* hal_malloc(size_t size) {
    return heap_caps_malloc(size,MALLOC_CAP_SPIRAM | MALLOC_CAP_DEFAULT);
}

// 内存分配并清零函数 - 使用SPIRAM进行内存分配
void* hal_calloc(size_t num, size_t size) {
    return heap_caps_calloc(num,size,MALLOC_CAP_SPIRAM | MALLOC_CAP_DEFAULT);
}

// 内存重新分配函数 - 使用SPIRAM进行内存重分配
void* hal_realloc(void* ptr, size_t new_size) {
    return heap_caps_realloc(ptr,new_size,MALLOC_CAP_SPIRAM | MALLOC_CAP_DEFAULT);
}

// 内存释放函数 - 释放SPIRAM分配的内存
void hal_free(void* ptr) {
    heap_caps_free(ptr);
}

// 互斥锁创建函数 - 创建线程安全的互斥锁
hal_mutex_t hal_mutex_create(void) {
    SemaphoreHandle_t m = xSemaphoreCreateMutex();
    return (hal_mutex_t)m;
}

void hal_mutex_lock(hal_mutex_t mutex) {
    xSemaphoreTake((SemaphoreHandle_t)mutex, portMAX_DELAY);
}

void hal_mutex_unlock(hal_mutex_t mutex) {
    xSemaphoreGive((SemaphoreHandle_t)mutex);
}

void hal_mutex_destroy(hal_mutex_t mutex) {
    if (mutex) {
        vSemaphoreDelete((SemaphoreHandle_t)mutex);
    }
}

// 获取当前时间函数 - 使用esp_timer获取微秒再转毫秒，避免CLOCK_REALTIME依赖
uint64_t hal_get_time_ms(void) {
    int64_t us = esp_timer_get_time();
    if (us < 0) us = 0;
    return (uint64_t)(us / 1000);
}

// 获取设备UUID函数 - 基于MAC地址生成唯一设备标识符
int hal_get_uuid(char* uuid, size_t size) {
    esp_netif_t *netif = NULL;
    
    while ((netif = esp_netif_next_unsafe(netif)) != NULL) {
        uint8_t hwaddr[6] = {0};
        esp_netif_get_mac(netif, hwaddr);
        snprintf(uuid, size,"%02X%02X%02X%02X%02X%02X",hwaddr[0], hwaddr[1], hwaddr[2], hwaddr[3], hwaddr[4], hwaddr[5]);
    } 
    return 0;
}

// 线程创建函数 - 创建FreeRTOS任务，支持SPIRAM栈分配
int hal_thread_create(hal_tid_t* thread, const hal_thread_param_t* param, void (*start_routine)(void *), void* args) {
    int ret = 0;
    int stack_size = 0;
    int priority = 0;
    BaseType_t core_id = 0;
    TaskHandle_t* handle = NULL;
    if (NULL == thread || NULL == start_routine) {
        return -1;
    }

    if (NULL != param) {
        stack_size = param->stack_size <= 0 ? 12288 : param->stack_size;
        priority = param->priority <= 0 ? 3 : param->priority;
        core_id = 1;
    } else {
        stack_size = 12288;
        priority = 3;
        core_id = tskNO_AFFINITY;
    }
    handle = (TaskHandle_t *)hal_calloc(1, sizeof(TaskHandle_t));
    if (NULL == handle) {
        return -1;
    }
    *thread = (hal_tid_t *)handle;

    if(param->stack_in_ext) {
        ret = xTaskCreatePinnedToCoreWithCaps(start_routine, param->name, stack_size, args, priority, handle, core_id, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
    } else {
        ret = xTaskCreatePinnedToCore(start_routine, param->name, stack_size, args, priority, handle, core_id);
    }
    if (pdPASS != ret) {
        return -1;
    }
    return 0;
}

// 线程分离函数 - 分离线程资源（ESP32平台暂不支持）
int hal_thread_detach(hal_tid_t thread) {
    return 0;
}

// 线程退出函数 - 退出当前线程
void hal_thread_exit(hal_tid_t thread) {
    vTaskDelete(NULL);
}

// 线程休眠函数 - 使当前线程休眠指定毫秒数
void hal_thread_sleep(int time_ms) {
    vTaskDelay(pdMS_TO_TICKS(time_ms));
}

// 线程销毁函数 - 销毁线程句柄并释放资源
void hal_thread_destroy(hal_tid_t thread) {
    if (NULL == thread) {
        return;
    }
    hal_free(thread);
}

// 获取平台信息函数 - 返回平台标识符
int hal_get_platform_info(char* info, size_t size) {
    if (NULL == info || size <= 0) {
        return -1;
    }
    snprintf(info, size, "esp32");
    return 0;
}

// 填充随机数函数 - 使用ESP32硬件随机数生成器
int hal_fill_random(uint8_t* data, size_t size) {
    if (NULL == data || size <= 0) {
        return -1;
    }
    esp_fill_random((void *)data, size);
    return 0;
}