#include "smart_json_wrapper.h"
#include "KinematicsWebAPI.h"
#include <emscripten.h>
#include <cmath>
#include <chrono>
#include <sstream>
#include <iomanip>
#include <regex>
#include <algorithm>
#include <memory>
#include <iostream>
#include <cstring>
#include <cctype>

// ========== 内存管理辅助函数 ==========
namespace
{
    // 创建 WASM 内存中的字符串（使用 malloc 分配，与 JavaScript 的 _free 兼容）
    char *createWasmString(const std::string &str)
    {
        if (str.empty())
        {
            char *buffer = (char *)malloc(1);
            if (buffer)
            {
                buffer[0] = '\0';
            }
            return buffer;
        }

        size_t len = str.length();
        char *buffer = (char *)malloc(len + 1); // +1 for null terminator

        if (buffer)
        {
            // 使用 std::copy 复制字符串内容
            std::copy(str.begin(), str.end(), buffer);
            buffer[len] = '\0'; // 添加 null 终止符
        }

        return buffer;
    }

    // 安全释放 WASM 字符串（使用 free 释放，与 JavaScript 的 _free 兼容）
    void freeWasmString(const char *str)
    {
        if (str)
        {
            free(const_cast<char *>(str));
        }
    }
}

// ========== SmartResponse 实现 ==========
std::string SmartResponse::toJson() const
{
    std::stringstream ss;
    ss << "{";
    ss << "\"success\":" << (success ? "true" : "false") << ",";
    ss << "\"code\":" << code << ",";
    ss << "\"msg\":\"" << msg << "\",";
    ss << "\"req_code\":\"" << req_code << "\",";
    ss << "\"req_cmd\":\"" << req_cmd << "\",";
    ss << "\"execution_time\":" << std::fixed << std::setprecision(3) << execution_time << ",";

    // 处理结果数据
    ss << "\"res_data\":";
    if (res_data.has_value())
    {
        try
        {
            if (res_data.type() == typeid(int))
            {
                ss << std::any_cast<int>(res_data);
            }
            else if (res_data.type() == typeid(float))
            {
                ss << std::fixed << std::setprecision(3) << std::any_cast<float>(res_data);
            }
            else if (res_data.type() == typeid(double))
            {
                ss << std::fixed << std::setprecision(3) << std::any_cast<double>(res_data);
            }
            else if (res_data.type() == typeid(bool))
            {
                ss << (std::any_cast<bool>(res_data) ? "true" : "false");
            }
            else if (res_data.type() == typeid(std::string))
            {
                ss << "\"" << std::any_cast<std::string>(res_data) << "\"";
            }
            else if (res_data.type() == typeid(std::vector<int>))
            {
                auto arr = std::any_cast<std::vector<int>>(res_data);
                ss << "[";
                for (size_t i = 0; i < arr.size(); ++i)
                {
                    if (i > 0)
                        ss << ",";
                    ss << arr[i];
                }
                ss << "]";
            }
            else
            {
                // 默认处理为字符串
                ss << "\"complex_data\"";
            }
        }
        catch (const std::bad_any_cast &)
        {
            ss << "null";
        }
    }
    else
    {
        ss << "null";
    }

    // 执行信息
    if (!execution_info.empty())
    {
        ss << ",\"execution_info\":{";
        bool first = true;
        for (const auto &[key, value] : execution_info)
        {
            if (!first)
                ss << ",";
            ss << "\"" << key << "\":\"" << value << "\"";
            first = false;
        }
        ss << "}";
    }

    ss << "}";
    return ss.str();
}

SmartResponse SmartResponse::createSuccess(const std::string &req_code,
                                           const std::string &req_cmd,
                                           const std::any &data)
{
    SmartResponse resp;
    resp.success = true;
    resp.code = 0;
    resp.msg = "操作成功";
    resp.req_code = req_code;
    resp.req_cmd = req_cmd;
    resp.res_data = data;
    return resp;
}

