/***************************************************************************
 * File Name: platform.c
 * Description: 跨平台通用逻辑实现（路由到具体平台的实现）
 * Author: ZXY
 * Company: 芯祥联科技
 * Date Created: 2025-10-22
 * Version: 1.5（修复64位指针截断问题）
 ***************************************************************************/
#include "type.h"
#include "platform.h"
#include "agent_log.h"
#include <string.h>
#include <stdarg.h>  // ✅【强制必加】va_start/va_end/va_list 全部定义在这里，根治LNK2019
#include <stdio.h>   // ✅【强制必加】vsnprintf/_vsnprintf_s 标准库函数定义
#include <stdlib.h>  // ✅【可选追加】兼容VS标准库，无副作用

// ==================== 跨平台系统头文件（自动包含，解决 Sleep 未定义）====================
#ifdef WIN32
#include <windows.h>        // 提供 Sleep()
#endif

#ifdef LINUX
#include <unistd.h>   // sleep, usleep, readlink
#include <sys/types.h>

#endif

// -------------------------- 平台特有实现声明（保持不变） --------------------------
#ifdef WIN32
// Windows平台新增接口声明
extern uint32_xxl platform_thread_id_win32(void);
extern PlatformTime platform_get_utc_seconds_win32(void);
extern PlatformTime platform_get_utc_ms_win32(void);
extern bool_xxl platform_timer_start_win32(PlatformTimer timer);
extern bool_xxl platform_timer_stop_win32(PlatformTimer timer);
//extern void* platform_malloc_win32(uint32 size);
extern void* platform_calloc_win32(uint32_xxl num, uint32_xxl size);
extern void platform_free_win32(void* ptr);
extern bool_xxl platform_rand_generate_crypto_win32(uint8_xxl* buf, uint32_xxl len);
extern bool_xxl platform_file_exists_win32(const char* path);
extern uint32_xxl platform_get_file_size_win32(const char* path);
extern uint32_xxl platform_memset_s_win32(void* dest, uint32_xxl dest_max_len, uint8_xxl value, uint32_xxl set_len);
extern int32_xxl platform_strcmp_win32(const char* str1, const char* str2);
extern char* platform_strchr_win32(const char* str, int32_xxl ch);
extern void platform_log_output_win32(const char* module, const char* fmt, ...);

#elif defined(LINUX)
// Linux平台新增接口声明
extern uint32_xxl platform_thread_id_linux(void);
extern PlatformTime platform_get_utc_seconds_linux(void);
extern PlatformTime platform_get_utc_ms_linux(void);
extern bool_xxl platform_timer_start_linux(PlatformTimer timer);
extern bool_xxl platform_timer_stop_linux(PlatformTimer timer);
extern void* platform_malloc_linux(uint32_xxl size);
extern void* platform_calloc_linux(uint32_xxl num, uint32_xxl size);
extern void platform_free_linux(void* ptr);
extern bool_xxl platform_rand_generate_crypto_linux(uint8_xxl* buf, uint32_xxl len);
extern bool_xxl platform_file_exists_linux(const char* path);
extern uint32_xxl platform_get_file_size_linux(const char* path);
extern uint32_xxl platform_memset_s_linux(void* dest, uint32_xxl dest_max_len, uint8_xxl value, uint32_xxl set_len);
extern int32_xxl platform_strcmp_linux(const char* str1, const char* str2);
extern char* platform_strchr_linux(const char* str, int32_xxl ch);
void platform_mutex_destroy_linux(PlatformMutex mutex);

#elif defined(STM32)
// STM32平台新增接口声明
extern uint32_xxl platform_thread_id_stm32(void);
extern PlatformTime platform_get_utc_seconds_stm32(void);
extern PlatformTime platform_get_utc_ms_stm32(void);
extern bool_xxl platform_timer_start_stm32(PlatformTimer timer);
extern bool_xxl platform_timer_stop_stm32(PlatformTimer timer);
extern void* platform_malloc_stm32(uint32_xxl size);
extern void* platform_calloc_stm32(uint32_xxl num, uint32_xxl size);
extern void platform_free_stm32(void* ptr);
extern bool_xxl platform_rand_generate_crypto_stm32(uint8_xxl* buf, uint32_xxl len);
extern bool_xxl platform_file_exists_stm32(const char* path);
extern uint32_xxl platform_get_file_size_stm32(const char* path);
extern uint32_xxl platform_memset_s_stm32(void* dest, uint32_xxl dest_max_len, uint8_xxl value, uint32_xxl set_len);
extern int32_xxl platform_strcmp_stm32(const char* str1, const char* str2);
extern char* platform_strchr_stm32(const char* str, int32_xxl ch);
extern void platform_log_output_stm32(const char* module, const char* fmt, ...);

