#include "napi/native_api.h"
#include "napi/native_node_api.h"
#include "uart.h"
#include <bits/alltypes.h>
#include <stdlib.h>
#include "advio.h"
#include "hilog/log.h"
#undef LOG_DOMAIN
#undef LOG_TAG
#define LOG_DOMAIN 0x3200 
#define LOG_TAG "MY_TAG"
typedef struct {
    UART_HANDLE handle;
} UartHandleWrapper;
enum UartErrorCode { INVALID_ARGUMENT = -1, INTERNAL_INTERFACE_ERROR = -2, CREATE_ERROR = -3 };

static napi_value AdvioDevInit(napi_env env, napi_callback_info info) {
    napi_value ret;
    size_t argc = 0;
    napi_value argv[0];
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    if (argc != 0) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioDevInit();
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevClose(napi_env env, napi_callback_info info) {
    napi_value ret;
    size_t argc = 0;
    napi_value argv[0];
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    if (argc != 0) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioDevClose();
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64]; 
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}




static napi_value AdvioGetSPIDevHandle(napi_env env, napi_callback_info info) {
    napi_value ret;
    size_t argc = 0;
    napi_value argv[0];
    int handle = 0;

    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    if (argc != 0) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioGetSPIDevHandle(&handle);
    if (result == Success) {
        napi_create_int32(env, handle, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u",
                 result);                                        
        napi_throw_error(env, "OPERATION_FAILED", errorMessage); 
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevGetAIIntergration(napi_env env, napi_callback_info info) {
    napi_value ret;
    uint8_t flag = 0;
    size_t argc = 0;
    napi_value argv[0];
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    if (argc != 0) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioDevGetAIIntergration(&flag);

    if (result == Success) {
        napi_create_uint32(env, flag, &ret);
    } else {
        char errorMessage[64]; 
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevGetDrvVersion(napi_env env, napi_callback_info info) {
    napi_value ret;
    uint32_t version = 0;
    size_t argc = 0;
    napi_value argv[0];
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    if (argc != 0) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioDevGetDrvVersion(&version);
    if (result == Success) {
        napi_create_uint32(env, version, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevGetADDevInfo(napi_env env, napi_callback_info info) {
    napi_value ret;
    char pname[256] = "Default AD Module Name";
    char pinfo[256] = "1.0.0";
    ErrorCode result = AdvioDevGetADDevInfo(pname, pinfo);
    if (result == Success) {
        napi_value obj;
        napi_create_object(env, &obj);
        napi_value nameValue;
        napi_create_string_utf8(env, pname, NAPI_AUTO_LENGTH, &nameValue);
        napi_set_named_property(env, obj, "adDevName", nameValue);
        napi_value infoValue;
        napi_create_string_utf8(env, pinfo, NAPI_AUTO_LENGTH, &infoValue);
        napi_set_named_property(env, obj, "adDevInfo", infoValue);
        ret = obj;
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevAICalibrate(napi_env env, napi_callback_info info) {
    napi_value ret;
    size_t argc = 2;
    napi_value argv[2];
    uint8_t chan, calitype;

    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);

    if (argc < 2) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    uint32_t tmp;
    if (napi_get_value_uint32(env, argv[0], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    chan = (uint8_t)tmp;

    if (napi_get_value_uint32(env, argv[1], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    calitype = (uint8_t)tmp;

    ErrorCode result = AdvioDevAICalibrate(chan, calitype);
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevAICalibrateFlash(napi_env env, napi_callback_info info) {
    napi_value ret;
    size_t argc = 1;
    napi_value argv[1];
    uint8_t act_type;
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    if (argc < 1) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    uint32_t tmp;
    if (napi_get_value_uint32(env, argv[0], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    act_type = (uint8_t)tmp;
    ErrorCode result = AdvioDevAICalibrateFlash(act_type);
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevSetAIIntergration(napi_env env, napi_callback_info info) {
    napi_value ret;
    size_t argc = 1;
    napi_value argv[1];
    uint32_t flag;

    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);

    if (argc < 1) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    uint32_t tmp;
    if (napi_get_value_uint32(env, argv[0], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    flag = (uint8_t)tmp;

    ErrorCode result = AdvioDevSetAIIntergration(static_cast<uint8_t>(flag));
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevSetDoInitValue(napi_env env, napi_callback_info info) {
    size_t argc = 4;
    napi_value args[4];
    napi_value ret;

    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    if (argc != 4) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    uint32_t chStart, chCount, type;
    if (napi_get_value_uint32(env, args[0], &chStart) != napi_ok ||
        napi_get_value_uint32(env, args[1], &chCount) != napi_ok ||
        napi_get_value_uint32(env, args[2], &type) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    napi_typedarray_type array_type;
    size_t length;
    void *data;
    napi_value buffer;
    size_t byte_offset;
    if (napi_get_typedarray_info(env, args[3], &array_type, &length, &data, &buffer, &byte_offset) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    if (array_type != napi_uint32_array) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioDevSetDoInitValue(chStart, chCount, type, data);
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevGetAIRangeCode(napi_env env, napi_callback_info info) {
    /* size_t argc = 3;
     napi_value args[3];
     napi_value ret;
     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

     // 参数校验
     if (argc < 3) {
          //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
         napi_create_int32(env, INVALID_ARGUMENT, &ret);
         return ret;
     }
     // 解析startch
     unsigned char startch; // 修改为 unsigned char
     if (napi_get_value_uint32(env, args[0], reinterpret_cast<uint32_t *>(&startch)) != napi_ok ) {
          //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
         napi_create_int32(env, INVALID_ARGUMENT, &ret);
         return ret;
     }
     // 解析stopch
     unsigned char stopch; // 修改为 unsigned char
     if (napi_get_value_uint32(env, args[1], reinterpret_cast<uint32_t *>(&stopch)) != napi_ok ) {
          //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
         napi_create_int32(env, INVALID_ARGUMENT, &ret);
         return ret;
     }
     // 解析输出缓冲区
     void *poutbuf;
     size_t buffer_length;
     if (napi_get_buffer_info(env, args[2], &poutbuf, &buffer_length) != napi_ok) {
          //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
         napi_create_int32(env, INVALID_ARGUMENT, &ret);
         return ret;
     }
     // 检查缓冲区大小是否足够
     if (buffer_length < (stopch - startch + 1)) {
          //OH_LOG_ERROR(LOG_APP, "Buffer is small");
         napi_create_int32(env, INVALID_ARGUMENT, &ret);
         return ret;
     }
     ErrorCode result = AdvioDevGetAIRangeCode(startch, stopch, static_cast<unsigned char *>(poutbuf));
     // 返回错误码
     napi_create_uint32(env, static_cast<uint32_t>(result), &ret);
     return ret;*/
    size_t argc = 2;
    napi_value args[2];
    napi_value ret;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    if (argc != 2) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    unsigned char startch, stopch;
    uint32_t tmp;
    if (napi_get_value_uint32(env, args[0], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    startch = static_cast<unsigned char>(tmp);

    if (napi_get_value_uint32(env, args[1], &tmp) != napi_ok || tmp > 0xFF || tmp < startch) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    stopch = static_cast<unsigned char>(tmp);
    const uint32_t channelCount = stopch - startch + 1;
    const size_t bufferSize = channelCount * 2;

    void *bufferData;
    napi_value arrayBuffer;
    if (napi_create_arraybuffer(env, bufferSize, &bufferData, &arrayBuffer) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    napi_value typedArray;
    if (napi_create_typedarray(env, napi_uint8_array, bufferSize, arrayBuffer, 0, &typedArray) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    ErrorCode result =
        AdvioDevGetAIRangeCode(startch, stopch, static_cast<unsigned char *>(bufferData));
    if (result == Success) {
        return typedArray;
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
}

static napi_value AdvioDevGetDoInitValue(napi_env env, napi_callback_info info) {
    napi_status status;
    size_t argc = 3;
    napi_value args[3];
    napi_value ret;

    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    if (argc != 3) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    uint32_t chStart, chCount, type;
    if (napi_get_value_uint32(env, args[0], &chStart) != napi_ok ||
        napi_get_value_uint32(env, args[1], &chCount) != napi_ok ||
        napi_get_value_uint32(env, args[2], &type) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    size_t bufferLength = chCount * sizeof(uint32_t);
    void *bufferData = nullptr;
    napi_value arrayBuffer;
    status = napi_create_arraybuffer(env, bufferLength, &bufferData, &arrayBuffer);
    if (status != napi_ok || !bufferData) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    napi_value typedArray;
    status = napi_create_typedarray(env, napi_uint32_array, chCount, arrayBuffer, 0, &typedArray);
    if (status != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    ErrorCode result = AdvioDevGetDoInitValue(chStart, chCount, type, bufferData);

    if (result == Success) {
        return typedArray;
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
}
static napi_value AdvioSPIProtoIO(napi_env env, napi_callback_info info) {
    size_t argc = 4;
    napi_value args[4];
    napi_value ret;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    if (argc != 4) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    uint8_t inputLen, printFlag, outputLen = 6;
    uint32_t tmp, handle;
    if (napi_get_value_uint32(env, args[0], &handle) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    if (napi_get_value_uint32(env, args[2], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    inputLen = static_cast<uint8_t>(tmp);
    if (napi_get_value_uint32(env, args[3], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    printFlag = static_cast<uint8_t>(tmp);

    napi_typedarray_type array_type;
    size_t length;
    void *data;
    napi_value buffer;
    size_t byte_offset;
    if (napi_get_typedarray_info(env, args[1], &array_type, &length, &data, &buffer, &byte_offset) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    if (array_type != napi_uint8_array) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    size_t bufferLength = 64;
    void *bufferData = nullptr;
    napi_value arrayBuffer;
    if (napi_create_arraybuffer(env, bufferLength, &bufferData, &arrayBuffer) != napi_ok || !bufferData) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    napi_value outputArray;
    if (napi_create_typedarray(env, napi_uint8_array, 64, arrayBuffer, 0, &outputArray) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioSPIProtoIO(handle, static_cast<unsigned char *>(data), inputLen,
                                       static_cast<unsigned char *>(bufferData), &outputLen, printFlag);

    if (result == Success) {
        napi_value obj;
        napi_create_object(env, &obj);
        napi_value lenValue;
        napi_create_uint32(env, outputLen, &lenValue);
        napi_set_named_property(env, obj, "outputLen", lenValue);
        napi_set_named_property(env, obj, "outData", outputArray);
        ret = obj;
    } else {
        char errorMessage[64];
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevConstructSPIPackage(napi_env env, napi_callback_info info) {
    size_t argc = 5;
    napi_value args[5];
    napi_value ret;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    if (argc != 5) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    unsigned char moduleId, direction, commandId, bufLen;
    uint32_t tmp;
    if (napi_get_value_uint32(env, args[0], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    moduleId = static_cast<unsigned char>(tmp);

    if (napi_get_value_uint32(env, args[1], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    direction = static_cast<unsigned char>(tmp);
    if (napi_get_value_uint32(env, args[2], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    commandId = static_cast<unsigned char>(tmp);
    if (napi_get_value_uint32(env, args[4], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    bufLen = static_cast<unsigned char>(tmp);

    napi_typedarray_type array_type;
    size_t length;
    void *data;
    napi_value buffer;
    size_t byte_offset;
    if (napi_get_typedarray_info(env, args[3], &array_type, &length, &data, &buffer, &byte_offset) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    if (array_type != napi_uint8_array) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    size_t bufferLength = 64;
    void *bufferData = nullptr;
    napi_value arrayBuffer;
    if (napi_create_arraybuffer(env, bufferLength, &bufferData, &arrayBuffer) != napi_ok || !bufferData) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    napi_value typedArray;
    if (napi_create_typedarray(env, napi_uint8_array, 64, arrayBuffer, 0, &typedArray) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioDevConstructSPIPackage(moduleId, direction, commandId, static_cast<unsigned char *>(data),
                                                   bufLen, static_cast<unsigned char *>(bufferData));
    if (result == Success) {
        return typedArray;
    } else {
        char errorMessage[128];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
}

static napi_value AdvioDevSetAIRangeCode(napi_env env, napi_callback_info info) {
    size_t argc = 3;
    napi_value args[3];
    napi_value ret;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    if (argc != 3) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    unsigned char startch, stopch;
    uint32_t tmp;
    if (napi_get_value_uint32(env, args[0], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    startch = static_cast<unsigned char>(tmp);

    if (napi_get_value_uint32(env, args[1], &tmp) != napi_ok || tmp > 0xFF || tmp < startch) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    stopch = static_cast<unsigned char>(tmp);

    const uint32_t channelCount = stopch - startch + 1;
    const size_t bufferSize = channelCount * 2;

    napi_typedarray_type array_type;
    size_t length;
    void *data;
    napi_value buffer;
    size_t byte_offset;
    if (napi_get_typedarray_info(env, args[2], &array_type, &length, &data, &buffer, &byte_offset) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    if (array_type != napi_uint8_array || bufferSize != length) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    ErrorCode result = AdvioDevSetAIRangeCode(startch, stopch, static_cast<unsigned char *>(data));
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevAIRead(napi_env env, napi_callback_info info) {
    size_t argc = 2;
    napi_value args[2];
    napi_value ret;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    if (argc != 2) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    unsigned char startch, stopch;
    uint32_t tmp;
    if (napi_get_value_uint32(env, args[0], &tmp) != napi_ok || tmp > 0xFF) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    startch = static_cast<unsigned char>(tmp);

    if (napi_get_value_uint32(env, args[1], &tmp) != napi_ok || tmp > 0xFF || tmp < startch) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    stopch = static_cast<unsigned char>(tmp);
    const uint32_t channelCount = stopch - startch + 1;
    const size_t bufferSize = channelCount * 2;

    void *bufferData;
    napi_value arrayBuffer;
    if (napi_create_arraybuffer(env, bufferSize, &bufferData, &arrayBuffer) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }
    napi_value typedArray;
    if (napi_create_typedarray(env, napi_uint8_array, bufferSize, arrayBuffer, 0, &typedArray) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    ErrorCode result = AdvioDevAIRead(startch, stopch, static_cast<unsigned char *>(bufferData));
    if (result == Success) {
        return typedArray;
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
}

static napi_value AdvioDevDIRead(napi_env env, napi_callback_info info) {
    napi_value ret;
    unsigned int di_value = 0;

    ErrorCode result = AdvioDevDIRead(&di_value);

    if (result == Success) {
        napi_create_int32(env, di_value, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}
static napi_value AdvioDevDORead(napi_env env, napi_callback_info info) {
    napi_value ret;
    unsigned int do_value = 0;

    ErrorCode result = AdvioDevDORead(&do_value);

    if (result == Success) {
        napi_create_int32(env, do_value, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }

    return ret;
}

static napi_value AdvioDevDOWriteAll(napi_env env, napi_callback_info info) {
    napi_value ret;
    size_t argc = 1;
    napi_value args[1];

    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    unsigned int value;

    if (argc < 1 || napi_get_value_uint32(env, args[0], &value) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    ErrorCode result = AdvioDevDOWriteAll(value);
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevDOWriteOneChannel(napi_env env, napi_callback_info info) {
    napi_value ret;
    size_t argc = 2;
    napi_value args[2];

    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    unsigned int index;
    unsigned int value;

    if (argc < 2 || napi_get_value_uint32(env, args[0], &index) != napi_ok ||
        napi_get_value_uint32(env, args[1], &value) != napi_ok) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    ErrorCode result = AdvioDevDOWriteOneChannel(index, value);
    if (result == Success) {
        napi_create_int32(env, result, &ret);
    } else {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    return ret;
}

static napi_value AdvioDevGetDevInfo(napi_env env, napi_callback_info info) {
    napi_status status;
    size_t argc = 0;
    SPISearchDev dev_info = {0};

    status = napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
    if (status != napi_ok || argc != 0) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    napi_value ret;
    napi_create_object(env, &ret);
    napi_value value;
    ErrorCode result = AdvioDevGetDevInfo(&dev_info);
    if (result != Success) {
        char errorMessage[64];  
        snprintf(errorMessage, sizeof(errorMessage), "Operation failed with code: %u", result);
        napi_throw_error(env, "OPERATION_FAILED", errorMessage);
        return nullptr;
    }
    napi_create_uint32(env, dev_info.uModuleMode, &value);
    napi_set_named_property(env, ret, "moduleMode", value);

    napi_create_string_utf8(env, (const char *)dev_info.ucModuleName, NAPI_AUTO_LENGTH, &value);
    napi_set_named_property(env, ret, "moduleName", value);

    napi_create_uint32(env, dev_info.ulModuleVersion, &value);
    napi_set_named_property(env, ret, "version", value);

    napi_create_uint32(env, dev_info.ucAINum, &value);
    napi_set_named_property(env, ret, "aiChannels", value);

    napi_create_uint32(env, dev_info.ucAONum, &value);
    napi_set_named_property(env, ret, "aoChannels", value);

    napi_create_uint32(env, dev_info.ucDINum, &value);
    napi_set_named_property(env, ret, "diChannels", value);

    napi_create_uint32(env, dev_info.ucDONum, &value);
    napi_set_named_property(env, ret, "doChannels", value);

    napi_create_uint32(env, dev_info.ulresv, &value);
    napi_set_named_property(env, ret, "reserved", value);

    return ret;
}

static napi_value UartInit(napi_env env, napi_callback_info info) {
    size_t argc = 5;
    napi_value args[5];
    napi_value ret;

    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    if (argc < 5) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    napi_valuetype types[5];
    for (int i = 0; i < 5; ++i) {
        napi_typeof(env, args[i], &types[i]);
    }

    if (types[0] != napi_string || types[1] != napi_number || types[2] != napi_number || types[3] != napi_number ||
        types[4] != napi_number) {
        napi_throw_error(env, "INVALID_ARGUMENTS", "Invalid arguments passed to the function");
        return nullptr;
    }

    char dev[32];
    size_t str_len;
    int baudrate, byteSize, stopBits, parity;

    napi_get_value_string_utf8(env, args[0], dev, sizeof(dev), &str_len);
    napi_get_value_int32(env, args[1], &baudrate);
    napi_get_value_int32(env, args[2], &byteSize);
    napi_get_value_int32(env, args[3], &stopBits);
    napi_get_value_int32(env, args[4], &parity);

    UART_HANDLE handle = UartInit(dev, baudrate, byteSize, stopBits, parity);
    napi_create_int32(env, handle, &ret);
    return ret;
}

static napi_value UartSend(napi_env env, napi_callback_info info) {
    size_t argc = 2;
    napi_value args[2];
    napi_value ret;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    if (argc != 2) {
         //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }
    int32_t handle;
    if (napi_get_value_int32(env, args[0], &handle) != napi_ok) {
         //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }

    napi_typedarray_type array_type;
    size_t array_length;
    void *data;
    napi_value buffer;
    size_t byte_offset;
    if (napi_get_typedarray_info(env, args[1], &array_type, &array_length, &data, &buffer, &byte_offset) != napi_ok) {
         //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }
    if (array_type != napi_uint8_array) {
         //OH_LOG_ERROR(LOG_APP, "array_type is uint8_array");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }
    uint8_t *byteArray = (uint8_t *)data;
    int result = UartSend(handle, byteArray, array_length);
    if (result != array_length ) {
         //OH_LOG_ERROR(LOG_APP, "Send failed");
        napi_create_int32(env, INTERNAL_INTERFACE_ERROR, &ret);
        return ret;
    }
    napi_create_int32(env, result, &ret);
    return ret;
}

static napi_value UartRecv(napi_env env, napi_callback_info info) {
    size_t argc = 2;
    napi_value args[2];
    napi_value ret;

    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    if (argc < 2) {
         //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }

    int32_t handle;
    if (napi_get_value_int32(env, args[0], &handle) != napi_ok) {
         //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }

    void *buffer_data;
    size_t buffer_length;
    if (napi_get_buffer_info(env, args[1], &buffer_data, &buffer_length) != napi_ok) {
         //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }

    int result = UartRecv(handle, buffer_data, buffer_length);
    if (result > 0) {
        napi_create_int32(env, result, &ret);
    } else {
         //OH_LOG_ERROR(LOG_APP, "Receive failed");
        napi_create_int32(env, INTERNAL_INTERFACE_ERROR, &ret);
    }
    return ret;
}

static napi_value UartUninit(napi_env env, napi_callback_info info) {
    size_t argc = 1;
    napi_value args[1];
    napi_value ret;

    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    if (argc < 1) {
         //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }
    int32_t handle;
    if (napi_get_value_int32(env, args[0], &handle) != napi_ok) {
         //OH_LOG_ERROR(LOG_APP, "Invalid arguments");
        napi_create_int32(env, INVALID_ARGUMENT, &ret);
        return ret;
    }

    int result = UartUninit(handle);

    napi_create_int32(env, result, &ret);
    return ret;
}

EXTERN_C_START
static napi_value Init(napi_env env, napi_value exports) {
    napi_property_descriptor desc[] = {
        {"uartInit", nullptr, UartInit, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"uartSend", nullptr, UartSend, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"uartRecv", nullptr, UartRecv, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"uartUninit", nullptr, UartUninit, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devInit", nullptr, AdvioDevInit, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devClose", nullptr, AdvioDevClose, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devGetAIRangeCode", nullptr, AdvioDevGetAIRangeCode, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devSetAIRangeCode", nullptr, AdvioDevSetAIRangeCode, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devAIRead", nullptr, AdvioDevAIRead, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devDIRead", nullptr, AdvioDevDIRead, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devDORead", nullptr, AdvioDevDORead, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devDOWriteAll", nullptr, AdvioDevDOWriteAll, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devDOWriteOneChannel", nullptr, AdvioDevDOWriteOneChannel, nullptr, nullptr, nullptr, napi_default,
         nullptr},
        {"devGetDevInfo", nullptr, AdvioDevGetDevInfo, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"getSPIDevHandle", nullptr, AdvioGetSPIDevHandle, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devGetADDevInfo", nullptr, AdvioDevGetADDevInfo, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devAICalibrate", nullptr, AdvioDevAICalibrate, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devAICalibrateFlash", nullptr, AdvioDevAICalibrateFlash, nullptr, nullptr, nullptr, napi_default,
         nullptr},
        {"devSetAIIntergration", nullptr, AdvioDevSetAIIntergration, nullptr, nullptr, nullptr, napi_default,
         nullptr},
        {"devGetAIIntergration", nullptr, AdvioDevGetAIIntergration, nullptr, nullptr, nullptr, napi_default,
         nullptr},
        {"devGetDrvVersion", nullptr, AdvioDevGetDrvVersion, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devSetDoInitValue", nullptr, AdvioDevSetDoInitValue, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devGetDoInitValue", nullptr, AdvioDevGetDoInitValue, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"devConstructSPIPackage", nullptr, AdvioDevConstructSPIPackage, nullptr, nullptr, nullptr, napi_default,
         nullptr},
        {"spiProtoIO", nullptr, AdvioSPIProtoIO, nullptr, nullptr, nullptr, napi_default, nullptr},
    };
    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
    return exports;
}
EXTERN_C_END

// 模块定义
static napi_module demoModule = {
    .nm_version = 1,
    .nm_flags = 0,
    .nm_filename = nullptr,
    .nm_register_func = Init,
    .nm_modname = "it3256",
    .nm_priv = ((void *)0),
    .reserved = {0},
};

extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }