natives_refsapi.cpp

#include "precompiled.h"

// native rf_get_players_num(nums[], nums_size, bool:teams_only);
cell AMX_NATIVE_CALL rf_get_players_num(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_nums_arr,
        arg_nums_arr_size,
        arg_teams_only
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    // UTIL_ServerPrint("[DEBUG] rf_get_players_num(): size = %u (%u)\n", params[arg_nums_arr_size], *getAmxAddr(amx, params[arg_nums_arr_size]));
    size_t max_size = std::min(_COUNT(g_PlayersNum), (size_t)params[arg_nums_arr_size]);
    if (max_size)
        Q_memcpy(getAmxAddr(amx, params[arg_nums_arr]), &g_PlayersNum, max_size << 2);
    int total = g_PlayersNum[TEAM_TERRORIST] + g_PlayersNum[TEAM_CT];
    return params[arg_teams_only] ? total : total + g_PlayersNum[TEAM_UNASSIGNED] + g_PlayersNum[TEAM_SPECTRATOR];
}

// native rf_get_user_weapons(const id, ent[], ent_size);
cell AMX_NATIVE_CALL rf_get_user_weapons(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_index,
        arg_ent_arr,
        arg_ent_arr_size
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    CHECK_ISPLAYER(arg_index);
    auto v = &g_Tries.player_entities[params[arg_index]];
    size_t max_size = std::min(v->size(), (size_t)params[arg_ent_arr_size]);
    if (max_size)
        Q_memcpy(getAmxAddr(amx, params[arg_ent_arr]), v->data(), max_size << 2);
    return max_size;
}

// native rf_get_weaponname(const ent, name[], name_len);
cell AMX_NATIVE_CALL rf_get_weaponname(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_entity,
        arg_name,
        arg_name_len
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    CHECK_ISENTITY(arg_entity);
    edict_t *pEdict = INDEXENT(params[arg_entity]);
    if (is_valid_entity(pEdict))
    {
        g_amxxapi.SetAmxString(amx, params[arg_name], STRING(pEdict->v.classname), params[arg_name_len]);
        return TRUE;
    }
    return FALSE;
}

// native rf_get_ent_by_class(const classname[], const owner, ent[], ent_size);
cell AMX_NATIVE_CALL rf_get_ent_by_class(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_classname,
        arg_owner,
        arg_ent_arr,
        arg_ent_arr_size
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    std::string key = getAmxString(amx, params[arg_classname], g_buff);
    auto dest = getAmxAddr(amx, params[arg_ent_arr]);
    size_t max_size = params[arg_ent_arr_size];
    if (dest == nullptr || key.empty() || !max_size)
        return 0;
    int owner_index = params[arg_owner];
    if (is_valid_index(owner_index))
        return copy_entities(g_Tries.player_entities[owner_index], key, dest, max_size);
    // CHECK WEAPON
    else if (key.find(WP_CLASS_PREFIX) == 0 && key.length() > sizeof(WP_CLASS_PREFIX))
        return copy_entities(g_Tries.wp_entities, key, dest, max_size);
    // CHECK GLOBAL
    else // if (g_Tries.entities.find(key) != g_Tries.entities.end())
        return copy_entities(g_Tries.entities[key], key, dest, max_size);
}

// native rf_roundfloat(const Float:value, const precision);
cell AMX_NATIVE_CALL rf_roundfloat(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_value,
        arg_precision
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    float result = roundd(amx_ctof(params[arg_value]), params[arg_precision]);
    return amx_ftoc(result);
}

// native rf_get_user_buyzone(const id);
cell AMX_NATIVE_CALL rf_get_user_buyzone(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_index
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    CHECK_ISPLAYER(arg_index);
    return get_user_buyzone(INDEXENT(params[arg_index]));
}