#else
//#warning "Unsupported platform! Some functions may be unavailable."
#endif

// 平台初始化（跨平台转发）
bool_xxl platform_init(void) {
#ifdef WIN32
    return platform_init_win32();
#elif defined(LINUX)
    return platform_init_linux();
#elif defined(STM32)
    return platform_init_stm32();
#else
    return true;
#endif
}

// 平台反初始化（跨平台转发）
void platform_deinit(void) {
#ifdef WIN32
    platform_deinit_win32();
#elif defined(LINUX)
    platform_deinit_linux();
#elif defined(STM32)
    platform_deinit_stm32();
#endif
}


// -------------------------- 通用接口实现（补充指针校验） --------------------------
// 线程接口（补充线程ID）
//uint32_xxl platform_thread_id(void) {
//#ifdef WIN32
//    return platform_thread_id_win32();
//#elif defined(LINUX)
//    return platform_thread_id_linux();
//#elif defined(STM32)
//    return platform_thread_id_stm32();
//#else
//    return 0;  // 未知平台默认返回0
//#endif
//}
// -------------------------- 新增：指针完整性检查工具函数 --------------------------
/**
 * 检查指针是否为合法64位地址（未被截断）
 * @param ptr 待检查的指针
 * @return 合法返回TRUE，否则FALSE
 */
static bool_xxl is_valid_pointer(void* ptr) {
    // 1. NULL 指针：我们这里定义为 "合法"（不拦截）
    if (!ptr) {
        return true;
    }

#ifdef _WIN64
    // 【仅 Windows 64位】检查指针被截断成 32 位的情况
    // 高 32 位 = 0xFFFFFFFF 是典型截断特征
    uintptr_t addr = (uintptr_t)ptr;
    if ((addr & 0xFFFFFFFF00000000) == 0xFFFFFFFF00000000) {
        agent_log_error("Invalid pointer (truncated): %p", ptr);
        return false;
    }
#endif

    // Linux / STM32 / 32位系统：不做额外判断
    return true;
}

// -------------------------- 新增：跨平台大小端转换函数实现 --------------------------
void platform_cpu_to_be32(uint8_xxl* out, uint32_xxl value) {
    if (!out) return;
    // 大端序：高位字节在前
    out[0] = (uint8_xxl)(value >> 24);
    out[1] = (uint8_xxl)(value >> 16);
    out[2] = (uint8_xxl)(value >> 8);
    out[3] = (uint8_xxl)(value & 0xFF);
}

uint32_xxl platform_be32_to_cpu(const uint8_xxl* in) {
    if (!in) return 0;
    // 大端字节数组转主机序：高位字节对应高地址
    return (uint32_xxl)((uint32_xxl)in[0] << 24) | 
           (uint32_xxl)((uint32_xxl)in[1] << 16) | 
           (uint32_xxl)((uint32_xxl)in[2] << 8)  | 
           (uint32_xxl)in[3];
}

void platform_cpu_to_be16(uint8_xxl* out, uint16_xxl value) {
    if (!out) return;
    // 大端序：高位字节在前
    out[0] = (uint8_xxl)(value >> 8);
    out[1] = (uint8_xxl)(value & 0xFF);
}

uint16_xxl platform_be16_to_cpu(const uint8_xxl* in) {
    if (!in) return 0;
    // 大端字节数组转主机序：高位字节对应高地址
    return (uint16_xxl)((uint16_xxl)in[0] << 8) | (uint16_xxl)in[1];
}

