#pragma once
#include "squirrel.h"
#include "sqstdaux.h"
#include "sqstdblob.h"
#include "sqstdio.h"
#include "sqstdmath.h"
#include "sqstdstring.h"
#include "sqstdsystem.h"
#include "CConnectPool.h"
#include "croncpp.h"
#include "l_socket.h"
#include <openssl/md5.h>
#include <opencc/opencc.h>
#include <iostream>
#include <functional>
#include <list>
#include <ffi.h>
#include <iconv.h>
#include "nlohmann/json.hpp"

#define CONTAINS_STRING(str, substr) (str == substr)

template <typename R, typename A, typename... ARG>
R CallGameT(A call_addr, const ARG... arguments)
{
    if (!call_addr)
    {
        return R();
    }
    const auto control = reinterpret_cast<R (*)(ARG...)>(call_addr);
    try
    {
        return control(arguments...);
    }
    catch (...)
    {
    }
    return R();
}
template <typename R>
R CallGameRT(void *call_addr, va_list arguments, std::vector<std::string> Type)
{
    if (!call_addr)
    {
        return R();
    }
    try
    {
        // 使用汇编语言将va_list中的值一个一个push进去
        R result;
        va_list args;
        va_copy(args, arguments);

        asm volatile(
            "pushl %0"
            :
            : "g"(va_arg(args, int))
            : "memory");

        va_end(args);

        asm volatile(
            "call *%1"
            : "=a"(result)
            : "r"(call_addr)
            : "memory");

        return result;
    }
    catch (...)
    {
    }
    return R();
}

static char szGamePath[256];
static int getargs(char ***argv)
{
    size_t buflen = 1024, readlen = 0, maxlen = buflen;
    int fd = open("/proc/self/cmdline", O_RDONLY);
    if (fd == -1)
        return 0;
    char *buf = (char *)malloc(buflen);
    while (1)
    {
        ssize_t n = read(fd, buf + readlen, buflen - readlen);
        if (n == -1)
        {
            free(buf);
            close(fd);
            return 0;
        }
        readlen += n;
        if (!n || readlen < buflen)
            break;
        maxlen += buflen;
        buf = (char *)realloc(buf, maxlen);
    }
    close(fd);
    int argc = 0;
    char *cp = buf;
    do
    {
        while (*cp != '\0')
            cp++;
        argc++;
    } while (++cp < buf + readlen);
    *argv = (char **)malloc(argc * sizeof(char *));
    argc = 0;
    cp = buf;
    do
    {
        (*argv)[argc] = (char *)malloc(strlen(cp) + 1);
        strcpy((*argv)[argc], cp);
        argc++;
        while (*cp != '\0')
            cp++;
    } while (++cp < buf + readlen);
    free(buf);
    return argc;
}
static int getConfigPath(char *pPath, size_t nSize)
{
    if (readlink("/proc/self/exe", pPath, nSize) <= 0)
        return -1;
    char **argv = NULL;
    int argc = getargs(&argv);
    if (!argv || argc < 2)
    {
        if (argv)
        {
            for (int i = 0; i < argc; i++)
            {
                if (argv[i])
                    free(argv[i]);
            }
            free(argv);
        }
        return -1;
    }
    *strrchr(pPath, '/') = '\0';
    sprintf(pPath, "%s/cfg/%s.cfg", pPath, argv[1]);
    for (int i = 0; i < argc; i++)
    {
        if (argv[i])
            free(argv[i]);
    }
    free(argv);
    return 0;
}
static SQInteger Game_GetConfig(HSQUIRRELVM v)
{
    sq_pushstring(v, szGamePath, -1);
    return 1;
}

// 加密函数
static std::string Buf_encryptDecrypt(const std::string &input, const std::string &key)
{
    std::string output = input;
    for (size_t i = 0; i < input.size(); i++)
    {
        output[i] = input[i] ^ key[i % key.size()]; // 使用异或运算进行加密
    }
    return output;
}

// 判断是否处理加密
static std::string Buf_IsencryptDecrypt(const std::string &input, const std::string &FileName)
{
    if (FileName.find(".nut") != std::string::npos)
        return input;
    else
        return Buf_encryptDecrypt(input, "Lenheart-asdhfjiaednkljanslk");
}