// native rf_config(const bool:auto_create = true, const name[] = "", const folder[] = "");
cell AMX_NATIVE_CALL rf_config(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_auto_create,
        arg_name,
        arg_folder
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    int result = FALSE;
    std::wstring name = stows(getAmxString(amx, params[arg_name], g_buff));
    std::wstring path = stows(getAmxString(amx, params[arg_folder], g_buff));
    auto plugin = findPluginFast(amx);
    return g_cvar_mngr.config(
        plugin->getId(),
        params[arg_auto_create],
        path,
        name,
        plugin->getTitle(),
        plugin->getAuthor(),
        plugin->getName(),
        plugin->getVersion());
    /*
    auto list_cvar = g_cvar_mngr.get(plugin->getId());
    if (list_cvar == nullptr)
        return FALSE;
    // Sort list
    g_cvar_mngr.sort(list_cvar);
    std::wstring name = stows(getAmxString(amx, params[arg_name], g_buff));
    std::wstring path = stows(getAmxString(amx, params[arg_folder], g_buff));
    // UTIL_ServerPrint("[DEBUG] rf_config(): path = %s\n", wstos(path).c_str());
    if (name.empty())
        name = stows(plugin->getName());
    size_t pos = name.find(L".amxx");
    // UTIL_ServerPrint("[DEBUG] rf_config(): find pos = %d\n", pos);
    if (pos != std::wstring::npos)
        name.replace(pos, sizeof(L".amxx") - 1, L"");
    getcwd(g_buff, sizeof(g_buff));
    std::wstring root = stows(g_buff);
    path = wfmt(L"%s/%s/%s/plugins/%s", wstos(root).c_str(), g_amxxapi.GetModname(), LOCALINFO("amxx_configsdir"), path.empty() ? "" : wstos(path).c_str()).c_str();
    // UTIL_ServerPrint("[DEBUG] rf_config(): root = %s, dirs = %s\n", wstos(root).c_str(), wstos(path).c_str());
    if (path.back() != L'/')
    {
        // UTIL_ServerPrint("[DEBUG] rf_config(): create dirs = %s\n", wstos(path).c_str());
        std::filesystem::create_directories(wstos(path).c_str());
        path += L'/';
    }
    path += name + L".cfg";
    // UTIL_ServerPrint("[DEBUG] rf_config(): auto_create = %d, path = %s\n", params[arg_auto_create], wstos(path).c_str());

    bool is_exist;
    if ((is_exist = file_exists(path)) || params[arg_auto_create])
    {
        std::wfstream file;
        file.open(wstos(path).c_str(), is_exist ? std::ios::in | std::ios::out | std::ios::binary : std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc);
        // UTIL_ServerPrint("[DEBUG] rf_config(): is_exist = %d, is_open = %d\n", is_exist, file.is_open());
        if (file.is_open())
        {
            file.imbue(_LOCALE);
            load_cvars_t load_cvars;
            if (is_exist)
            {
                size_t pos;
                std::wstring line;
                std::wstring var_name;
                std::wstring var_value;
                while (std::getline(file, line, L'\n'))
                {
                    // UTIL_ServerPrint("[DEBUG] rf_config(): line = <%s>\n", wstos(line).c_str());
                    trim(line);
                    // Is comments?
                    if (line.find(L";") == 0 || line.find(L"#") == 0 || line.find(L"//") == 0 || (pos = line.find(L" ")) == std::string::npos)
                        continue;
                    // Split var
                    var_name = trim_c(line.substr(0, pos++));
                    var_value = trim_c(line.substr(pos, line.size() - pos));
                    if (rm_quote(var_value) == -1)
                        AMXX_Log("%s(): the parameter <%s> has a value <%s> with a wrong quotation mark", __func__, wstos(var_name).c_str(), wstos(var_value).c_str());
                    // UTIL_ServerPrint("[DEBUG] rf_config(): name = <%s>, value = <%s>\n", wstos(var_name).c_str(), wstos(var_value).c_str());
                    load_cvars.insert({var_name, var_value});
                }
            }
            // UTIL_ServerPrint("[DEBUG] rf_config(): cvars read %d\n", load_cvars.size());
            bool need_update = g_cvar_mngr.need_update(load_cvars, list_cvar);
            load_cvars_t::iterator load_cvars_it;
            bool need_replace;
            m_cvar_t *m_cvar;
            if (need_update)
            {
                // UTIL_ServerPrint("[DEBUG] rf_config(): the config needs to be updated\n");
                //  Need truncate?
                if (is_exist)
                {
                    // Reopen
                    file.close();
                    file.open(wstos(path).c_str(), std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc);
                }
                //"test %d", 10);
                file << L"// This file was auto-generated by REFSAPI\n";
                file << L"// Cvars for plugin \"" << plugin->getTitle() << L"\" by \"" << plugin->getAuthor() << L"\" (" << plugin->getName() << L", v" << plugin->getVersion() << L")\n";
            }
            for (auto m_cvar : *list_cvar)
            {
                // Skip cvar witout bind
                // if (m_cvar->type == CVAR_TYPE_NONE)
                //    continue;
                if (need_update)
                {
                    file << L"\n// ";
                    for (auto &ch : m_cvar->desc)
                    {
                        file << ch;
                        if (ch == L'\n')
                            file << L"// ";
                    }
                    file << L"\n// -\n";
                    file << L"// Default: \"" << m_cvar->value << L"\"\n";
                    if (m_cvar->has_min)
                        file << L"// Minimum: \"" << std::to_wstring(m_cvar->min_val) << "\"\n";
                    if (m_cvar->has_max)
                        file << L"// Maximum: \"" << std::to_wstring(m_cvar->max_val) << "\"\n";
                }
                // Is loaded cvar value?
                need_replace = (load_cvars_it = load_cvars.find(m_cvar->name)) != load_cvars.end();
                if (need_update)
                    file << m_cvar->name << " \"" << remove_chars(need_replace ? load_cvars_it->second : m_cvar->value) << "\"\n";
                if (need_replace)
                {
                    // Direct set
                    g_cvar_mngr.direct_set(m_cvar->cvar, wstos(load_cvars_it->second).c_str()); // g_cvar_mngr.set(CVAR_TYPE_STR, m_cvar, (cell *)wstos(load_cvars_it->second).c_str());
                    // Remove from list
                    load_cvars.erase(load_cvars_it);
                }
            }
            // UTIL_ServerPrint("[DEBUG] rf_config(): cvars left %d\n", load_cvars.size());
            //  Unknown cvars left?
            if (need_update && load_cvars.size())
            {
                file << L"\n// - DISABLED\n";
                for (auto &cvar : load_cvars)
                    file << L"// " << cvar.first << L" = \"" << cvar.second << "\"\n";
            }
            result = (list_cvar->size() & 0xFF) | ((load_cvars.size() & 0xFF) << 8) | ((is_exist | ((!is_exist && (bool)params[arg_auto_create]) << 1) | (need_update << 2)) << 16);
            file.close();
        }
        else
            AMXX_LogError(amx, AMX_ERR_NATIVE, "%s: error opening the file <%s> (check permissions)", __FUNCTION__, wstos(path).c_str());
    }
    */

    return result;
}