SmartResponse SmartResponse::createError(const std::string &req_code,
                                         const std::string &req_cmd,
                                         int code,
                                         const std::string &msg)
{
    SmartResponse resp;
    resp.success = false;
    resp.code = code;
    resp.msg = msg;
    resp.req_code = req_code;
    resp.req_cmd = req_cmd;
    return resp;
}

// ========== 字符串工具函数 ==========
std::string SmartJsonProcessor::trim(const std::string &str)
{
    size_t first = str.find_first_not_of(" \t\n\r");
    if (first == std::string::npos)
        return "";
    size_t last = str.find_last_not_of(" \t\n\r");
    return str.substr(first, (last - first + 1));
}

std::vector<std::string> SmartJsonProcessor::split(const std::string &str, char delimiter)
{
    std::vector<std::string> tokens;
    std::stringstream ss(str);
    std::string token;
    while (std::getline(ss, token, delimiter))
    {
        token = trim(token);
        if (!token.empty())
        {
            tokens.push_back(token);
        }
    }
    return tokens;
}

// ========== SmartJsonProcessor 实现 ==========
SmartJsonProcessor::SmartJsonProcessor()
{
    registerMathFunctions();
}

SmartJsonProcessor::~SmartJsonProcessor()
{
    // 清理资源
}

// ========== JSON 解析 ==========
std::map<std::string, std::any> SmartJsonProcessor::parseJsonParams(const std::string &json_str)
{
    std::map<std::string, std::any> params;

    // 简化JSON解析，解析键值对
    std::regex param_regex("\"([^\"]+)\"\\s*:\\s*([^,}\\s\"]+|\"[^\"]*\")");
    std::sregex_iterator it(json_str.begin(), json_str.end(), param_regex);
    std::sregex_iterator end;

    while (it != end)
    {
        std::smatch match = *it;
        std::string key = match[1].str();
        std::string value = match[2].str();

        // 移除引号
        if (!value.empty() && value[0] == '"' && value.back() == '"')
        {
            value = value.substr(1, value.length() - 2);
        }

        params[key] = inferJsonValue(key, value);
        ++it;
    }

    // 特别处理数组参数
    std::regex array_regex("\"([^\"]+)\"\\s*:\\s*\\[([^\\]]*)\\]");
    it = std::sregex_iterator(json_str.begin(), json_str.end(), array_regex);

    while (it != end)
    {
        std::smatch match = *it;
        std::string key = match[1].str();
        std::string array_str = match[2].str();

        // 尝试解析为整数数组
        auto int_array = parseIntArray(array_str);
        if (!int_array.empty())
        {
            params[key] = int_array;
        }
        else
        {
            // 尝试解析为浮点数数组
            auto float_array = parseFloatArray(array_str);
            if (!float_array.empty())
            {
                params[key] = float_array;
            }
        }
        ++it;
    }

    return params;
}

std::any SmartJsonProcessor::inferJsonValue(const std::string &key, const std::string &value_str)
{
    if (value_str.empty())
    {
        return std::string();
    }

    // 根据键名猜测类型
    std::string lower_key = key;
    // std::transform(lower_key.begin(), lower_key.end(), lower_key.begin(), ::towlower);
    // std::transform(lower_key.begin(), lower_key.end(), lower_key.begin(), std::tolower);

    // 布尔值
    if (value_str == "true" || value_str == "false")
    {
        return value_str == "true";
    }

    // 尝试解析为数字
    try
    {
        // 检查是否是整数
        // if (value_str.find('.') == std::string::npos && value_str.find('e') == std::string::npos)
        // {
        //     return std::stoi(value_str);
        // }
        // else
        // {
        //     return std::stof(value_str);
        // }
    }
    catch (...)
    {
        // 不是数字，保持字符串
    }

    return value_str;
}

std::vector<int> SmartJsonProcessor::parseIntArray(const std::string &array_str)
{
    std::vector<int> result;
    auto tokens = split(array_str, ',');

    for (const auto &token : tokens)
    {
        try
        {
            result.push_back(std::stoi(trim(token)));
        }
        catch (...)
        {
            // 转换失败，清空数组并返回
            result.clear();
            break;
        }
    }

    return result;
}

std::vector<float> SmartJsonProcessor::parseFloatArray(const std::string &array_str)
{
    std::vector<float> result;
    auto tokens = split(array_str, ',');

    for (const auto &token : tokens)
    {
        try
        {
            result.push_back(std::stof(trim(token)));
        }
        catch (...)
        {
            // 转换失败，清空数组并返回
            result.clear();
            break;
        }
    }

    return result;
}

// ========== 数学函数注册 ==========
void SmartJsonProcessor::registerMathFunctions()
{
    auto &registry = FunctionRegistry::instance();

    // 1. add 函数
    auto add_func = std::make_shared<FunctionInfo>("add", "整数加法");
    add_func->addParam("a", ParamType::INT, 0)
        .addParam("b", ParamType::INT, 0)
        .addAlias("a", {"num1", "first", "x", "operand1", "left"})
        .addAlias("b", {"num2", "second", "y", "operand2", "right"})
        .setHandler([](const std::vector<std::any> &args) -> std::any
                    {
                if (args.size() >= 2) {
                    int a = 0, b = 0;
                    try {
                        a = std::any_cast<int>(args[0]);
                        b = std::any_cast<int>(args[1]);
                    } catch (...) {
                        // 尝试转换
                        if (args[0].type() == typeid(float)) a = static_cast<int>(std::any_cast<float>(args[0]));
                        if (args[1].type() == typeid(float)) b = static_cast<int>(std::any_cast<float>(args[1]));
                    }
                    return add(a, b);
                }
                return 0; });
    registry.registerFunction(add_func);

    // 2. subtract 函数
    auto sub_func = std::make_shared<FunctionInfo>("subtract", "整数减法");
    sub_func->addParam("a", ParamType::INT, 0)
        .addParam("b", ParamType::INT, 0)
        .addAlias("a", {"num1", "minuend", "x"})
        .addAlias("b", {"num2", "subtrahend", "y"})
        .setHandler([](const std::vector<std::any> &args) -> std::any
                    {
                if (args.size() >= 2) {
                    int a = 0, b = 0;
                    try {
                        a = std::any_cast<int>(args[0]);
                        b = std::any_cast<int>(args[1]);
                    } catch (...) {
                        if (args[0].type() == typeid(float)) a = static_cast<int>(std::any_cast<float>(args[0]));
                        if (args[1].type() == typeid(float)) b = static_cast<int>(std::any_cast<float>(args[1]));
                    }
                    return subtract(a, b);
                }
                return 0; });
    registry.registerFunction(sub_func);

    // 3. multiply 函数
    auto mul_func = std::make_shared<FunctionInfo>("multiply", "乘法运算");
    mul_func->addParam("a", ParamType::FLOAT, 0.0f)
        .addParam("b", ParamType::FLOAT, 0.0f)
        .addAlias("a", {"num1", "factor1", "x", "multiplicand"})
        .addAlias("b", {"num2", "factor2", "y", "multiplier"})
        .setHandler([](const std::vector<std::any> &args) -> std::any
                    {
                if (args.size() >= 2) {
                    float a = 0.0f, b = 0.0f;
                    try {
                        if (args[0].type() == typeid(float)) a = std::any_cast<float>(args[0]);
                        else if (args[0].type() == typeid(int)) a = static_cast<float>(std::any_cast<int>(args[0]));
                        if (args[1].type() == typeid(float)) b = std::any_cast<float>(args[1]);
                        else if (args[1].type() == typeid(int)) b = static_cast<float>(std::any_cast<int>(args[1]));
                    } catch (...) {
                        // 使用默认值
                    }
                    return multiply(a, b);
                }
                return 0.0f; });
    registry.registerFunction(mul_func);

    // 4. divide 函数
    auto div_func = std::make_shared<FunctionInfo>("divide", "除法运算");
    div_func->addParam("a", ParamType::FLOAT, 0.0f)
        .addParam("b", ParamType::FLOAT, 1.0f)
        .addAlias("a", {"numerator", "dividend", "x"})
        .addAlias("b", {"denominator", "divisor", "y"})
        .setHandler([](const std::vector<std::any> &args) -> std::any
                    {
                if (args.size() >= 2) {
                    float a = 0.0f, b = 1.0f;
                    try {
                        if (args[0].type() == typeid(float)) a = std::any_cast<float>(args[0]);
                        else if (args[0].type() == typeid(int)) a = static_cast<float>(std::any_cast<int>(args[0]));
                        if (args[1].type() == typeid(float)) b = std::any_cast<float>(args[1]);
                        else if (args[1].type() == typeid(int)) b = static_cast<float>(std::any_cast<int>(args[1]));
                    } catch (...) {
                        // 使用默认值
                    }
                    if (b == 0.0f) {
                        throw std::runtime_error("除数不能为零");
                    }
                    return divide(a, b);
                }
                return 0.0f; });
    registry.registerFunction(div_func);

    // 5. fibonacci 函数
    auto fib_func = std::make_shared<FunctionInfo>("fibonacci", "斐波那契数列");
    fib_func->addParam("n", ParamType::INT, 0)
        .addAlias("n", {"number", "index", "term", "position"})
        .setHandler([](const std::vector<std::any> &args) -> std::any
                    {
                if (!args.empty()) {
                    int n = 0;
                    try {
                        n = std::any_cast<int>(args[0]);
                    } catch (...) {
                        if (args[0].type() == typeid(float)) n = static_cast<int>(std::any_cast<float>(args[0]));
                    }
                    if (n < 0) n = 0;
                    if (n > 40) n = 40; // 限制大小避免性能问题
                    return fibonacci(n);
                }
                return 0; });
    registry.registerFunction(fib_func);

    // 6. create_buffer 函数
    auto create_buf_func = std::make_shared<FunctionInfo>("create_buffer", "创建缓冲区");
    create_buf_func->addParam("size", ParamType::INT, 1024)
        .addAlias("size", {"length", "capacity", "bytes"})
        .setHandler([](const std::vector<std::any> &args) -> std::any
                    {
                    if (!args.empty()) {
                        int size = 1024;
                        try {
                            size = std::any_cast<int>(args[0]);
                        } catch (...) {
                            if (args[0].type() == typeid(float)) size = static_cast<int>(std::any_cast<float>(args[0]));
                        }
                        if (size <= 0) size = 1024;
                        if (size > 1024 * 1024) size = 1024 * 1024; // 限制1MB
                        void* buffer = create_buffer(size);
                        std::stringstream ss;
                        ss << "0x" << std::hex << reinterpret_cast<uintptr_t>(buffer);
                        return ss.str();
                    }
                    return "null"; });
    registry.registerFunction(create_buf_func);

    // 7. compute_sum 函数
    auto sum_func = std::make_shared<FunctionInfo>("compute_sum", "数组求和");
    sum_func->addParam("array", ParamType::INT_ARRAY, std::vector<int>())
        .addAlias("array", {"arr", "list", "values", "numbers"})
        .setHandler([](const std::vector<std::any> &args) -> std::any
                    {
                if (!args.empty()) {
                    try {
                        auto arr = std::any_cast<std::vector<int>>(args[0]);
                        if (arr.empty()) return 0;
                        return compute_sum(arr.data(), static_cast<int>(arr.size()));
                    } catch (...) {
                        return 0;
                    }
                }
                return 0; });
    registry.registerFunction(sum_func);

    // 8. get_greeting 函数
    auto greet_func = std::make_shared<FunctionInfo>("get_greeting", "获取问候语");
    greet_func->setHandler([](const std::vector<std::any> &args) -> std::any
                           {
        const char* greeting = get_greeting();
        return std::string(greeting); });
    registry.registerFunction(greet_func);
}