// 执行脚本
static SQInteger RunScript(HSQUIRRELVM v)
{
    const SQChar *Path;
    sq_getstring(v, 2, &Path);
    std::string RealPath(Path);
    RealPath = "/dp_s/" + RealPath;

    std::fstream F;
    F.open(RealPath, std::ios::in);
    std::stringstream ContentStringStream;
    ContentStringStream << F.rdbuf();
    std::string ContentString(ContentStringStream.str());
    F.close();

    std::string RealContentString = Buf_IsencryptDecrypt(ContentString, RealPath);

    if (SQ_SUCCEEDED(sq_compilebuffer(v, (SQChar *)(RealContentString.c_str()), RealContentString.length(), (SQChar *)(RealPath.c_str()), true)))
    {
        sq_pushroottable(v);
        sq_call(v, 1, 1, 1);
        sq_pop(v, 1);
    }

    return 0;
}
// 指针转int
static SQInteger L_Ptr2Int(HSQUIRRELVM v)
{
    SQUserPointer P;
    sq_getuserpointer(v, 2, &P);
    sq_pushinteger(v, (int)P);
    return 1;
}
// int转指针
static SQInteger L_Int2Ptr(HSQUIRRELVM v)
{
    SQInteger Address;
    sq_getinteger(v, 2, &Address);
    sq_pushuserpointer(v, (void *)Address);
    return 1;
}

// 写内存
static SQInteger L_WriteAddress(HSQUIRRELVM v)
{
    // 内存地址 int型
    SQUserPointer Address;
    // 内存偏移 int型
    SQInteger Offset;
    // 获取参数个数
    int ParameterNum = sq_gettop(v);
    // 2个参数时
    if (ParameterNum == 4)
    {
        // 获取地址
        sq_getuserpointer(v, 2, &Address);
        // 获取偏移
        sq_getinteger(v, 3, &Offset);
        // 获取修改的值
        SQInteger WriteValue;
        sq_getinteger(v, 4, &WriteValue);

        *(int *)((void *)Address + Offset) = WriteValue;
        sq_pushbool(v, true);
        return 1;
    }
    if (ParameterNum == 5)
    {
    }
    else
    {
        sq_pushbool(v, false);
        return 1;
    }
    return 0;
}
// 读内存
static SQInteger L_ReadAddress(HSQUIRRELVM v)
{
    // 内存地址 int型
    SQUserPointer Address;
    // 获取地址
    sq_getuserpointer(v, 2, &Address);
    sq_pushinteger(v, *(int *)Address);
    return 1;
}
// 读内存
static SQInteger L_ReadPoint(HSQUIRRELVM v)
{
    // 内存地址 int型
    SQUserPointer Address;
    // 获取地址
    sq_getuserpointer(v, 2, &Address);
    int *ptr = reinterpret_cast<int *>(Address);
    int value = *ptr;
    sq_pushuserpointer(v, (void *)(value));
    return 1;
}
// 读内存字符串
static SQInteger L_ReadAddressString(HSQUIRRELVM v)
{
    // 内存地址 int型
    SQUserPointer Address;
    // 获取地址
    sq_getuserpointer(v, 2, &Address);
    if (sq_gettop(v) == 3)
    {
        SQInteger Length;
        sq_getinteger(v, 3, &Length);
        sq_pushstring(v, (char *)(Address), Length);
    }
    else
    {
        sq_pushstring(v, (char *)(Address), -1);
    }
    return 1;
}