// native rf_create_cvar(const name[], const value[], flags = FCVAR_NONE, const desc[] = "", bool:has_min = false, Float:min_val = 0.0, bool:has_max = false, Float:max_val = 0.0);
cell AMX_NATIVE_CALL rf_create_cvar(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_name,
        arg_value,
        arg_flags,
        arg_desc,
        arg_has_min,
        arg_min_val,
        arg_has_max,
        arg_max_val
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    auto plugin = findPluginFast(amx);
    std::wstring name = stows(getAmxString(amx, params[arg_name], g_buff));
    std::wstring value = stows(getAmxString(amx, params[arg_value], g_buff));
    std::wstring desc = stows(getAmxString(amx, params[arg_desc], g_buff));
    // UTIL_ServerPrint("[DEBUG] rf_create_cvar(): name = <%s>\n", wstos(name).c_str());
    return (cell)((void *)g_cvar_mngr.add(plugin->getId(), name, value, params[arg_flags], desc, params[arg_has_min], amx_ctof(params[arg_min_val]), params[arg_has_max], amx_ctof(params[arg_max_val])));
}

// native rf_bind_pcvar(type, pcvar, any:var[], varlen = 0);
cell AMX_NATIVE_CALL rf_bind_pcvar(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_type,
        arg_pcvar,
        arg_var,
        arg_var_size,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    auto plugin = findPluginFast(amx);
    // Variable address is not inside global area?
    check_global_r(params[arg_var]);
    check_type_r(params[arg_type]);
    m_cvar_t *m_cvar = (m_cvar_t *)((void *)params[arg_pcvar]);
    g_cvar_mngr.bind((CVAR_TYPES_t)params[arg_type], m_cvar, getAmxAddr(amx, params[arg_var]), params[arg_var_size]);
    return TRUE;
}

// native rf_hook_cvar_change(pcvar, const callback[], bool:is_enable = true);
cell AMX_NATIVE_CALL rf_hook_cvar_change(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_pcvar,
        arg_callback,
        arg_state
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    auto plugin = findPluginFast(amx);
    std::wstring name = stows(getAmxString(amx, params[arg_callback], g_buff));
    int fwd = g_amxxapi.RegisterSPForwardByName(amx, wstos(name).c_str(), FP_CELL, FP_STRING, FP_STRING, FP_DONE);
    check_fwd_r(fwd, wstos(name).c_str());
    m_cvar_t *m_cvar = (m_cvar_t *)((void *)params[arg_pcvar]);
    // UTIL_ServerPrint("[DEBUG] rf_hook_cvar_change(): fwd = %d, name = <%s>, cvar = %d\n", fwd, wstos(name).c_str(), cvar);
    return g_cvar_mngr.create_hook(fwd, m_cvar, params[arg_state]);
}

// native rf_cvar_hook_state(phook, bool:is_enbale);
cell AMX_NATIVE_CALL rf_cvar_hook_state(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_fwd,
        arg_state,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_cvar_mngr.cvar_hook_state(params[arg_fwd], params[arg_state]);
}

// native rf_get_pcvar(type, pcvar, any:value[] = "", size = 0);
cell AMX_NATIVE_CALL rf_get_pcvar(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_type,
        arg_pcvar,
        arg_var,
        arg_var_size,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    m_cvar_t *m_cvar = (m_cvar_t *)((void *)params[arg_pcvar]);
    return g_cvar_mngr.get((CVAR_TYPES_t)params[arg_type], m_cvar, getAmxAddr(amx, params[arg_var]), params[arg_var_size]);
}

// native rf_get_cvar(type, cvar[], any:value[] = "", size = 0);
cell AMX_NATIVE_CALL rf_get_cvar(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_type,
        arg_cvar,
        arg_var,
        arg_var_size,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    std::wstring name = stows(getAmxString(amx, params[arg_cvar], g_buff));
    return g_cvar_mngr.get((CVAR_TYPES_t)params[arg_type], name, getAmxAddr(amx, params[arg_var]), params[arg_var_size]);
}

// native rf_set_pcvar(type, pcvar, any:value[]);
cell AMX_NATIVE_CALL rf_set_pcvar(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_type,
        arg_pcvar,
        arg_var,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    m_cvar_t *m_cvar = (m_cvar_t *)((void *)params[arg_pcvar]);
    if (m_cvar == nullptr)
        return FALSE;
    cell *ptr = nullptr;
    switch (params[arg_type])
    {
    case CVAR_TYPE_NUM:
    case CVAR_TYPE_FLT:
    case CVAR_TYPE_FLG:
        ptr = getAmxAddr(amx, params[arg_var]);
        // UTIL_ServerPrint("[DEBUG] rf_set_pcvar(): value_int = %d, value_float = %f\n", *ptr, *ptr);
        break;
    case CVAR_TYPE_STR:
        ptr = (cell *)getAmxString(amx, params[arg_var], g_buff);
        break;
    default:
        return FALSE;
    }
    if (ptr == nullptr)
        return FALSE;
    g_cvar_mngr.set((CVAR_TYPES_t)params[arg_type], m_cvar, ptr);
    return TRUE;
}

