-- 判断表是否为空
---@param t table 要判断的表
---@return boolean 如果表为空则返回true，否则返回false
function table.isempty(t)
    for k, v in pairs(t) do
        return false
    end
    return true
end

-- 获取表的元素数量
---@param t table 要获取元素数量的表
---@return number 表的元素数量
function table.nums(t)
    local count = 0
    for k, v in pairs(t) do
        count = count + 1
    end
    return count
end

-- 获取表的所有键
---@param hashtable table 要获取键的表
---@return table 表的所有键
function table.keys(hashtable)
    local keys = {}
    for k, v in pairs(hashtable) do
        keys[#keys + 1] = k
    end
    return keys
end
    
-- 获取表的所有值
---@param hashtable table 要获取值的表
---@return table 表的所有值
function table.values(hashtable)
    local values = {}
    for k, v in pairs(hashtable) do
        values[#values + 1] = v
    end
    return values
end

-- 合并两个表
---@param dest table 目标表
---@param src table 源表
function table.merge(dest, src)
    for k, v in pairs(src) do
        dest[k] = v
    end
end

-- 将一个表插入到另一个表的指定位置
---@param dest table 目标表
---@param src table 要插入的表
---@param begin number 开始插入的位置，默认为0
function table.insertto(dest, src, begin)
    begin = begin or 0
    if begin <= 0 then
        begin = #dest + 1
    end

    local len = #src
    for i = 0, len - 1 do
        dest[i + begin] = src[i + 1]
    end
end

-- 在序列表中查找指定的值并返回其索引
---@param array table 要查找的序列表
---@param value any 要查找的值
---@param begin number 开始查找的位置，默认为1
---@return number|boolean 如果找到值则返回其索引，否则返回false
function table.indexof(array, value, begin)
    for i = begin or 1, #array do
        if array[i] == value then return i end
    end
    return false
end

-- 在表中查找指定值的键
---@param hashtable table 要查找的表
---@param value any 要查找的值
---@return any|nil 如果找到值则返回其键，否则返回nil
function table.keyof(hashtable, value)
    for k, v in pairs(hashtable) do
        if v == value then return k end
    end
    return nil
end

-- 从数组中移除指定值
---@param array table 要移除值的数组
---@param value any 要移除的值
---@param removeall boolean 是否移除所有匹配的值，默认为false
---@return number 移除的值的数量
function table.removebyvalue(array, value, removeall)
    local c, i, max = 0, 1, #array
    while i <= max do
        if array[i] == value then
            table.remove(array, i)
            c = c + 1
            i = i - 1
            max = max - 1
            if not removeall then break end
        end
        i = i + 1
    end
    return c
end

-- 对表中的每个元素进行映射操作
---@param t table 要进行映射操作的表
---@param fn function 映射操作的函数
function table.map(t, fn)
    for k, v in pairs(t) do
        t[k] = fn(v, k)
    end
end

-- 对表中的每个元素进行遍历操作
---@param t table 要进行遍历操作的表
---@param fn function 遍历操作的函数
function table.walk(t, fn)
    for k,v in pairs(t) do
        fn(v, k)
    end
end

-- 对表中的每个元素进行过滤操作
---@param t table 要进行过滤操作的表
---@param fn function 过滤操作的函数
function table.filter(t, fn)
    for k, v in pairs(t) do
        if not fn(v, k) then t[k] = nil end
    end
end

-- 去除表中的重复元素
---@param t table 要去除重复元素的表
---@param bArray boolean 是否为数组，默认为false
---@return table 去除重复元素后的表
function table.unique(t, bArray)
    local check = {}
    local n = {}
    local idx = 1
    for k, v in pairs(t) do
        if not check[v] then
            if bArray then
                n[idx] = v
                idx = idx + 1
            else
                n[k] = v
            end
            check[v] = true
        end
    end
    return n
end

-- 根据键值对在表中查找元素
---@param t table 要查找的表
---@param key any 键
---@param value any 值
---@return any|nil 如果找到元素则返回该元素，否则返回nil
function table.findtbykv(t, key, value)
    for _,v in pairs(t) do
        if v[key] == value then
            return v
        end
    end
end

-- 在数组中查找满足条件的元素
---@param t table 要查找的数组
---@param fn function 条件判断函数
---@param reverse boolean 是否反向查找，默认为false
---@return any|nil 如果找到满足条件的元素则返回该元素，否则返回nil
function table.findarrvalue(t, fn, reverse)
    local size = #t
    local begin = reverse and size or 1
    local toend = reverse and 1 or size
    local change = reverse and -1 or 1

    local result
    for i=begin,toend,change do
        result = fn(t[i], i)
        if result then return result end
    end
end

-- 判断两个数组是否相等
---@param arr1 table 第一个数组
---@param arr2 table 第二个数组
---@return boolean 如果两个数组相等则返回true，否则返回false
function table.arrequal(arr1, arr2)
    local size1, size2 = #arr1, #arr2
    if size1 ~= size2 then return false end

    for k,v1 in ipairs(arr1) do
        local v2 = arr2[k]
        if v1 ~= v2 then return false end
    end

    return true
end



-- 复制非镜像表
function table.Copy(orig)
    local orig_type = type(orig)
    local copy
    if orig_type == 'table' then
        copy = {}
        for orig_key, orig_value in next, orig, nil do
            copy[table.Copy(orig_key)] = table.Copy(orig_value)
        end
        setmetatable(copy, table.Copy(getmetatable(orig)))
    else -- number, string, boolean, etc
        copy = orig
    end
    return copy
end