// 读取字节数组
static SQInteger L_ReadByteArr(HSQUIRRELVM v)
{
    SQUserPointer P;
    sq_getuserpointer(v, 2, &P);
    SQInteger Count;
    sq_getinteger(v, 3, &Count);

    char *Address = (char *)P;
    sq_newarray(v, 0);
    for (size_t i = 0; i < Count; i++)
    {
        sq_pushinteger(v, (int)(Address[i]));
        sq_arrayappend(v, -2);
    }
    return 1;
}
// 指针转Blob
static SQInteger L_Point2Blob(HSQUIRRELVM v)
{
    SQUserPointer P;
    sq_getuserpointer(v, 2, &P);
    SQInteger Count;
    sq_getinteger(v, 3, &Count);

    char *Address = (char *)P;
    SQUserPointer Blobobj = sqstd_createblob(v, Count);
    memcpy(Blobobj, P, Count);

    return 1;
}
// 写字节数组
static SQInteger L_WriteByteArr(HSQUIRRELVM v)
{
    SQUserPointer P;
    sq_getuserpointer(v, 2, &P);
    char *Address = (char *)P;

    size_t Idx = 0;
    sq_pushnull(v); // null iterator
    while (SQ_SUCCEEDED(sq_next(v, 3)))
    {
        SQInteger Buf;
        sq_getinteger(v, -1, &Buf);
        CMem::WriteUChar((Address + Idx), Buf);
        // 这里-1是值，-2是键
        sq_pop(v, 2); // 在下一次迭代之前弹出键和值
        Idx++;
    }
    sq_pop(v, 1);

    return 0;
}
// 写Blob到指定地址
static SQInteger L_WriteBlobToAddress(HSQUIRRELVM v)
{
    SQUserPointer P;
    sq_getuserpointer(v, 2, &P);
    SQUserPointer Blobobj;
    // sq_getuserpointer(v, 3, &P);
    sqstd_getblob(v, 3, &Blobobj);
    int Size = sqstd_getblobsize(v, 3);

    memcpy(P, Blobobj, Size);
    return 0;
}
// 通过ID从Pvf中查询名称
static SQInteger L_GetNameByIdFromPvf(HSQUIRRELVM v)
{
    SQInteger Idx;
    sq_getinteger(v, 2, &Idx);

    void *Ret = CallGameT<void *>(0x835FA32, CallGameT<void *>(0x80CC19B), (unsigned int)Idx);
    if (Ret)
    {
        const char *Name = CallGameT<const char *>(0x811ed82, Ret);
        sq_pushstring(v, Name, -1);
    }
    else
    {
        sq_pushnull(v);
    }
    return 1;
}
// 通过ID从Pvf中查询Data
static SQInteger L_GetDataByIdFromPvf(HSQUIRRELVM v)
{
    SQInteger Idx;
    sq_getinteger(v, 2, &Idx);

    void *Ret = CallGameT<void *>(0x835FA32, CallGameT<void *>(0x80CC19B), (unsigned int)Idx);
    if (Ret)
    {
        sq_pushuserpointer(v, Ret);
    }
    else
    {
        sq_pushnull(v);
    }
    return 1;
}

// 创建数据库连接池
static SQInteger L_CreatCConnectPool(HSQUIRRELVM v)
{
    SQInteger MinConnectCount, MaxConnectCount, Port;
    const SQChar *Host;
    const SQChar *Account;
    const SQChar *Passwd;

    sq_getinteger(v, 2, &MinConnectCount);
    sq_getinteger(v, 3, &MaxConnectCount);
    sq_getstring(v, 4, &Host);
    sq_getinteger(v, 5, &Port);
    sq_getstring(v, 6, &Account);
    sq_getstring(v, 7, &Passwd);

    // 初始化数据库
    CConnectPool::CreatePool(MinConnectCount, MaxConnectCount, Host, Port, Account, Passwd);
    return 0;
}
// 阻塞线程的数据库操作 无返回值
static SQInteger L_MysqlExecNoRet(HSQUIRRELVM v)
{
    const SQChar *Sql;
    sq_getstring(v, 2, &Sql);

    MYSQL *MysqlObject = CConnectPool::GetConnect();
    mysql_query(MysqlObject, Sql);
    CConnectPool::PutConnect(MysqlObject);
    return 0;
}

struct CreateSocketInfo
{
    std::string Ip;
    std::string Port;
};

static void *SocketThread_function(void *arg)
{
    CreateSocketInfo *Info = (CreateSocketInfo *)arg;
    l_socket::getInstance().Init(Info->Ip, Info->Port);
    delete Info;
    // 在这里编写线程的具体操作

    pthread_exit(NULL);
}

// 创建Socket连接
static SQInteger L_CreatSocketConnect(HSQUIRRELVM v)
{
    const SQChar *Host;
    const SQChar *Port;
    sq_getstring(v, 2, &Host);
    sq_getstring(v, 3, &Port);
    CreateSocketInfo *Info = new CreateSocketInfo();
    Info->Ip = Host;
    Info->Port = Port;

    pthread_t SocketThread;
    // 创建线程1
    if (pthread_create(&SocketThread, NULL, SocketThread_function, Info) != 0)
    {
        std::cerr << "Error creating thread 1" << std::endl;
    }
    return 0;
}

static SQInteger register_Game_func(HSQUIRRELVM v, SQFUNCTION f, const char *fname)
{
    sq_pushroottable(v);
    sq_pushstring(v, fname, -1);
    sq_newclosure(v, f, 0); // create a new function
    sq_newslot(v, -3, SQFalse);
    sq_pop(v, 1); // pops the root table
}

static void Aprintfunc(const SQChar *s, ...)
{
    fflush(stdout);
    va_list vl;
    va_start(vl, s);
    scvprintf(stdout, s, vl);
    va_end(vl);
    printf("\n");
    fflush(stdout);
}