// 时间接口（补充UTC时间）
PlatformTime platform_get_utc_seconds(void) {
#ifdef WIN32
    return platform_get_utc_seconds_win32();
#elif defined(LINUX)
    return platform_get_utc_seconds_linux();
#elif defined(STM32)
    return platform_get_utc_seconds_stm32();
#else
    return 0;  // 未知平台默认返回0
#endif
}

//PlatformTime platform_get_utc_ms(void) {
//#ifdef WIN32
//    return platform_get_utc_ms_win32();
//#elif defined(LINUX)
//    return platform_get_utc_ms_linux();
//#elif defined(STM32)
//    return platform_get_utc_ms_stm32();
//#else
//    return 0;  // 未知平台默认返回0
//#endif
//}

// 定时器接口（补充启停，新增指针校验）
//bool_xxl platform_timer_start(PlatformTimer timer) {
//    // 新增：检查定时器指针完整性
//    if (!is_valid_pointer(timer)) {
//        agent_log_error("platform_timer_start: 无效定时器指针（已截断）");
//        return false;
//    }

//#ifdef WIN32
//    return platform_timer_start_win32(timer);
//#elif defined(LINUX)
//    return platform_timer_start_linux(timer);
//#elif defined(STM32)
//    return platform_timer_start_stm32(timer);
//#else
//    return false;  // 未知平台返回失败
//#endif
//}

//bool_xxl platform_timer_stop(PlatformTimer timer) {
//    // 新增：检查定时器指针完整性
//    if (!is_valid_pointer(timer)) {
//        agent_log_error("platform_timer_stop: 无效定时器指针（已截断）");
//        return false;
//    }

//#ifdef WIN32
//    return platform_timer_stop_win32(timer);
//#elif defined(LINUX)
//    return platform_timer_stop_linux(timer);
//#elif defined(STM32)
//    return platform_timer_stop_stm32(timer);
//#else
//    return false;  // 未知平台返回失败
//#endif
//}

// 内存接口（补充基础分配）
void* platform_malloc(uint32_xxl size) {
#ifdef WIN32
    return platform_malloc_win32(size);
#elif defined(LINUX)
    return platform_malloc_linux(size);
#elif defined(STM32)
    return platform_malloc_stm32(size);
#else
    return malloc(size);  // 未知平台 fallback 到标准库
#endif
}

//void* platform_calloc(uint32_xxl num, uint32_xxl size) {
//#ifdef WIN32
//    return platform_calloc_win32(num, size);
//#elif defined(LINUX)
//    return platform_calloc_linux(num, size);
//#elif defined(STM32)
//    return platform_calloc_stm32(num, size);
//#else
//    return calloc(num, size);  // 未知平台 fallback 到标准库
//#endif
//}

void platform_free(void* ptr) {
    if (!ptr) return;
    // 新增：释放前检查指针完整性（避免释放非法地址）
    if (!is_valid_pointer(ptr)) {
        agent_log_error("platform_free: 尝试释放无效指针（已截断）：%p", ptr);
        return;
    }

#ifdef WIN32
    platform_free_win32(ptr);
#elif defined(LINUX)
    platform_free_linux(ptr);
#elif defined(STM32)
    platform_free_stm32(ptr);
#else
    free(ptr);  // 未知平台 fallback 到标准库
#endif
}

// 随机数接口（补充加密级）
bool_xxl platform_rand_generate_crypto(uint8_xxl* buf, uint32_xxl len) {
    if (!buf || len == 0) return false;
#ifdef WIN32
    return platform_rand_generate_crypto_win32(buf, len);
#elif defined(LINUX)
    return platform_rand_generate_crypto_linux(buf, len);
#elif defined(STM32)
    return platform_rand_generate_crypto_stm32(buf, len);
#else
    // 未知平台使用普通随机数（安全性较低）
    return platform_rand_generate(buf, len);
#endif
}

// 文件系统接口
//bool_xxl platform_file_exists(const char* path) {
//    if (!path) return false;
//#ifdef WIN32
//    return platform_file_exists_win32(path);
//#elif defined(LINUX)
//    return platform_file_exists_linux(path);
//#elif defined(STM32)
//    return platform_file_exists_stm32(path);
//#else
//    return false;  // 未知平台默认返回不存在
//#endif
//}