// ========== 主处理函数 ==========
SmartResponse SmartJsonProcessor::processRequest(const std::string &json_request)
{
    auto start_time = std::chrono::high_resolution_clock::now();

    try
    {
        // 1. 解析基础信息
        std::string req_code = "REQ_" + std::to_string(std::chrono::system_clock::now().time_since_epoch().count());
        std::string req_cmd = "unknown";

        // 简化解析req_cmd
        std::regex cmd_regex("\"req_cmd\"\\s*:\\s*\"([^\"]+)\"");
        std::smatch match;
        if (std::regex_search(json_request, match, cmd_regex))
        {
            req_cmd = match[1].str();
        }

        // 2. 获取函数信息
        auto &registry = FunctionRegistry::instance();
        auto func_info = registry.getFunction(req_cmd);

        if (!func_info)
        {
            return SmartResponse::createError(req_code, req_cmd, 1001,
                                              "未找到函数: " + req_cmd);
        }

        // 3. 解析参数
        auto input_params = parseJsonParams(json_request);

        // 4. 智能参数匹配
        auto matched_params = registry.smartMatchParams(func_info, input_params);

        // 5. 验证参数
        std::string error_msg;
        if (!func_info->validateParams(matched_params, error_msg))
        {
            return SmartResponse::createError(req_code, req_cmd, 1002, error_msg);
        }

        // 6. 准备调用参数
        std::vector<std::any> call_args;
        for (const auto &param : func_info->params)
        {
            auto it = matched_params.find(param.name);
            if (it != matched_params.end())
            {
                call_args.push_back(it->second);
            }
            else if (param.default_value.has_value())
            {
                call_args.push_back(param.default_value);
            }
            else
            {
                call_args.push_back(std::any()); // 空值
            }
        }

        // 7. 执行函数
        std::any result;
        try
        {
            result = func_info->handler(call_args);
        }
        catch (const std::exception &e)
        {
            return SmartResponse::createError(req_code, req_cmd, 3001,
                                              std::string("执行错误: ") + e.what());
        }

        // 8. 构建响应
        auto response = SmartResponse::createSuccess(req_code, req_cmd, result);

        // 9. 添加执行信息
        response.execution_info["matched_params"] = std::to_string(matched_params.size());
        response.execution_info["function"] = func_info->name;

        // 10. 计算执行时间
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
            end_time - start_time);
        response.execution_time = duration.count() / 1000.0;

        return response;
    }
    catch (const std::exception &e)
    {
        return SmartResponse::createError("ERROR", "unknown", 5001,
                                          std::string("处理异常: ") + e.what());
    }
}

