#include "JZsdkLib.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include "JZsdk_Hal.h"

#include "JZsdk_uart/JZsdk_Uart.h"

// 静态全局变量：HAL 信息指针和句柄指针
static T_JZsdk_HalInfo* g_pHalInfo = NULL;
static T_JZsdkHalHandle* g_HalHandle = NULL;

// 用于保护初始化的临时锁（仅用于 JZsdk_HalInit 和 JZsdk_HalDeinit）
static pthread_mutex_t g_initMutex = PTHREAD_MUTEX_INITIALIZER;


/* 默认锁函数实现（使用 pthread） */
static T_JZsdkReturnCode default_lock(T_JZsdkHalHandle* handle) 
{
    pthread_mutex_lock((pthread_mutex_t*)handle->lockCtx);
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

static T_JZsdkReturnCode default_unlock(T_JZsdkHalHandle* handle) 
{
    pthread_mutex_unlock((pthread_mutex_t*)handle->lockCtx);
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/***************
*
*  查询设备是否被引用
*
***********/
static int JZsdk_Hal_PortIsUsed(int PortId)
{
    // 检查句柄和数据是否已初始化
    if (g_HalHandle == NULL || g_pHalInfo == NULL) 
    {
        JZSDK_LOG_ERROR("HAL 未初始化，请先调用 JZsdk_HalInit");
        return JZ_FLAGCODE_OFF;
    }
    
    // 加锁
    g_HalHandle->lock(g_HalHandle);

    int used = JZ_FLAGCODE_OFF;
    for (int i = 0; i < g_pHalInfo->HaveUsePortNum; i++) {
        if (g_pHalInfo->HaveUsePortId[i] == PortId) {
            used = JZ_FLAGCODE_ON;
            break;
        }
    }

    g_HalHandle->unlock(g_HalHandle);

    return used;
}

/***************
*
*  获取结构体以获取信息
*
***********/
static T_JZsdkReturnCode JZsdk_Get_HalInfo(T_JZsdk_HalInfo* pHalInfo)
{
    if (g_HalHandle == NULL || g_pHalInfo == NULL) 
    {
        JZSDK_LOG_ERROR("获取hal信息失败：HAL未初始化");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    if (pHalInfo == NULL) 
    {
        JZSDK_LOG_ERROR("无效参数：pHalInfo 为空");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    g_HalHandle->lock(g_HalHandle);
    memcpy(pHalInfo, g_pHalInfo, sizeof(T_JZsdk_HalInfo));
    g_HalHandle->unlock(g_HalHandle);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}



/**
*
 * @brief 上层UART端口注册与管理
 * @param pUartInfo 指向UART配置信息的指针
 * @return 成功返回JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS，失败返回相应错误码
 *
 */
T_JZsdkReturnCode JZsdk_HalUartInit(T_JZsdk_UartInfo* pUartInfo)
{
    if (pUartInfo == NULL) 
    {
        JZSDK_LOG_ERROR("无效参数：pUartInfo 为空");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    // 检查句柄和数据是否已初始化
    if (g_HalHandle == NULL || g_pHalInfo == NULL) 
    {
        JZSDK_LOG_ERROR("HAL 未初始化，请先调用 JZsdk_HalInit");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    g_HalHandle->lock(g_HalHandle);

    T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

    // 1. 检查端口ID是否已经存在
    for (int i = 0; i < g_pHalInfo->HaveUsePortNum; i++)
    {
        if (pUartInfo->Base.PortId == g_pHalInfo->HaveUsePortId[i])
        {
            JZSDK_LOG_INFO("端口 0x%x 已经初始化过", pUartInfo->Base.PortId);
            ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
            goto unlock;
        }
    }

    // 2. 检查全局端口表是否已满
    if (g_pHalInfo->HaveUsePortNum >= JZ_MAX_PORT_NUM)
    {
        JZSDK_LOG_ERROR("全局端口表已满（最多 %d 个）", JZ_MAX_PORT_NUM);
        ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        goto unlock;
    }

    // 3. 检查UART端口数量是否已达上限
    if (g_pHalInfo->UartNum >= JZ_MAX_UART_NUM)
    {
        JZSDK_LOG_ERROR("没有可用的UART槽位（最多 %d 个）", JZ_MAX_UART_NUM);
        ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        goto unlock;
    }

    // 4. 调用底层硬件初始化
    if (JZsdk_UartInit(pUartInfo) != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("UART硬件初始化失败，端口 0x%x", pUartInfo->Base.PortId);
        ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        goto unlock;
    }

    // 5. 保存UART信息到UART数组（使用UartNum作为索引）
    int uartIndex = g_pHalInfo->UartNum;
    memcpy(&g_pHalInfo->UartInfo[uartIndex], pUartInfo, sizeof(T_JZsdk_UartInfo));
    g_pHalInfo->UartNum++;

    // 6. 记录端口ID到全局已使用表
    g_pHalInfo->HaveUsePortId[g_pHalInfo->HaveUsePortNum] = pUartInfo->Base.PortId;
    g_pHalInfo->HaveUsePortNum++;

    JZSDK_LOG_INFO("UART端口 第:%d  0x%x 初始化成功", (g_pHalInfo->HaveUsePortNum - 1), g_pHalInfo->HaveUsePortId[g_pHalInfo->HaveUsePortNum - 1]);
    ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

unlock:
    g_HalHandle->unlock(g_HalHandle);
    return ret;
}


/**
*
 *  uart重初始化的专用指针
 *
 *
 */
T_JZsdkReturnCode JZsdk_HalUartReInit(int PortId, int NewBitRate)
{
    //获取id信息
    T_JZsdkHalHandle* HalHandle = JZsdk_Platform_GetHalHandle();
    if (HalHandle == NULL)
    {
        JZSDK_LOG_ERROR("注册错误，hal未初始化");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    //检查该id是否已被注册
    if (HalHandle->PortIsUsed(PortId) == JZ_FLAGCODE_OFF)
    {
        JZSDK_LOG_ERROR("当前串口未被初始化");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    // 获取当前 HAL 信息（需要加锁，但 GetHalInfo 内部已经加锁）
    T_JZsdk_HalInfo halInfo = { 0 };
    T_JZsdkReturnCode ret = HalHandle->GetHalInfo(&halInfo);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        return ret;
    }


    // 查找对应 UART 信息
    int i = 0;
    for (; i < halInfo.UartNum; i++)
    {
        if (halInfo.UartInfo[i].Base.PortId == PortId) {
            break;
        }
    }
    if (i >= halInfo.UartNum)
    {
        JZSDK_LOG_ERROR("重初始化失败，未检测到串口信息");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    // 修改波特率
    T_JZsdk_UartInfo uartInfo = halInfo.UartInfo[i];
    uartInfo.Baudrate = NewBitRate;

    //重初始化
    if (JZsdk_UartReinit(&uartInfo, PortId) != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("串口重初始化失败");
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    // 更新全局信息（需要加锁）
    HalHandle->lock(HalHandle);
    // 再次查找（可能期间发生变化），确保索引有效
    int j = 0;
    for (; j < g_pHalInfo->UartNum; j++)
    {
        if (g_pHalInfo->UartInfo[j].Base.PortId == PortId) {
            memcpy(&g_pHalInfo->UartInfo[j], &uartInfo, sizeof(T_JZsdk_UartInfo));
            break;
        }
    }

    HalHandle->unlock(HalHandle);

    if (j >= g_pHalInfo->UartNum) {
        JZSDK_LOG_ERROR("更新失败，端口在查找过程中被移除");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    JZSDK_LOG_INFO("UART端口 0x%x 重初始化成功", PortId);
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}





T_JZsdkReturnCode JZsdk_HalDirectDataInit(T_JZsdk_DirectDataInfo* pDirectDataInfo)
{
    if (pDirectDataInfo == NULL) 
    {
        JZSDK_LOG_ERROR("无效参数：pDirectDataInfo 为空");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    if (g_HalHandle == NULL || g_pHalInfo == NULL) 
    {
        JZSDK_LOG_ERROR("HAL 未初始化，请先调用 JZsdk_HalInit");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    g_HalHandle->lock(g_HalHandle);

    T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

    // 1. 检查端口ID是否已经存在
    for (int i = 0; i < g_pHalInfo->HaveUsePortNum; i++)
    {
        if (pDirectDataInfo->Base.PortId == g_pHalInfo->HaveUsePortId[i])
        {
            JZSDK_LOG_INFO("端口 0x%x 已经初始化过", pDirectDataInfo->Base.PortId);
            ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
            goto unlock;
        }
    }

    // 2. 检查全局端口表是否已满
    if (g_pHalInfo->HaveUsePortNum >= JZ_MAX_PORT_NUM)
    {
        JZSDK_LOG_ERROR("全局端口表已满（最多 %d 个）", JZ_MAX_PORT_NUM);
        ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        goto unlock;
    }

    // 3. 检查UART端口数量是否已达上限
    if (g_pHalInfo->DirectNum >= JZ_MAX_DIRECT_NUM)
    {
        JZSDK_LOG_ERROR("没有可用的DIRECT槽位（最多 %d 个）", JZ_MAX_DIRECT_NUM);
        ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        goto unlock;
    }

    // 4 初始化直通
    //（只是把id打开）


    int Index = g_pHalInfo->DirectNum;
    memcpy(&g_pHalInfo->DirectDataInfo[Index], pDirectDataInfo, sizeof(T_JZsdk_DirectDataInfo));
    g_pHalInfo->DirectNum++;

    // 6. 记录端口ID到全局已使用表
    g_pHalInfo->HaveUsePortId[g_pHalInfo->HaveUsePortNum] = g_pHalInfo->DirectDataInfo->Base.PortId;
    (g_pHalInfo->HaveUsePortNum)++;

    JZSDK_LOG_INFO("DIRECT端口 num:%d 0x%x 初始化成功", (g_pHalInfo->HaveUsePortNum - 1 ),pDirectDataInfo->Base.PortId);
    ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

unlock:
    g_HalHandle->unlock(g_HalHandle);
    return ret;
}

























//hal的基类指针，用于快速修改或者找到某个数据
T_JZsdk_PortBase* JZsdk_FindPortBase(int PortId)
{
    if (g_pHalInfo == NULL) return NULL;

    // 遍历 UART
    for (int i = 0; i < g_pHalInfo->UartNum; i++) {
        if (g_pHalInfo->UartInfo[i].Base.PortId == PortId) {
            return &g_pHalInfo->UartInfo[i].Base;
        }
    }
    // 遍历 USB
    for (int i = 0; i < g_pHalInfo->UsbNum; i++) {
        if (g_pHalInfo->UsbInfo[i].Base.PortId == PortId) {
            return &g_pHalInfo->UsbInfo[i].Base;
        }
    }
    // 遍历 NET
    for (int i = 0; i < g_pHalInfo->NetNum; i++) {
        if (g_pHalInfo->NetInfo[i].Base.PortId == PortId) {
            return &g_pHalInfo->NetInfo[i].Base;
        }
    }
    // 遍历 DIRECT
    for (int i = 0; i < g_pHalInfo->DirectNum; i++) {
        if (g_pHalInfo->DirectDataInfo[i].Base.PortId == PortId) {
            return &g_pHalInfo->DirectDataInfo[i].Base;
        }
    }
    return NULL;
}


T_JZsdkHalHandle* JZsdk_Platform_GetHalHandle(void)
{
    return g_HalHandle;  // 返回已注册的 OSAL 处理器
}



/**
 * HAL 初始化（动态分配内存）
 */
T_JZsdkReturnCode JZsdk_HalInit(void)
{
    // 使用单独的初始化锁保护
    pthread_mutex_lock(&g_initMutex);

    if (g_pHalInfo != NULL || g_HalHandle != NULL) 
    {
        JZSDK_LOG_WARN("HAL 已经初始化过");
        pthread_mutex_unlock(&g_initMutex);
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    // 1. 分配 HAL 信息内存
    T_JZsdk_HalInfo* halInfo = (T_JZsdk_HalInfo*)malloc(sizeof(T_JZsdk_HalInfo));
    if (halInfo == NULL) 
    {
        JZSDK_LOG_ERROR("分配 HAL 信息内存失败");
        pthread_mutex_unlock(&g_initMutex);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    memset(halInfo, 0, sizeof(T_JZsdk_HalInfo));

    // 2. 分配句柄内存
    T_JZsdkHalHandle* handle = (T_JZsdkHalHandle*)malloc(sizeof(T_JZsdkHalHandle));
    if (handle == NULL) 
    {
        JZSDK_LOG_ERROR("分配 HAL 句柄内存失败");
        free(halInfo);
        pthread_mutex_unlock(&g_initMutex);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    // 3. 分配锁对象（使用 pthread_mutex_t）
    pthread_mutex_t* mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (mutex == NULL) 
    {
        JZSDK_LOG_ERROR("分配锁内存失败");
        free(handle);
        free(halInfo);
        pthread_mutex_unlock(&g_initMutex);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    pthread_mutex_init(mutex, NULL);

    // 4. 填充句柄
    handle->lockCtx = mutex;
    handle->lock = default_lock;
    handle->unlock = default_unlock;
    handle->PortIsUsed = JZsdk_Hal_PortIsUsed;
    handle->GetHalInfo = JZsdk_Get_HalInfo;

    // 5. 赋值给全局变量
    g_pHalInfo = halInfo;
    g_HalHandle = handle;

    pthread_mutex_unlock(&g_initMutex);

    JZSDK_LOG_INFO("JZSDK HAL INIT SUCCESS");
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**
 * HAL 去初始化（释放内存）
 */
T_JZsdkReturnCode JZsdk_HalDeinit(void)
{
    pthread_mutex_lock(&g_initMutex);

    if (g_HalHandle != NULL) {
        // 销毁锁
        pthread_mutex_t* mutex = (pthread_mutex_t*)g_HalHandle->lockCtx;
        if (mutex) {
            pthread_mutex_destroy(mutex);
            free(mutex);
        }
        free(g_HalHandle);
        g_HalHandle = NULL;
    }
    if (g_pHalInfo != NULL) {
        free(g_pHalInfo);
        g_pHalInfo = NULL;
    }

    pthread_mutex_unlock(&g_initMutex);
    JZSDK_LOG_INFO("JZSDK HAL 去初始化成功");
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}















//temp
/**************
 *
 *  jzsdk 获取hal的端口使用标志位
 *
 * *********************/
int JZsdk_HalPort_UseFlag(int PortName)
{
    for (int i = 0; i < g_pHalInfo->HaveUsePortNum; i++)
    {
        if (g_pHalInfo->HaveUsePortId[i] == PortName) 
        {
            return JZ_FLAGCODE_ON;
        }
    }

    return JZ_FLAGCODE_OFF;
}