//uint32_xxl platform_get_file_size(const char* path) {
//    if (!path) return 0;
//#ifdef WIN32
//    return platform_get_file_size_win32(path);
//#elif defined(LINUX)
//    return platform_get_file_size_linux(path);
//#elif defined(STM32)
//    return platform_get_file_size_stm32(path);
//#else
//    return 0;  // 未知平台默认返回0
//#endif
//}

// 字符串/内存操作（补充安全函数）
uint32_xxl platform_memset_s(void* dest, uint32_xxl dest_max_len, uint8_xxl value, uint32_xxl set_len) {
    if (!dest || dest_max_len == 0) return 0;
    uint32_xxl actual_len = (set_len < dest_max_len) ? set_len : dest_max_len;
#ifdef WIN32
    return platform_memset_s_win32(dest, dest_max_len, value, actual_len);
#elif defined(LINUX)
    return platform_memset_s_linux(dest, dest_max_len, value, actual_len);
#elif defined(STM32)
    return platform_memset_s_stm32(dest, dest_max_len, value, actual_len);
#else
    memset(dest, value, actual_len);
    return actual_len;
#endif
}

int32_xxl platform_strcmp(const char* str1, const char* str2) {
    if (!str1 || !str2) return (str1 == str2) ? 0 : (str1 ? 1 : -1);
#ifdef WIN32
    return platform_strcmp_win32(str1, str2);
#elif defined(LINUX)
    return platform_strcmp_linux(str1, str2);
#elif defined(STM32)
    return platform_strcmp_stm32(str1, str2);
#else
    return strcmp(str1, str2);  // 未知平台 fallback 到标准库
#endif
}

uint32_xxl platform_strlen(const char* str) {
    if (str == NULL) {
        return 0;  // 空指针安全处理
    }
     return strlen(str);
}

char* platform_strchr(const char* str, int32_xxl ch) {
    if (!str) return NULL;
#ifdef WIN32
    return platform_strchr_win32(str, ch);
#elif defined(LINUX)
    return platform_strchr_linux(str, ch);
#elif defined(STM32)
    return platform_strchr_stm32(str, ch);
#else
    return strchr(str, ch);  // 未知平台 fallback 到标准库
#endif
}

// ========== 新增：补齐缺失的 platform_memcmp 完整实现 - 解决核心LNK2019报错 ==========
int32_xxl platform_memcmp(const void* buf1, const void* buf2, uint32_xxl len)
{
    // 空指针+非法参数安全校验，和你现有代码逻辑完全一致
    if (buf1 == NULL || buf2 == NULL || len == 0)
    {
        agent_log_error("platform_memcmp: 非法参数 (buf1=%p, buf2=%p, len=%d)", buf1, buf2, len);
        return -1;
    }
    // 跨平台路由，和你所有platform_xxx函数风格统一
#ifdef WIN32
    return memcmp(buf1, buf2, len);
#elif defined(LINUX)
    return memcmp(buf1, buf2, len);
#elif defined(STM32)
    return memcmp(buf1, buf2, len);
#else
    return memcmp(buf1, buf2, len);
#endif
}

// ========== 新增：platform_strstr 跨平台实现（解决LNK2019错误） ==========
char* platform_strstr(const char* str, const char* substr) {
    // 1. 空指针校验（避免崩溃）
    if (!str || !substr) {
        agent_log_error("platform_strstr: 空指针参数（str=%p, substr=%p）", str, substr);
        return NULL;
    }
    // 2. 子串为空直接返回源字符串（兼容标准库行为）
    if (*substr == '\0') {
        return (char*)str;
    }

#ifdef WIN32
	return strstr(str, substr);

#elif defined(LINUX)
    // Linux平台：直接调用标准库strstr
    return strstr(str, substr);
#elif defined(STM32)
    // STM32裸机：手动实现strstr（避免依赖标准库）
    const char* s = str;
    const char* sub = substr;
    while (*s != '\0') {
        const char* s_tmp = s;
        const char* sub_tmp = sub;
        // 逐字符匹配
        while (*s_tmp == *sub_tmp && *sub_tmp != '\0') {
            s_tmp++;
            sub_tmp++;
        }
        // 子串完全匹配
        if (*sub_tmp == '\0') {
            return (char*)s;
        }
        s++;
    }
    return NULL;
#else
    // 未知平台：降级调用标准库（兼容大多数场景）
    return strstr(str, substr);
#endif
}