// CallFunc
static SQInteger L_CallFunc(HSQUIRRELVM v)
{
    // 得到参数个数
    SQInteger Count = sq_gettop(v);
    // 得到函数地址
    SQUserPointer FuncAddress;
    sq_getuserpointer(v, 2, &FuncAddress);
    // 得到返回值类型
    const SQChar *RetType;
    sq_getstring(v, 3, &RetType);

    std::vector<std::string> ParameterType;
    // 遍历参数类型数组
    sq_pushnull(v); // null iterator
    while (SQ_SUCCEEDED(sq_next(v, 4)))
    {
        const SQChar *path;
        sq_getstring(v, -1, &path);
        ParameterType.push_back(path);
        sq_pop(v, 2);
    }
    sq_pop(v, 1);

    // 头部信息个数
    int HeaderCount = 4;

    // 计算valist内存
    int AdrSize = 0;
    for (std::string Type : ParameterType)
    {
        if (CONTAINS_STRING(Type, "int"))
            AdrSize += sizeof(int);
        else if (CONTAINS_STRING(Type, "bool"))
            AdrSize += sizeof(bool);
        else if (CONTAINS_STRING(Type, "string"))
            AdrSize += sizeof(char *);
        else if (CONTAINS_STRING(Type, "float"))
            AdrSize += sizeof(float);
        else if (CONTAINS_STRING(Type, "pointer"))
            AdrSize += sizeof(void *);
        else if (CONTAINS_STRING(Type, "short"))
            AdrSize += sizeof(short);
        else if (CONTAINS_STRING(Type, "char"))
            AdrSize += sizeof(char);
    }

    char *m = (char *)malloc(AdrSize);
    void *bm = m;
    // 定义函数签名
    ffi_cif cif;
    ffi_type **args = (ffi_type **)malloc(ParameterType.size() * sizeof(ffi_type *)); // 动态分配参数类型数组
    void **values = (void **)malloc(ParameterType.size() * sizeof(void *));           // 动态分配参数值数组
    ffi_arg result;

    int CFlag = 0;
    for (int i = (HeaderCount + 1); i < (Count + 1); i++)
    {
        if (CONTAINS_STRING(ParameterType[0], "int"))
        {
            sq_getinteger(v, i, (SQInteger *)m);
            args[CFlag] = &ffi_type_sint;
            values[CFlag] = m;
            m += sizeof(int);
        }
        else if (CONTAINS_STRING(ParameterType[0], "float"))
        {
            sq_getfloat(v, i, (SQFloat *)m);
            args[CFlag] = &ffi_type_float;
            values[CFlag] = m;
            m += sizeof(float);
        }
        else if (CONTAINS_STRING(ParameterType[0], "bool"))
        {
            sq_getbool(v, i, (SQBool *)m);
            args[CFlag] = &ffi_type_sint8;
            values[CFlag] = m;
            m += sizeof(bool);
        }
        else if (CONTAINS_STRING(ParameterType[0], "string"))
        {

            sq_getstring(v, i, (const SQChar **)m);
            args[CFlag] = &ffi_type_pointer;
            values[CFlag] = m;
            m += sizeof(void *);
        }
        else if (CONTAINS_STRING(ParameterType[0], "pointer"))
        {
            sq_getuserpointer(v, i, (SQUserPointer *)m);
            args[CFlag] = &ffi_type_pointer;
            values[CFlag] = m;
            m += sizeof(void *);
        }
        else if (CONTAINS_STRING(ParameterType[0], "short"))
        {
            sq_getinteger(v, i, (SQInteger *)m);
            args[CFlag] = &ffi_type_sint16;
            values[CFlag] = m;
            m += sizeof(short);
        }
        else if (CONTAINS_STRING(ParameterType[0], "char"))
        {
            sq_getinteger(v, i, (SQInteger *)m);
            args[CFlag] = &ffi_type_schar;
            values[CFlag] = m;
            m += sizeof(char);
        }

        ParameterType.erase(ParameterType.begin());
        CFlag++;
    }

    ffi_type *RetTypeFlag = &ffi_type_void;

    std::string RetTypeString = RetType;
    if (CONTAINS_STRING(RetTypeString, "int"))
        RetTypeFlag = &ffi_type_sint;
    else if (CONTAINS_STRING(RetTypeString, "float"))
        RetTypeFlag = &ffi_type_float;
    else if (CONTAINS_STRING(RetTypeString, "bool"))
        RetTypeFlag = &ffi_type_sint8;
    else if (CONTAINS_STRING(RetTypeString, "string"))
        RetTypeFlag = &ffi_type_pointer;
    else if (CONTAINS_STRING(RetTypeString, "pointer"))
        RetTypeFlag = &ffi_type_pointer;
    else if (CONTAINS_STRING(RetTypeString, "short"))
        RetTypeFlag = &ffi_type_sint16;
    else if (CONTAINS_STRING(RetTypeString, "char"))
        RetTypeFlag = &ffi_type_schar;

    if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, CFlag, RetTypeFlag, args) == FFI_OK)
    {
        // 动态调用函数
        ffi_call(&cif, FFI_FN(FuncAddress), &result, values);
    }

    free(args);
    free(values);
    free(bm);

    if (CONTAINS_STRING(RetTypeString, "int"))
        sq_pushinteger(v, (int)result);
    else if (CONTAINS_STRING(RetTypeString, "float"))
        sq_pushfloat(v, (float)result);
    else if (CONTAINS_STRING(RetTypeString, "bool"))
        sq_pushbool(v, (bool)result);
    else if (CONTAINS_STRING(RetTypeString, "string"))
        sq_pushstring(v, (char *)result, -1);
    else if (CONTAINS_STRING(RetTypeString, "pointer"))
        sq_pushuserpointer(v, (void *)result);
    else if (CONTAINS_STRING(RetTypeString, "short"))
        sq_pushinteger(v, (int)result);
    else if (CONTAINS_STRING(RetTypeString, "char"))
        sq_pushinteger(v, (int)result);
    else
        return 0;
    return 1;
}