std::map<std::string, std::shared_ptr<FunctionInfo>>
SmartJsonProcessor::getAvailableFunctions() const
{
    auto &registry = FunctionRegistry::instance();
    return registry.getAllFunctions();
}

std::string SmartJsonProcessor::getFunctionInfo(const std::string &func_name) const
{
    auto &registry = FunctionRegistry::instance();
    auto func_info = registry.getFunction(func_name);

    if (!func_info)
    {
        return "函数未找到: " + func_name;
    }

    std::stringstream ss;
    ss << "函数: " << func_info->name << "\n";
    ss << "描述: " << func_info->description << "\n";
    ss << "参数:\n";

    for (const auto &param : func_info->params)
    {
        ss << "  - " << param.name << " (" << param.getTypeName() << ")";
        if (param.is_optional)
            ss << " [可选]";
        if (param.default_value.has_value())
        {
            ss << " [默认: ";
            try
            {
                if (param.type == ParamType::INT)
                    ss << param.convert<int>(param.default_value);
                else if (param.type == ParamType::FLOAT)
                    ss << param.convert<float>(param.default_value);
                else if (param.type == ParamType::STRING)
                    ss << param.convert<std::string>(param.default_value);
            }
            catch (...)
            {
                ss << "unknown";
            }
            ss << "]";
        }
        ss << "\n";
    }

    return ss.str();
}