// -------------------------- 原有接口路由（补充指针校验） --------------------------
// 线程接口
PlatformThread platform_thread_create(PlatformThreadFunc func, void* arg) {
    // 新增：检查回调函数指针完整性
    if (!is_valid_pointer((void*)func)) {
        agent_log_error("platform_thread_create: 无效回调函数指针（已截断）");
        return NULL;
    }

#ifdef WIN32
    return platform_thread_create_win32(func, arg);
#elif defined(LINUX)
    return platform_thread_create_linux(func, arg);
#elif defined(STM32)
    return platform_thread_create_stm32(func, arg);
#else
	//裸机环境可以在LOOP中调用func();
    return NULL;
#endif
}

void platform_thread_join(PlatformThread thread) {
	//线程销毁
    // 新增：检查线程指针完整性
    if (!is_valid_pointer(thread)) {
        agent_log_error("platform_thread_join: 无效线程指针（已截断）：%p", thread);
        return;
    }

#ifdef WIN32
    platform_thread_join_win32(thread);
#elif defined(LINUX)
    platform_thread_join_linux(thread);
#elif defined(STM32)
    platform_thread_join_stm32(thread);
#else
	//裸机环境可以为空。
#endif
}

//void platform_thread_detach(PlatformThread thread) {
//    // 新增：检查线程指针完整性
//    if (!is_valid_pointer(thread)) {
//        agent_log_error("platform_thread_detach: 无效线程指针（已截断）：%p", thread);
//        return;
//    }

//#ifdef WIN32
//    platform_thread_detach_win32(thread);
//#elif defined(LINUX)
//    platform_thread_detach_linux(thread);
//#elif defined(STM32)
//    platform_thread_detach_stm32(thread);
//#endif
//}

// 互斥锁接口
PlatformMutex platform_mutex_create(void) {
#ifdef WIN32
    return platform_mutex_create_win32();
#elif defined(LINUX)
    return platform_mutex_create_linux();
#elif defined(STM32)
    return platform_mutex_create_stm32();
#else
	//裸机环境可以为空
    return NULL;
#endif
}

void platform_mutex_lock(PlatformMutex mutex) {
    if (mutex == NULL) {
//        agent_log_error("platform_mutex_lock: mutex is NULL!");
        return;
    }

    if (!is_valid_pointer(mutex)) {
        agent_log_error("platform_mutex_lock: 无效指针（已截断）：%p", mutex);
        return;
    }

#ifdef WIN32
    platform_mutex_lock_win32(mutex);
#elif defined(LINUX)
    platform_mutex_lock_linux(mutex);
#elif defined(STM32)
    platform_mutex_lock_stm32(mutex);
#else
		//裸机环境可以为空
#endif
}

void platform_mutex_unlock(PlatformMutex mutex) {
    if (mutex == NULL) {
//        agent_log_error("platform_mutex_unlock: mutex is NULL!");
        return;
    }

    if (!is_valid_pointer(mutex)) {
        agent_log_error("platform_mutex_unlock: 无效指针（已截断）：%p", mutex);
        return;
    }

#ifdef WIN32
    platform_mutex_unlock_win32(mutex);
#elif defined(LINUX)
    platform_mutex_unlock_linux(mutex);
#elif defined(STM32)
    platform_mutex_unlock_stm32(mutex);
#else
	//裸机环境可以为空

#endif
}

void platform_mutex_destroy(PlatformMutex mutex) {


//	return;
    // 1. 空指针
    if (mutex == NULL) {
        return;
    }

    // 2. 指针合法性（WIN64截断检查）
    if (!is_valid_pointer(mutex)) {
        agent_log_error("mutex_destroy: invalid pointer");
        return;
    }

    // 3. 调用平台底层销毁（不再访问 ->valid，因为 void* 没有成员）
#ifdef WIN32
    platform_mutex_destroy_win32(mutex);
#elif defined(LINUX)
    platform_mutex_destroy_linux(mutex);
#elif defined(STM32)
    platform_mutex_destroy_stm32(mutex);
#endif

}