static SQInteger L_S_Ptr(HSQUIRRELVM v)
{
    const SQChar *str;
    sq_getstring(v, 2, &str);
    unsigned long long addr = std::stoull(str, 0, 16);
    void *ptr = reinterpret_cast<void *>(addr);
    sq_pushuserpointer(v, ptr);
    return 1;
}
static SQInteger L_Str_Ptr(HSQUIRRELVM v)
{
    const SQChar *str;
    sq_getstring(v, 2, &str);
    sq_pushuserpointer(v, (void *)str);
    return 1;
}
static SQInteger L_Ptr_Operation_A2S(HSQUIRRELVM v)
{
    // 内存地址 int型
    SQUserPointer Address;
    // 获取地址
    sq_getuserpointer(v, 2, &Address);
    SQInteger Offset;
    sq_getinteger(v, 3, &Offset);
    sq_pushuserpointer(v, (void *)(Address + Offset));
    return 1;
}

static SQInteger New_Point(HSQUIRRELVM v)
{
    SQInteger Len;
    sq_getinteger(v, 2, &Len);
    void *P = malloc(Len);
    sq_pushuserpointer(v, P);
    return 1;
}
static SQInteger Delete_Point(HSQUIRRELVM v)
{
    SQUserPointer P;
    sq_getuserpointer(v, 2, &P);
    free(P);
    return 0;
}

static SQInteger Sq_getExportByName(HSQUIRRELVM v)
{
    const SQChar *MoudleName;
    const SQChar *FuncName;

    sq_getstring(v, 2, &MoudleName);
    sq_getstring(v, 3, &FuncName);

    void *handle = dlopen(nullptr, RTLD_LAZY);
    if (!handle)
        return 0;

    void *targetFunctionPtr = dlsym(handle, FuncName);
    if (!targetFunctionPtr)
        return 0;

    sq_pushuserpointer(v, targetFunctionPtr);
    return 1;
}

static SQInteger OutPutTable(HSQUIRRELVM v)
{
    const SQChar *Str;
    sq_getstring(v, 2, &Str);

    nlohmann::json ex1 = nlohmann::json::parse(Str);

    std::cout << std::setw(4) << ex1 << std::endl;
    return 0;
}

const std::string base64_chars =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz"
    "0123456789+/";

std::string base64_encode(const std::string &in)
{
    std::string out;
    int val = 0;
    int valb = -6;
    for (unsigned char c : in)
    {
        val = (val << 8) + c;
        valb += 8;
        while (valb >= 0)
        {
            out.push_back(base64_chars[(val >> valb) & 0x3F]);
            valb -= 6;
        }
    }
    if (valb > -6)
    {
        out.push_back(base64_chars[((val << 8) >> (valb + 8)) & 0x3F]);
    }
    while (out.size() % 4)
    {
        out.push_back('=');
    }
    return out;
}
std::string calculateMD5(const std::string &filePath)
{
    std::ifstream file(filePath, std::ios::binary | std::ios::ate);
    if (!file)
    {
        return "";
    }
    std::streampos size = file.tellg();
    file.seekg(0, std::ios::beg);

    unsigned char buffer[16];
    MD5_CTX md5Context;
    MD5_Init(&md5Context);

    while (file.read(reinterpret_cast<char *>(buffer), sizeof(buffer)))
    {
        MD5_Update(&md5Context, buffer, file.gcount());
    }

    MD5_Final(buffer, &md5Context);

    file.close();
    return base64_encode((char *)buffer);
}

