/* c_src/my_nif.c */
#include <erl_nif.h>

/* NIF 函数：加法 */
static ERL_NIF_TERM add(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    int a, b;
    
    /* 从 Erlang term 提取参数 */
    if (!enif_get_int(env, argv[0], &a) ||
        !enif_get_int(env, argv[1], &b)) {
        return enif_make_badarg(env);
    }
    
    /* 返回结果 */
    return enif_make_int(env, a + b);
}

/* NIF 函数：字符串处理 */
static ERL_NIF_TERM string_length(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    ErlNifBinary bin;
    
    if (!enif_inspect_binary(env, argv[0], &bin)) {
        return enif_make_badarg(env);
    }
    
    return enif_make_int(env, bin.size);
}

/* NIF 函数数组 */
static ErlNifFunc nif_funcs[] = {
    {"add", 2, add},
    {"string_length", 1, string_length}
};

/* 初始化模块 */
ERL_NIF_INIT(my_nif, nif_funcs, NULL, NULL, NULL, NULL)

%% src/my_nif.erl
-module(my_nif).
-export([add/2, string_length/1]).

-on_load(load_nif/0).

load_nif() ->
    SoName = filename:join(code:priv_dir(my_nif), "my_nif"),
    erlang:load_nif(SoName, 0).

%% NIF 实现（如果加载失败，会调用这些后备实现）
add(_A, _B) ->
    erlang:nif_error("NIF library not loaded").

string_length(_Str) ->
    erlang:nif_error("NIF library not loaded").

%% rebar.config
{plugins, [rebar3_hex]}.

{port_specs, [
    {"priv/my_nif.so", ["c_src/*.c"]}
]}.

{provider_hooks, [
    {pre, [{compile, {pc, compile}}]},
    {clean, {pc, clean}}
]}.

{deps, [
    {pc, "1.15.0"}  %% rebar3 port compiler plugin
]}.

/* 创建元组 {ok, Result} */
static ERL_NIF_TERM make_ok(ErlNifEnv* env, ERL_NIF_TERM result)
{
    return enif_make_tuple2(env, 
        enif_make_atom(env, "ok"),
        result);
}

/* 创建错误元组 {error, Reason} */
static ERL_NIF_TERM make_error(ErlNifEnv* env, const char* reason)
{
    return enif_make_tuple2(env,
        enif_make_atom(env, "error"),
        enif_make_atom(env, reason));
}

/* 从列表创建 Erlang binary */
static ERL_NIF_TERM make_binary_string(ErlNifEnv* env, const char* str)
{
    ErlNifBinary bin;
    size_t len = strlen(str);
    enif_alloc_binary(len, &bin);
    memcpy(bin.data, str, len);
    return enif_make_binary(env, &bin);
}

/* 每个 NIF 调用都有一个环境 */
static ERL_NIF_TERM my_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    /* 在这个环境中分配的内存会在函数返回时自动释放 */
    /* 所以不需要手动释放 enif_alloc 分配的内存 */
    
    ERL_NIF_TERM result = enif_make_int(env, 42);
    return result;
}

/* 需要在多次 NIF 调用间保持的数据，使用资源对象 */
typedef struct {
    int fd;
    char buffer[1024];
} my_resource;

static ErlNifResourceType* my_resource_type;

/* 初始化时创建资源类型 */
static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
{
    my_resource_type = enif_open_resource_type(env, NULL, "my_resource",
        NULL, ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER, NULL);
    return 0;
}

/* 创建资源对象 */
static ERL_NIF_TERM create_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    my_resource* res = (my_resource*)enif_alloc_resource(my_resource_type, sizeof(my_resource));
    res->fd = -1;
    memset(res->buffer, 0, sizeof(res->buffer));
    
    ERL_NIF_TERM term = enif_make_resource(env, res);
    enif_release_resource(res);
    
    return term;
}

/* 声明为 dirty NIF（在 dirty scheduler 上执行） */
static ErlNifFunc nif_funcs[] = {
    {"add", 2, add, 0},                    /* 正常 scheduler */
    {"heavy_compute", 1, heavy_compute, ERL_NIF_DIRTY_JOB_CPU_BOUND},  /* CPU 密集 */
    {"io_operation", 1, io_operation, ERL_NIF_DIRTY_JOB_IO_BOUND}     /* IO 密集 */
};

%% config/vm.args
%% 必须有足够的 dirty scheduler
+SDcpu 4   %% 4 个 CPU-bound dirty scheduler
+SDio 4    %% 4 个 IO-bound dirty scheduler

/* c_src/zlib_nif.c */
#include <erl_nif.h>
#include <zlib.h>

static ERL_NIF_TERM compress_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    ErlNifBinary input;
    ErlNifBinary output;
    uLongf dest_len;
    
    if (!enif_inspect_binary(env, argv[0], &input)) {
        return enif_make_badarg(env);
    }
    
    dest_len = compressBound(input.size);
    enif_alloc_binary(dest_len, &output);
    
    if (compress(output.data, &dest_len, input.data, input.size) != Z_OK) {
        enif_release_binary(&output);
        return enif_make_atom(env, "error");
    }
    
    output.size = dest_len;
    return enif_make_binary(env, &output);
}

static ERL_NIF_TERM decompress_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    ErlNifBinary input, output;
    uLongf dest_len = 1024 * 1024; /* 1MB 初始缓冲区 */
    
    if (!enif_inspect_binary(env, argv[0], &input)) {
        return enif_make_badarg(env);
    }
    
    enif_alloc_binary(dest_len, &output);
    
    if (uncompress(output.data, &dest_len, input.data, input.size) != Z_OK) {
        enif_release_binary(&output);
        return enif_make_atom(env, "error");
    }
    
    output.size = dest_len;
    return enif_make_binary(env, &output);
}

static ErlNifFunc nif_funcs[] = {
    {"compress", 1, compress_nif, ERL_NIF_DIRTY_JOB_CPU_BOUND},
    {"decompress", 1, decompress_nif, ERL_NIF_DIRTY_JOB_CPU_BOUND}
};

ERL_NIF_INIT(zlib_nif, nif_funcs, NULL, NULL, NULL, NULL)