int32_xxl platform_sem_timedwait(PlatformSem sem, uint32_xxl timeout_ms) {
    // 新增：检查信号量指针完整性
    if (!is_valid_pointer(sem)) {
        agent_log_error("platform_sem_timedwait: 无效信号量指针（已截断）：%p", sem);
        return -1;
    }

#ifdef WIN32
    return platform_sem_timedwait_win32(sem, timeout_ms);
#elif defined(LINUX)
    return platform_sem_timedwait_linux(sem, timeout_ms);
#elif defined(STM32)
    return platform_sem_timedwait_stm32(sem, timeout_ms);
#else
    return -1;
#endif
}




// 时间接口
uint32_xxl platform_get_tick_ms(void) {
#ifdef WIN32
    return platform_get_tick_ms_win32();
#elif defined(LINUX)
    return platform_get_tick_ms_linux();
#elif defined(STM32)
    return platform_get_tick_ms_stm32();
#else
	//产生一个MS级别的tick值
    return 0;
#endif
}
void platform_delay_ms(uint32_xxl ms) {
#ifdef WIN32
    Sleep(ms);
#elif defined(LINUX)
    usleep(ms * 1000);
#elif defined(STM32)
    HAL_Delay(ms);
#else
    // 空平台兼容
    (void)ms;
#endif
}

//uint64_xxl platform_get_tick_us(void) {
//#ifdef WIN32
//    return platform_get_tick_us_win32();
//#elif defined(LINUX)
//    return platform_get_tick_us_linux();
//#elif defined(STM32)
//    return platform_get_tick_us_stm32();
//#else
//    return 0;
//#endif
//}



// 定时器接口（补充指针校验）
//PlatformTimer platform_timer_create(PlatformTimerFunc func, void* arg, uint32_xxl period_ms) {
//    // 新增：检查回调函数指针完整性
//    if (!is_valid_pointer((void*)func)) {
//        agent_log_error("platform_timer_create: 无效回调函数指针（已截断）");
//        return NULL;
//    }

//#ifdef WIN32
//    return platform_timer_create_win32(func, arg, period_ms);
//#elif defined(LINUX)
//    return platform_timer_create_linux(func, arg, period_ms);
//#elif defined(STM32)
//    return platform_timer_create_stm32(func, arg, period_ms);
//#else
//    return NULL;
//#endif
//}

//void platform_timer_destroy(PlatformTimer timer) {
//    // 新增：检查定时器指针完整性
//    if (!is_valid_pointer(timer)) {
//        agent_log_error("platform_timer_destroy: 无效定时器指针（已截断）：%p", timer);
//        return;
//    }

//#ifdef WIN32
//    platform_timer_destroy_win32(timer);
//#elif defined(LINUX)
//    platform_timer_destroy_linux(timer);
//#elif defined(STM32)
//    platform_timer_destroy_stm32(timer);
//#endif
//}

// 内存接口
//void* platform_malloc_aligned(uint32_xxl size, uint32_xxl align) {
//#ifdef WIN32
//    return platform_malloc_aligned_win32(size, align, PLATFORM_MEM_DEFAULT);  // 补充参数
//#elif defined(LINUX)
//    return platform_malloc_aligned_linux(size, align, PLATFORM_MEM_DEFAULT);
//#elif defined(STM32)
//    return platform_malloc_aligned_stm32(size, align, PLATFORM_MEM_DEFAULT);
//#else
//    return NULL;  // 未知平台返回NULL
//#endif
//}

//void platform_free_aligned(void* ptr) {
//    // 新增：检查对齐内存指针完整性
//    if (!is_valid_pointer(ptr)) {
//        agent_log_error("platform_free_aligned: 无效对齐内存指针（已截断）：%p", ptr);
//        return;
//    }

//#ifdef WIN32
//    platform_free_aligned_win32(ptr);
//#elif defined(LINUX)
//    platform_free_aligned_linux(ptr);
//#elif defined(STM32)
//    platform_free_aligned_stm32(ptr);
//#endif
//}