void processDirectory(const std::string &directoryPath, std::unordered_map<std::string, std::string> &fileMD5Map)
{
    DIR *dir;
    struct dirent *entry;

    if ((dir = opendir(directoryPath.c_str())) != nullptr)
    {
        while ((entry = readdir(dir)) != nullptr)
        {
            if (entry->d_type == DT_REG)
            {
                std::string filePath = directoryPath + "/" + entry->d_name;
                std::string currentMD5 = calculateMD5(filePath);

                if (fileMD5Map.find(filePath) != fileMD5Map.end())
                {
                    if (fileMD5Map[filePath] != currentMD5)
                    {
                        fileMD5Map[filePath] = currentMD5;
                        std::lock_guard<std::recursive_mutex> lock(SqMtx);
                        // 执行虚拟机Main函数
                        SQInteger top = sq_gettop(v); // saves the stack size before the call
                        sq_pushroottable(v);          // pushes the global table
                        sq_pushstring(v, _SC("_Reload_List_Write_"), -1);
                        if (SQ_SUCCEEDED(sq_get(v, -2)))
                        {                        // gets the field 'foo' from the global table
                            sq_pushroottable(v); // push the 'this' (in this case is the global table)
                            sq_pushstring(v, filePath.c_str(), -1);
                            sq_call(v, 2, SQFalse, SQTrue); // calls the function
                        }
                        sq_settop(v, top); // restores the original stack size
                    }
                }
                else
                {
                    fileMD5Map[filePath] = currentMD5;
                }
            }
            else if (entry->d_type == DT_DIR && std::string(entry->d_name) != "." && std::string(entry->d_name) != "..")
            {
                processDirectory(directoryPath + "/" + entry->d_name, fileMD5Map);
            }
        }
        closedir(dir);
    }
    else
    {
        std::cerr << "无法打开目录：" << directoryPath << std::endl;
    }
}
struct AutoReloadSt
{
    std::string Path;
};
static void *continuousMonitoring(void *arg)
{
    AutoReloadSt *Info = (AutoReloadSt *)arg;
    std::unordered_map<std::string, std::string> fileMD5Map;
    while (true)
    {
        processDirectory(Info->Path, fileMD5Map);
        usleep(1000); // 每隔 1 秒检查一次
    }
}
static SQInteger AutoReload(HSQUIRRELVM v)
{
    const SQChar *Str;
    sq_getstring(v, 2, &Str);

    AutoReloadSt *Info = new AutoReloadSt();
    Info->Path = std::string(Str);
    // 开启DP-S 自动热重载
    // std::string targetDirectory = (char *)Str;
    // std::thread monitorThread(continuousMonitoring, targetDirectory);
    // monitorThread.join();

    pthread_t MonitoringThread;
    // 创建线程1
    if (pthread_create(&MonitoringThread, NULL, continuousMonitoring, Info) != 0)
    {
        std::cerr << "Error creating thread 1" << std::endl;
    }

    return 0;
}

static SQInteger L_Sq_Cron_Next(HSQUIRRELVM v)
{
    const SQChar *Str;
    sq_getstring(v, 2, &Str);
    SQInteger Date;
    sq_getinteger(v, 3, &Date);

    auto cron = cron::make_cron(Str);
    std::time_t next = cron::cron_next(cron, Date);
    sq_pushinteger(v, next);

    return 1;
}

static SQInteger _stream_myreadstring(HSQUIRRELVM v)
{
    SQStream *self = NULL;
    if (SQ_FAILED(sq_getinstanceup(v, 1, (SQUserPointer *)&self, (SQUserPointer)((SQUnsignedInteger)SQSTD_STREAM_TYPE_TAG), SQFalse)))
        return sq_throwerror(v, _SC("invalid type tag"));
    if (!self || !self->IsValid())
        return sq_throwerror(v, _SC("the stream is invalid"));

    SQInteger Count;
    sq_getinteger(v, 2, &Count);
    char *Str = new char[Count + 1];
    self->Read(Str, Count);
    std::string Sstr(Str, Count);
    delete[] Str;
    sq_pushstring(v, Sstr.c_str(), -1);
    return 1;
}