// ========== WASM 导出函数 ==========
static SmartJsonProcessor *g_smart_processor = nullptr;
// 信号处理
static KinematicsWebAPI *global_server = nullptr;

EMSCRIPTEN_KEEPALIVE
const char *init_func()
{
    try
    {
        if (!global_server)
        {
            global_server = new KinematicsWebAPI();
        }
        if (!global_server)
        {
            auto error = SmartResponse::createError("ERROR", "unknown", 1001, "init_func 请求数据为空");
            return createWasmString(error.toJson());
        }

        auto response = SmartResponse::createSuccess("req_code", "init_func");

        return createWasmString(response.toJson());
    }
    catch (const std::exception &e)
    {
        auto error = SmartResponse::createError("ERROR", "unknown", 5001,
                                                std::string("处理异常: ") + e.what());
        return createWasmString(error.toJson());
    }
}

EMSCRIPTEN_KEEPALIVE
const char *func(const char *json_request)
{
    if (!global_server)
    {
        // 注意：这里需要动态分配，否则作用域结束会被销毁
        global_server = new KinematicsWebAPI();
    }

    try
    {
        if (!json_request)
        {
            auto error = SmartResponse::createError("ERROR", "unknown", 1001, "请求数据为空");
            return createWasmString(error.toJson());
        }

        std::string request_str(json_request);

        std::string response_str = global_server->func(request_str);

        return createWasmString(response_str);
    }
    catch (const std::exception &e)
    {
        auto error = SmartResponse::createError("ERROR", "unknown", 5001,
                                                std::string("处理异常: ") + e.what());
        return createWasmString(error.toJson());
    }
}

EMSCRIPTEN_KEEPALIVE
const char *smart_process_json(const char *json_request)
{
    if (!g_smart_processor)
    {
        g_smart_processor = new SmartJsonProcessor();
    }

    try
    {
        if (!json_request)
        {
            auto error = SmartResponse::createError("ERROR", "unknown", 1001, "请求数据为空");
            return createWasmString(error.toJson());
        }

        std::string request_str(json_request);
        auto response = g_smart_processor->processRequest(request_str);

        return createWasmString(response.toJson());
    }
    catch (const std::exception &e)
    {
        auto error = SmartResponse::createError("ERROR", "unknown", 5001,
                                                std::string("处理异常: ") + e.what());
        return createWasmString(error.toJson());
    }
}

EMSCRIPTEN_KEEPALIVE
const char *smart_get_function_list()
{
    if (!g_smart_processor)
    {
        g_smart_processor = new SmartJsonProcessor();
    }

    try
    {
        auto functions = g_smart_processor->getAvailableFunctions();

        std::stringstream ss;
        ss << "[";
        bool first = true;
        for (const auto &[name, func_info] : functions)
        {
            if (!first)
                ss << ",";
            ss << "{";
            ss << "\"name\":\"" << name << "\",";
            ss << "\"description\":\"" << func_info->description << "\",";
            ss << "\"params\":[";
            bool first_param = true;
            for (const auto &param : func_info->params)
            {
                if (!first_param)
                    ss << ",";
                ss << "{";
                ss << "\"name\":\"" << param.name << "\",";
                ss << "\"type\":\"" << param.getTypeName() << "\",";
                ss << "\"optional\":" << (param.is_optional ? "true" : "false");
                ss << "}";
                first_param = false;
            }
            ss << "]";
            ss << "}";
            first = false;
        }
        ss << "]";

        std::string result_str = ss.str();
        return createWasmString(result_str);
    }
    catch (const std::exception &e)
    {
        std::string error = "{\"error\":\"" + std::string(e.what()) + "\"}";
        return createWasmString(error);
    }
}