// native rf_set_cvar(type, cvar[], any:value[]);
cell AMX_NATIVE_CALL rf_set_cvar(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_type,
        arg_cvar,
        arg_var,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    std::wstring name = stows(getAmxString(amx, params[arg_cvar], g_buff));
    if (name.empty())
        return FALSE;
    cell *ptr = nullptr;
    switch (params[arg_type])
    {
    case CVAR_TYPE_NUM:
    case CVAR_TYPE_FLT:
    case CVAR_TYPE_FLG:
        ptr = getAmxAddr(amx, params[arg_var]);
        // UTIL_ServerPrint("[DEBUG] rf_set_pcvar(): value_int = %d, value_float = %f\n", *ptr, *ptr);
        break;
    case CVAR_TYPE_STR:
        ptr = (cell *)getAmxString(amx, params[arg_var], g_buff);
        break;
    default:
        return FALSE;
    }
    if (ptr == nullptr)
        return FALSE;
    g_cvar_mngr.set((CVAR_TYPES_t)params[arg_type], name, ptr);
    return TRUE;
}

// native rf_get_cvar_ptr(type, cvar[]);
cell AMX_NATIVE_CALL rf_get_cvar_ptr(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_cvar,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    // UTIL_ServerPrint("[DEBUG] rf_get_cvar_ptr(): start\n");
    std::wstring name = stows(getAmxString(amx, params[arg_cvar], g_buff));
    return (cell)((void *)g_cvar_mngr.get(name));
}

// native rf_recoil_enable(custom_impulse_offset);
cell AMX_NATIVE_CALL rf_recoil_enable(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_custom_impulse_offset,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    g_recoil_mngr.enable(params[arg_custom_impulse_offset]);
    return TRUE;
}

// native rf_recoil_disable();
cell AMX_NATIVE_CALL rf_recoil_disable(AMX *amx, cell *params)
{
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    g_recoil_mngr.disable();
    return TRUE;
}