static SQInteger _CrcDecode(HSQUIRRELVM v)
{
    SQInteger Buffer[4];

    sq_pushnull(v); // null iterator
    int Idx = 0;
    while (SQ_SUCCEEDED(sq_next(v, -2)))
    {
        sq_getinteger(v, -1, &Buffer[Idx]);
        Idx++;
        sq_pop(v, 2);
    }
    sq_pop(v, 1);

    SQInteger crc32;
    sq_getinteger(v, 3, &crc32);

    int64 num = 2175242257;
    int64 anInt = ((Buffer[0]) << 0) | ((Buffer[1]) << 8) | ((Buffer[2]) << 16) | ((Buffer[3]) << 24);
    int64 val = (anInt ^ num ^ crc32);
    int64 jiemi = (val >> 6) | ((val << (32 - 6)) & 0xFFFFFFFF);

    sq_newarray(v, 0);
    for (size_t i = 0; i < 4; i++)
    {
        sq_pushinteger(v, (jiemi >> (i * 8)) & 0xFF);
        sq_arrayappend(v, -2);
    }
    return 1;
}

static SQInteger L_Conversion(HSQUIRRELVM v)
{
    const SQChar *Str;
    sq_getstring(v, 2, &Str);
    SQInteger Type;
    sq_getinteger(v, 3, &Type);

    std::string traditionalStr = std::string(Str);
    // sq_pushnull(v);
    opencc_t ot;
    if (Type == 0)
        ot = opencc_open(OPENCC_DEFAULT_CONFIG_TRAD_TO_SIMP);
    else if (Type == 1)
        ot = opencc_open(OPENCC_DEFAULT_CONFIG_SIMP_TO_TRAD);

    char *NewStr = opencc_convert_utf8(ot, traditionalStr.c_str(), traditionalStr.length());
    std::string RetStr(NewStr);
    sq_pushstring(v, RetStr.c_str(), -1);
    opencc_convert_utf8_free(NewStr);
    opencc_close(ot);

    return 1;
}

static SQInteger L_GetTimestampString(HSQUIRRELVM v)
{
    auto now = std::chrono::system_clock::now();
    auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
    auto value = now_ms.time_since_epoch();
    long long milliseconds = value.count();

    std::ostringstream oss;
    oss << milliseconds;

    sq_pushstring(v, oss.str().c_str(), -1);
    return 1;
}

#define NSUBHOOK_INIT(func, addr)   \
    fn##func func = (fn##func)addr; \
    FuncHook h##func
#define NSUBHOOK_SETUP(func) h##func.Hook((void **)&func, (void *)_##func)

typedef int (*fnInven_Item_reset)(void *a1);

typedef void *(*fnInven_Item_setcopy)(void *a1, void *a2);
NSUBHOOK_INIT(Inven_Item_reset, 0x080CB7D8);
int _Inven_Item_reset(void *item)
{
    int ret = Inven_Item_reset(item);
    memset(item, 0, 61);
    return ret;
}
NSUBHOOK_INIT(Inven_Item_setcopy, 0x0814A62E);
void *_Inven_Item_setcopy(void *item, void *item2)
{
    Inven_Item_setcopy(item, item2);
    memcpy(item, item2, 61);
    return item2;
}
static SQInteger L_HookEquimentUseJewel(HSQUIRRELVM v)
{
    NSUBHOOK_SETUP(Inven_Item_setcopy);
    NSUBHOOK_SETUP(Inven_Item_reset);
    return 0;
}

static SQInteger LongLongOperation(HSQUIRRELVM v)
{
    const SQChar *valuebuf1;
    sq_getstring(v, 2, &valuebuf1);
    long long value1 = std::atoll(valuebuf1);

    const SQChar *valuebuf2;
    sq_getstring(v, 3, &valuebuf2);
    long long value2 = std::atoll(valuebuf2);

    const SQChar *TypeBuf;
    sq_getstring(v, 4, &TypeBuf);
    std::string Type(TypeBuf);

    std::string RetString = "";
    if (Type == "+")
    {
        RetString = std::to_string(value1 + value2);
    }
    else if (Type == "-")
    {
        RetString = std::to_string(value1 - value2);
    }
    else if (Type == "*")
    {
        RetString = std::to_string((static_cast<double>(value1) * static_cast<double>(value2)));
    }
    else if (Type == "/")
    {
        RetString = std::to_string((static_cast<double>(value1) / static_cast<double>(value2)));
    }
    else if (Type == "%")
    {
        RetString = std::to_string(value1 % value2);
    }
    else if (Type == "format")
    {
        if (value1 < 1000)
        {
            RetString = std::to_string(value1);
        }
        else if (value1 < 1000000)
        {
            RetString = std::to_string(value1 / 1000.0) + "k";
        }
        else if (value1 < 1000000000)
        {
            RetString = std::to_string(value1 / 1000000.0) + "M";
        }
        else if (value1 < 1000000000000LL)
        {
            RetString = std::to_string(value1 / 1000000000.0) + "G";
        }
        else
        {
            RetString = std::to_string(value1 / 1000000000000.0) + "T";
        }
    }
    sq_pushstring(v, RetString.c_str(), -1);
    return 1;
}