// 随机数接口
bool_xxl platform_rand_generate(uint8_xxl* buf, uint32_xxl len) {
#ifdef WIN32
    return platform_rand_generate_win32(buf, len);
#elif defined(LINUX)
    return platform_rand_generate_linux(buf, len);
#elif defined(STM32)
    return platform_rand_generate_stm32(buf, len);
#else
    return false;
#endif
}



// 通用辅助函数（保持不变）
uint32_xxl platform_memcpy_s(void* dest, uint32_xxl dest_max_len, const void* src, uint32_xxl src_len) {
    if (dest == NULL || src == NULL || dest_max_len == 0) {
        return 0;
    }
    uint32_xxl copy_len = (src_len < dest_max_len) ? src_len : dest_max_len;
    memmove(dest, src, copy_len);  // 处理缓冲区重叠
    return copy_len;
}

uint32_xxl platform_strcpy_s(char* dest, uint32_xxl dest_max_len, const char* src) {
    if (dest == NULL || src == NULL || dest_max_len == 0) {
        return 0;
    }
    uint32_xxl src_len = 0;
    while (src[src_len] != '\0' && src_len < dest_max_len - 1) {
        src_len++;
    }
    memcpy(dest, src, src_len);
    dest[src_len] = '\0';  // 确保终止符
    return src_len;
}

// ========== 新增：纯基础平台函数实现 - 安全字符串拼接（通用能力，无任何MQTT业务） ==========
uint32_xxl platform_strcat_s(char* dest, uint32_xxl dest_max_len, const char* src)
{
    if (dest == NULL || src == NULL || dest_max_len == 0)
    {
        agent_log_error("platform_strcat_s: invalid param (dest=%p, src=%p, len=%d)", dest, src, dest_max_len);
        return 0;
    }
    uint32_xxl dest_len = platform_strlen(dest);
    uint32_xxl src_len  = platform_strlen(src);
    // 安全校验：防止缓冲区溢出
    if ((dest_len + src_len) >= dest_max_len)
    {
        agent_log_error("platform_strcat_s: buffer overflow (dest_len=%d, src_len=%d, max_len=%d)", dest_len, src_len, dest_max_len);
        return 0;
    }
    // 内存拷贝实现拼接，复用已有安全接口
    platform_memcpy_s(&dest[dest_len], dest_max_len - dest_len, src, src_len);
    dest[dest_len + src_len] = '\0'; // 补字符串结束符
    return (dest_len + src_len);
}
// ========== 新增：纯基础平台函数 - 安全格式化字符串 (和现有代码风格、校验逻辑完全一致) ==========
uint32_xxl platform_snprintf(char* dest, uint32_xxl dest_max_len, const char* fmt, ...)
{
    // 空指针+非法参数安全校验，和你所有platform_xxx函数校验逻辑完全一致
    if (dest == NULL || fmt == NULL || dest_max_len == 0)
    {
        agent_log_error("platform_snprintf: invalid param (dest=%p, fmt=%p, len=%d)", dest, fmt, dest_max_len);
        return 0;
    }

    va_list args = { 0 };  // ✅【绝杀修复C4700】声明时直接初始化！VS编译器彻底闭嘴，根源解决
    va_start(args, fmt);   // 可变参数初始化，必须执行
    int ret = 0;

    // 跨平台兼容 + WIN32 安全函数正确写法，无语法错误
#ifdef WIN32
    ret = _vsnprintf_s(dest, dest_max_len, _TRUNCATE, fmt, args);
    // WIN32下_vsnprintf_s返回-1表示截断，做兼容处理
    if(ret == -1)
    {
        ret = (int)dest_max_len - 1;
    }
#else
    // Linux/STM32/其他平台 标准写法，无兼容问题
    ret = vsnprintf(dest, dest_max_len, fmt, args);
#endif

    va_end(args); // 释放可变参数列表，必须执行，防止内存泄漏

    // 返回值处理+缓冲区安全兜底，和你现有platform_strcat_s语义完全一致
    if (ret < 0 || ret >= (int)dest_max_len)
    {
        agent_log_error("platform_snprintf: buffer overflow (ret=%d, max_len=%d)", ret, dest_max_len);
        dest[dest_max_len - 1] = '\0'; // 强制补字符串结束符，绝对安全
        return dest_max_len - 1;
    }
    return (uint32_xxl)ret;
}