EMSCRIPTEN_KEEPALIVE
const char *smart_get_function_info(const char *func_name)
{
    if (!g_smart_processor)
    {
        g_smart_processor = new SmartJsonProcessor();
    }

    try
    {
        if (!func_name)
        {
            std::string error = "{\"error\":\"函数名不能为空\"}";
            return createWasmString(error);
        }

        std::string info = g_smart_processor->getFunctionInfo(func_name);
        return createWasmString(info);
    }
    catch (const std::exception &e)
    {
        std::string error = "{\"error\":\"" + std::string(e.what()) + "\"}";
        return createWasmString(error);
    }
}

EMSCRIPTEN_KEEPALIVE
const char *smart_test_match(const char *json_request)
{
    if (!g_smart_processor)
    {
        g_smart_processor = new SmartJsonProcessor();
    }

    try
    {
        if (!json_request)
        {
            auto error = SmartResponse::createError("TEST", "test", 1001, "请求数据为空");
            return createWasmString(error.toJson());
        }

        // 演示智能匹配过程
        std::string request_str(json_request);

        // 解析请求
        std::regex cmd_regex("\"req_cmd\"\\s*:\\s*\"([^\"]+)\"");
        std::smatch match;
        std::string req_cmd = "unknown";
        if (std::regex_search(request_str, match, cmd_regex))
        {
            req_cmd = match[1].str();
        }

        auto &registry = FunctionRegistry::instance();
        auto func_info = registry.getFunction(req_cmd);

        if (!func_info)
        {
            auto error = SmartResponse::createError("TEST", req_cmd, 1001,
                                                    "未找到函数: " + req_cmd);
            error.execution_info["test_type"] = "function_not_found";
            return createWasmString(error.toJson());
        }

        // 解析参数
        SmartJsonProcessor processor;
        auto input_params = processor.parseJsonParams(request_str);

        // 智能匹配
        auto matched_params = registry.smartMatchParams(func_info, input_params);

        // 显示匹配结果
        std::stringstream ss;
        ss << "{\"test\":\"smart_match\",";
        ss << "\"function\":\"" << func_info->name << "\",";
        ss << "\"description\":\"" << func_info->description << "\",";

        ss << "\"input_params\":[";
        bool first = true;
        for (const auto &[key, value] : input_params)
        {
            if (!first)
                ss << ",";
            ss << "{\"key\":\"" << key << "\",";
            ss << "\"type\":\"" << static_cast<int>(registry.deduceParamType(value)) << "\"}";
            first = false;
        }
        ss << "],";

        ss << "\"matched_params\":[";
        first = true;
        for (const auto &[key, value] : matched_params)
        {
            if (!first)
                ss << ",";
            ss << "{\"key\":\"" << key << "\",";
            ss << "\"type\":\"" << static_cast<int>(registry.deduceParamType(value)) << "\"}";
            first = false;
        }
        ss << "]";

        ss << "}";

        std::string result_str = ss.str();
        return createWasmString(result_str);
    }
    catch (const std::exception &e)
    {
        std::string error = "{\"error\":\"" + std::string(e.what()) + "\"}";
        return createWasmString(error);
    }
}

EMSCRIPTEN_KEEPALIVE
const char *smart_get_version()
{
    std::string version = "{\"version\":\"1.0.0\",\"name\":\"Smart WASM JSON API\"}";
    return createWasmString(version);
}

EMSCRIPTEN_KEEPALIVE
void smart_free_string(const char *str)
{
    freeWasmString(str);
}

// 导出额外的辅助函数
EMSCRIPTEN_KEEPALIVE
void *wasm_malloc(size_t size)
{
    return malloc(size);
}

EMSCRIPTEN_KEEPALIVE
void wasm_free(void *ptr)
{
    if (ptr)
    {
        free(ptr);
    }
}