static void RegisterGame(HSQUIRRELVM v)
{
    getConfigPath(szGamePath, sizeof(szGamePath));

    // 获取字符串时间戳
    register_World_func(v, L_GetTimestampString, _SC("Sq_GetTimestampString"));

    // 简繁转换
    register_World_func(v, L_Conversion, _SC("Sq_Conversion"));

    // 获取下一个cron
    register_World_func(v, L_Sq_Cron_Next, _SC("Sq_Cron_Next"));
    // 自身封装读取流
    register_World_func(v, _stream_myreadstring, _SC("stream_myreadstring"));
    register_World_func(v, _CrcDecode, _SC("Sq_CrcDecode"));

    // int 和指针相互转换
    register_World_func(v, RunScript, _SC("sq_RunScript"));

    register_World_func(v, L_Ptr2Int, _SC("Sq_Ptr2Int"));
    register_World_func(v, L_Int2Ptr, _SC("Sq_Int2Ptr"));
    register_World_func(v, L_S_Ptr, _SC("S_Ptr"));
    register_World_func(v, L_Str_Ptr, _SC("Str_Ptr"));

    // 指针运算
    register_World_func(v, L_Ptr_Operation_A2S, _SC("Ptr_Operation_A2S"));

    // new一个指针
    register_World_func(v, New_Point, _SC("Sq_New_Point"));
    // 销毁一个指针
    register_World_func(v, Delete_Point, _SC("Sq_Delete_Point"));

    // 获取频道配置
    register_World_func(v, Game_GetConfig, _SC("Sq_Game_GetConfig"));
    // 写地址int
    register_World_func(v, L_WriteAddress, _SC("Sq_WriteAddress"));
    // 读地址int
    register_World_func(v, L_ReadAddress, _SC("Sq_ReadAddress"));
    // 读地址Point
    register_World_func(v, L_ReadPoint, _SC("Sq_ReadPoint"));
    // 读地址字符串
    register_World_func(v, L_ReadAddressString, _SC("Sq_ReadAddressString"));
    // 读取Byte
    register_World_func(v, L_ReadByteArr, _SC("Sq_ReadByteArr"));
    // 写入Byte
    register_World_func(v, L_WriteByteArr, _SC("Sq_WriteByteArr"));
    // 通过指针转Blob
    register_World_func(v, L_Point2Blob, _SC("Sq_Point2Blob"));
    // 写Blob到指定地址
    register_World_func(v, L_WriteBlobToAddress, _SC("Sq_WriteBlobToAddress"));
    // 通过ID从Pvf中查询名称
    register_World_func(v, L_GetNameByIdFromPvf, _SC("Sq_GetNameByIdFromPvf"));
    // 通过ID从Pvf中查询Data
    register_World_func(v, L_GetDataByIdFromPvf, _SC("Sq_GetDataByIdFromPvf"));
    // 创建数据库连接池
    register_World_func(v, L_CreatCConnectPool, _SC("Sq_CreatCConnectPool"));
    // 阻塞线程的数据库操作 无返回值
    register_World_func(v, L_MysqlExecNoRet, _SC("Sq_MysqlExecNoRet"));
    // 创建Socket连接
    register_World_func(v, L_CreatSocketConnect, _SC("Sq_CreatSocketConnect"));
    // 动态调用Call
    register_World_func(v, L_CallFunc, _SC("Sq_CallFunc"));
    // 获取模块函数地址
    register_World_func(v, Sq_getExportByName, _SC("Sq_getExportByName"));
    // 打印表
    register_World_func(v, OutPutTable, _SC("Sq_OutPutTable"));
    // 开启自动热重载
    register_World_func(v, AutoReload, _SC("Sq_AutoReload"));
    // Hook装备镶嵌
    register_World_func(v, L_HookEquimentUseJewel, _SC("L_HookEquimentUseJewel"));
    //大数字计算
    register_World_func(v, LongLongOperation, _SC("Sq_LongLongOperation"));
}