#ifndef WITHOUT_SQL
// native Handle:rf_sql_tuple(callback[], db_host[], db_user[], db_pass[], db_name[], timeout = 3, db_chrs[] = "utf8");
cell AMX_NATIVE_CALL rf_sql_tuple(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_callback,
        arg_db_host,
        arg_db_user,
        arg_db_pass,
        arg_db_name,
        arg_timeout,
        arg_db_chrs,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    int fwd = -1;
    std::string callback, db_host, db_user, db_pass, db_name, db_chrs;
    callback = getAmxString(amx, params[arg_callback], g_buff);
    if (!callback.empty())
    {
        // public QueryHandler(failstate, Handle:query, error[], errnum, data[], size, Float:queuetime);
        // fwd = g_amxxapi.RegisterSPForwardByName(amx, callback.c_str(), FP_CELL, FP_CELL, FP_STRING, FP_CELL, FP_ARRAY, FP_CELL, FP_CELL, FP_DONE);
        fwd = g_amxxapi.RegisterSPForwardByName(amx, callback.c_str(), FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
        check_fwd_r(fwd, callback.c_str());
    }
    db_host = getAmxString(amx, params[arg_db_host], g_buff);
    db_user = getAmxString(amx, params[arg_db_user], g_buff);
    db_pass = getAmxString(amx, params[arg_db_pass], g_buff);
    db_name = getAmxString(amx, params[arg_db_name], g_buff);
    db_chrs = getAmxString(amx, params[arg_db_chrs], g_buff);
    return g_mysql_mngr.add_connect(amx, fwd, db_host, db_user, db_pass, db_name, db_chrs, params[arg_timeout]);
}

// native Handle:rf_sql_connect(Handle:tuple, &err_num, error[], error_size);
cell AMX_NATIVE_CALL rf_sql_connect(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_tuple,
        arg_err_num,
        arg_error,
        arg_error_size,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return (cell)g_mysql_mngr.connect(params[arg_tuple], getAmxAddr(amx, params[arg_err_num]), getAmxAddr(amx, params[arg_error]), params[arg_error_size]);
}

// native bool:rf_sql_close(Handle:conn);
cell AMX_NATIVE_CALL rf_sql_close(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_conn,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.close((MYSQL *)params[arg_conn]);
}

// native bool:rf_sql_async_query(Handle:tuple, query[], data[] = "", data_size = 0, pri = 3, timeout = 60);
cell AMX_NATIVE_CALL rf_sql_async_query(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_tuple,
        arg_query,
        arg_data,
        arg_data_size,
        arg_pri,
        arg_timeout,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    // std::string query = getAmxString(amx, params[arg_query], g_buff);
    return g_mysql_mngr.push_query(params[arg_tuple], getAmxString(amx, params[arg_query], g_buff), getAmxAddr(amx, params[arg_data]), params[arg_data_size], params[arg_pri], params[arg_timeout]);
}

// native bool:rf_sql_get_result(Handle:query, bool:is_buffered = false);
cell AMX_NATIVE_CALL rf_sql_get_result(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
        arg_buffered,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.get_result((m_query_t *)params[arg_query], params[arg_buffered]);
}

// native rf_sql_num_rows(Handle:query);
cell AMX_NATIVE_CALL rf_sql_num_rows(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.num_rows((m_query_t *)params[arg_query]);
}

// native bool:rf_sql_fetch_row(Handle:query);
cell AMX_NATIVE_CALL rf_sql_fetch_row(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.fetch_row((m_query_t *)params[arg_query]);
}

// native rf_sql_field_count(Handle:query);
cell AMX_NATIVE_CALL rf_sql_field_count(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.field_count((m_query_t *)params[arg_query]);
}

// native [RF_MAX_FIELD_SIZE] rf_sql_fetch_field(Handle:query, offset, mode = FT_AUTO, buff[] = "", buff_size = 0);
cell AMX_NATIVE_CALL rf_sql_fetch_field(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
        arg_offset,
        arg_type,
        arg_buff,
        arg_buff_size,
        arg_ret,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.fetch_field((m_query_t *)params[arg_query], params[arg_offset], params[arg_type], getAmxAddr(amx, params[arg_ret]), getAmxAddr(amx, params[arg_buff]), params[arg_buff_size]);
}

// native [RF_MAX_FIELD_SIZE] rf_sql_fetch_nm_field(Handle:query, name[], mode = FT_AUTO, buff[] = "", buff_size = 0);
cell AMX_NATIVE_CALL rf_sql_fetch_nm_field(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
        arg_name,
        arg_type,
        arg_buff,
        arg_buff_size,
        arg_ret,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    char buff[2 * RF_MAX_FIELD_NAME];
    return g_mysql_mngr.fetch_field((m_query_t *)params[arg_query], getAmxString(amx, params[arg_name], buff), params[arg_type], getAmxAddr(amx, params[arg_ret]), getAmxAddr(amx, params[arg_buff]), params[arg_buff_size]);
}

// native [RF_MAX_FIELD_NAME] rf_sql_field_name(Handle:query, offset, buff[] = 0, buff_size = 0);
cell AMX_NATIVE_CALL rf_sql_field_name(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
        arg_offset,
        arg_buff,
        arg_buff_size,
        arg_ret,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.field_name((m_query_t *)params[arg_query], params[arg_offset], getAmxAddr(amx, params[arg_ret]), getAmxAddr(amx, params[arg_buff]), params[arg_buff_size]);
}

// native rf_sql_insert_id(Handle:query);
cell AMX_NATIVE_CALL rf_sql_insert_id(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.insert_id((m_query_t *)params[arg_query]);
}

// native rf_sql_affected_rows(Handle:query);
cell AMX_NATIVE_CALL rf_sql_affected_rows(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.affected_rows((m_query_t *)params[arg_query]);
}

// native [RF_MAX_FIELD_SIZE] rf_sql_query_str(Handle:query, buff[] = "", buff_size = 0);
cell AMX_NATIVE_CALL rf_sql_query_str(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
        arg_buff,
        arg_buff_size,
        arg_ret,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.query_str((m_query_t *)params[arg_query], getAmxAddr(amx, params[arg_ret]), getAmxAddr(amx, params[arg_buff]), params[arg_buff_size]);
}

// native Handle:rf_sql_query(Handle:conn, const fmt[], any:...);
cell AMX_NATIVE_CALL rf_sql_query(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_conn,
        arg_fmt,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    int len;
    auto fmt = g_amxxapi.FormatAmxString(amx, params, arg_fmt, &len);
    return (cell)g_mysql_mngr.prepare_query((MYSQL *)params[arg_conn], fmt);
}

// native bool:rf_sql_exec(Handle:query);
cell AMX_NATIVE_CALL rf_sql_exec(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_mysql_mngr.exec_query((m_query_t *)params[arg_query]);
}

// native rf_sql_free(Handle:query);
cell AMX_NATIVE_CALL rf_sql_free(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_query,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    g_mysql_mngr.free_query((m_query_t *)params[arg_query]);
    return TRUE;
}
#endif

#ifndef WITHOUT_LOG
// native rf_log_config(const path[] = "", const name[] = "", log_level = -1, prefix_mode = 2);
cell AMX_NATIVE_CALL rf_log_config(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_path,
        arg_name,
        arg_log_level,
        arg_prefix_mode,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    std::string path, name;
    path = getAmxString(amx, params[arg_path], g_buff);
    name = getAmxString(amx, params[arg_name], g_buff);
    return g_log_mngr.add_config(amx, stows(path), stows(name), params[arg_log_level], params[arg_prefix_mode]);
}

// native rf_log(const log_level, const fmt[], any:...);
cell AMX_NATIVE_CALL rf_log(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_log_level,
        arg_fmt,
    };
    DEBUG("%s(): amx = %p, from %s, START => log_level = %d, level = %d", __func__, amx, findPluginFast(amx)->getName(), g_log_mngr.get_log_level(amx), params[arg_log_level]);
    if (!(g_log_mngr.get_log_level(amx) & params[arg_log_level]))
        return FALSE;
    int len;
    auto fmt = g_amxxapi.FormatAmxString(amx, params, arg_fmt, &len);
    g_log_mngr.write_file(amx, fmt);
    return TRUE;
}
#endif

#ifndef WITHOUT_TIMER
// native rf_set_timer(const Float:delay_s, const callback[] = "", const group_id = 0, data[] = "", data_size = 0, TIMER_FLAGS:flags = TIMER_FLAG_ONCE, repeat = 0);
cell AMX_NATIVE_CALL rf_set_timer(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_delay_sec,
        arg_callback,
        arg_timer_id,
        arg_data,
        arg_data_size,
        arg_flags,
        arg_repeat,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_timer_mngr.add_timer(amx, getAmxString(amx, params[arg_callback], g_buff),
                                  amx_ctof(params[arg_delay_sec]), params[arg_timer_id], getAmxAddr(amx, params[arg_data]), params[arg_data_size], params[arg_flags], params[arg_repeat]);
}
// native rf_remove_timer(const group_id);
cell AMX_NATIVE_CALL rf_remove_timer(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_group_id,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_timer_mngr.remove_timers(amx, params[arg_group_id]);
}
// native rf_remove_timer_id(const timer_id);
cell AMX_NATIVE_CALL rf_remove_timer_id(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_timer_id,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_timer_mngr.remove_timer_by_id(amx, params[arg_timer_id]);
}
// native rf_timer_exists(const group_id);
cell AMX_NATIVE_CALL rf_timer_exists(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_group_id,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_timer_mngr.timer_exists(amx, params[arg_group_id]);
}
// native rf_timer_id_exists(const timer_id);
cell AMX_NATIVE_CALL rf_timer_id_exists(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_timer_id,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_timer_mngr.timer_exists_by_id(amx, params[arg_timer_id]);
}
// native rf_change_timer_id(const timer_id, const Float:delay_sec, const TIMER_FLAGS:flags = TIMER_FLAG_NONE, const repeat = 0);
cell AMX_NATIVE_CALL rf_change_timer_id(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_timer_id,
        arg_delay_sec,
        arg_flags,
        arg_repeat,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    return g_timer_mngr.change_timer_by_id(amx, params[arg_timer_id], amx_ctof(params[arg_delay_sec]), params[arg_flags], params[arg_repeat]);
}
#endif

// native Float:rf_check_nick_imitation(const id, const Float:threshold = 0.9, const Float:lcs_threshold = 0.7, const Float:k_lev = 0.6, const Float:k_tan = 0.3, const Float:k_lcs = 0.1);
cell AMX_NATIVE_CALL rf_check_nick_imitation(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_id,
        arg_threshold,
        arg_lcs_threshold,
        arg_k_lev,
        arg_k_tan,
        arg_k_lcs,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    auto result = check_nick_imitation(params[arg_id], amx_ctof(params[arg_threshold]), amx_ctof(params[arg_lcs_threshold]), amx_ctof(params[arg_k_lev]), amx_ctof(params[arg_k_tan]), amx_ctof(params[arg_k_lcs]));
    return amx_ftoc(result);
}

// native rf_similarity_score(const str_1[], const str_2[], const Float:lcs_threshold = 0.7, const Float:k_lev = 0.6, const Float:k_tan = 0.3, const Float:k_lcs = 0.1);
cell AMX_NATIVE_CALL rf_similarity_score(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_str_1,
        arg_str_2,
        arg_lcs_threshold,
        arg_k_lev,
        arg_k_tan,
        arg_k_lcs,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    std::wstring str_1 = stows(getAmxString(amx, params[arg_str_1], g_buff));
    std::wstring str_2 = stows(getAmxString(amx, params[arg_str_2], g_buff));
    float result = 0.0f;
    if (!str_1.empty() && !str_2.empty())
        result = similarity_score(str_1, str_2, amx_ctof(params[arg_lcs_threshold]), amx_ctof(params[arg_k_lev]), amx_ctof(params[arg_k_tan]), amx_ctof(params[arg_k_lcs]));
    return amx_ftoc(result);
}

// native Float:rf_artificiality_score(const str[], const Float:k1 = 0.5, const Float:k2 = 0.3, const Float:k3 = 0.2);
cell AMX_NATIVE_CALL rf_artificiality_score(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_str,
        arg_k1,
        arg_k2,
        arg_k3,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    std::string s = getAmxString(amx, params[arg_str], g_buff);
    auto result = artificiality_score(s, amx_ctof(params[arg_k1]), amx_ctof(params[arg_k2]), amx_ctof(params[arg_k3]));
    return amx_ftoc(result);
}

// native rf_transfer_items(const from, const to,  const skip_items = 0, const bool:replace = true, const bool:force = true);
cell AMX_NATIVE_CALL rf_transfer_items(AMX *amx, cell *params)
{
    enum args_e
    {
        arg_count,
        arg_from,
        arg_to,
        arg_skip_items,
        arg_replace,
        arg_force,
    };
    DEBUG("%s(): from %s, START", __func__, findPluginFast(amx)->getName());
    if (!is_valid_index(params[arg_from]) || !is_valid_index(params[arg_to]))
        return FALSE;
    CHECK_ISPLAYER(arg_from);
    CHECK_ISPLAYER(arg_to);
    auto pl_from = UTIL_PlayerByIndex(params[arg_from]);
    auto pl_to = UTIL_PlayerByIndex(params[arg_to]);
    CHECK_CONNECTED(pl_from, arg_from);
    CHECK_CONNECTED(pl_to, arg_to);
    if (params[arg_replace])
    {
        DEBUG("%s(): from %s, REPLACE", __func__, findPluginFast(amx)->getName());
        if (params[arg_skip_items])
        {
            for (auto index : g_Tries.player_entities[params[arg_to]])
            {
                auto ed = INDEXENT(index);
                if (ed == nullptr || ed->free || ed->pvPrivateData == nullptr)
                    continue;
                auto owner = ENTINDEX(ed->v.owner);
                DEBUG("%s(): from %s, REPLACE OWNER = %d (%d)", __func__, findPluginFast(amx)->getName(), owner, params[arg_from]);
                if (owner != params[arg_to])
                    continue;
                auto item = (CBasePlayerItem *)GET_PRIVATE(ed);
                if (item != nullptr && item->m_iId)
                {
                    if (((1 << item->m_iId) & params[arg_skip_items]))
                        continue;
                    if (pl_to->RemovePlayerItem(item))
                        item->Kill();
                }
            }
        }
        else
            pl_to->CSPlayer()->RemoveAllItems(true);
    }
    // Check shield
    if (pl_from->m_bOwnsShield)
    {
        pl_to->CSPlayer()->GiveShield();
        pl_to->m_bShieldDrawn = pl_from->m_bShieldDrawn;
        pl_from->CSPlayer()->RemoveShield();
    }
    // Check nightvision
    if (pl_from->m_bNightVisionOn)
    {
        pl_from->m_bNightVisionOn = false;
        pl_to->m_bNightVisionOn = true;
    }
    // Check defuser
    if (pl_from->m_bHasDefuser)
    {
        pl_from->RemoveDefuser();
        if (pl_to->m_iTeam == CT)
            pl_to->GiveDefuser();
    }
    CBasePlayerItem *active_item = nullptr;
    std::vector<int> weapon_list = g_Tries.player_entities[params[arg_from]];
    for (auto index : weapon_list)
    {
        DEBUG("%s(): from %s, TRANSFER ITEM = %d, ACTIVE = %d", __func__, findPluginFast(amx)->getName(), index, pl_from->m_pActiveItem ? pl_from->m_pActiveItem->entindex() : -1);
        auto ed = INDEXENT(index);
        if (ed == nullptr || ed->pvPrivateData == nullptr)
            continue;
        auto owner = ENTINDEX(ed->v.owner);
        DEBUG("%s(): from %s, TRANSFER OWNER = %d (%d)", __func__, findPluginFast(amx)->getName(), owner, params[arg_from]);
        if (owner != params[arg_from])
            continue;
        auto item = (CBasePlayerWeapon *)GET_PRIVATE(ed);
        if (item != nullptr && item->IsWeapon())
        {
            DEBUG("%s(): from %s, TRANSFER ITEM = %p, m_iId = %d, NAME = %s", __func__, findPluginFast(amx)->getName(), item, item->m_iId, item->CSPlayerItem()->m_ItemInfo.pszName);
            if ((1 << item->m_iId) & params[arg_skip_items])
                continue;
            // Get bpammo
            auto ammo_type = item->PrimaryAmmoIndex();
            auto bp_ammo = ammo_type >= 0 ? std::max(pl_from->m_rgAmmo[ ammo_type ], 0) : 0;
            DEBUG("%s(): from %s, GET AMMO = %d, TYPE = %d", __func__, findPluginFast(amx)->getName(), bp_ammo, ammo_type);
            // Chech grenade
            if (((1 << item->m_iId) & ((1 << WEAPON_HEGRENADE) | (1 << WEAPON_FLASHBANG) | (1 << WEAPON_SMOKEGRENADE))) && pl_from->m_pActiveItem == item)
            {
                DEBUG("%s(): from %s, GRENADE RELEASE = %f, START = %f, IDLE = %f", __func__, findPluginFast(amx)->getName(), item->m_flReleaseThrow, item->m_flStartThrow, item->m_flTimeWeaponIdle);
                if (item->m_flReleaseThrow > 0 && item->m_flTimeWeaponIdle <= gpGlobals->time && !bp_ammo)
                {
                    g_pGameRules->GetNextBestWeapon(pl_from, item);
                    continue;
                }
                item->m_flStartThrow = 0;
                item->m_flReleaseThrow = -1.0f;
                item->m_iWeaponState &= ~WPNSTATE_SHIELD_DRAWN;
                pl_from->edict()->v.button &= ~IN_ATTACK;
                // FIX DEPLOY
                const float now = gpGlobals->time;
                item->m_flTimeWeaponIdle = now + 0.55f;
                item->m_flNextPrimaryAttack = now;
                item->m_flNextSecondaryAttack = now;
                // FIX
                if (pl_to->m_pActiveItem == item)
                    pl_to->m_flNextAttack = now;
            }
            // Transfer item
            if (pl_from->RemovePlayerItem(item))
            {
                DEBUG("%s(): from %s, REMOVE ITEM = %d", __func__, findPluginFast(amx)->getName(), index);
                if (!(params[arg_force] || g_pGameRules->CanHavePlayerItem(pl_to, item))) {
                    DEBUG("%s(): from %s, KILL ITEM = %d", __func__, findPluginFast(amx)->getName(), index);
                    item->Kill();
                    continue;
                }
                if (pl_to->AddPlayerItem(item))
                {
                    DEBUG("%s(): from %s, ADD & ATTACH ITEM = %d", __func__, findPluginFast(amx)->getName(), index);
                    item->AttachToPlayer(pl_to);
                    if (bp_ammo > 0)
                        pl_to->m_rgAmmo[ ammo_type ] = bp_ammo;
                    // Check bomb
                    if (((1 << item->m_iId) & (1 << WEAPON_C4)) && pl_from->m_iTeam == pl_to->m_iTeam)
                    {
                        pl_to->m_bHasC4 = true;
                        pl_to->CSPlayer()->SetBombIcon();
                        g_pGameRules->m_bBombDropped = false;
                    }
                    DEBUG("%s(): from %s, SET AMMO = %d, TYPE = %d", __func__, findPluginFast(amx)->getName(), bp_ammo, ammo_type);
                }
            }
            if (pl_from->m_pActiveItem == item)
                active_item = item;
        }
    }
    DEBUG("%s(): from %s, PLAYER ACTIVE ITEM = %d (%d)", __func__, findPluginFast(amx)->getName(), pl_to->m_pActiveItem, active_item);
    if (active_item && pl_to->m_pActiveItem != active_item)
        pl_to->CSPlayer()->SwitchWeapon(active_item);
    DEBUG("%s(): from %s, END", __func__, findPluginFast(amx)->getName());
    return TRUE;
}

AMX_NATIVE_INFO Misc_Natives[] = {
    {"rf_get_players_num", rf_get_players_num},
    {"rf_get_user_weapons", rf_get_user_weapons},
    {"rf_get_weaponname", rf_get_weaponname},
    {"rf_get_ent_by_class", rf_get_ent_by_class},
    {"rf_roundfloat", rf_roundfloat},
    {"rf_get_user_buyzone", rf_get_user_buyzone},
    {"rf_config", rf_config},
    {"rf_create_cvar", rf_create_cvar},
    {"rf_bind_pcvar", rf_bind_pcvar},
    {"rf_hook_cvar_change", rf_hook_cvar_change},
    {"rf_cvar_hook_state", rf_cvar_hook_state},
    {"rf_get_pcvar", rf_get_pcvar},
    {"rf_get_cvar", rf_get_cvar},
    {"rf_set_pcvar", rf_set_pcvar},
    {"rf_set_cvar", rf_set_cvar},
    {"rf_get_cvar_ptr", rf_get_cvar_ptr},
    {"rf_recoil_enable", rf_recoil_enable},
    {"rf_recoil_disable", rf_recoil_disable},
#ifndef WITHOUT_SQL
    {"rf_sql_tuple", rf_sql_tuple},
    {"rf_sql_connect", rf_sql_connect},
    {"rf_sql_close", rf_sql_close},
    {"rf_sql_get_result", rf_sql_get_result},
    {"rf_sql_async_query", rf_sql_async_query},
    {"rf_sql_num_rows", rf_sql_num_rows},
    {"rf_sql_fetch_row", rf_sql_fetch_row},
    {"rf_sql_field_count", rf_sql_field_count},
    {"rf_sql_fetch_field", rf_sql_fetch_field},
    {"rf_sql_fetch_nm_field", rf_sql_fetch_nm_field},
    {"rf_sql_field_name", rf_sql_field_name},
    {"rf_sql_insert_id", rf_sql_insert_id},
    {"rf_sql_affected_rows", rf_sql_affected_rows},
    {"rf_sql_query", rf_sql_query},
    {"rf_sql_query_str", rf_sql_query_str},
    {"rf_sql_exec", rf_sql_exec},
    {"rf_sql_free", rf_sql_free},
#endif
#ifndef WITHOUT_LOG
    {"rf_log", rf_log},
    {"rf_log_config", rf_log_config},
#endif
#ifndef WITHOUT_TIMER
    {"rf_set_timer", rf_set_timer},
    {"rf_remove_timer", rf_remove_timer},
    {"rf_remove_timer_id", rf_remove_timer_id},
    {"rf_timer_exists", rf_timer_exists},
    {"rf_timer_id_exists", rf_timer_id_exists},
    {"rf_change_timer_id", rf_change_timer_id},
#endif
    {"rf_check_nick_imitation", rf_check_nick_imitation},
    {"rf_similarity_score", rf_similarity_score},
    {"rf_artificiality_score", rf_artificiality_score},
    {"rf_transfer_items", rf_transfer_items},
    {nullptr, nullptr}};

void RegisterNatives_Misc()
{
    g_amxxapi.AddNatives(Misc_Natives);
    // g_amxxapi.OverrideNatives()
}