local defaults = {}
setmetatable(defaults, {__mode = "k"})
local mt = {__index = function (t) return defaults[t] end}
function setDefault (t, d)
defaults[t] = d
setmetatable(t, mt)
end

local metas = {}
setmetatable(metas, {__mode = "v"})
function setDefault (t, d)
local mt = metas[d]
if mt == nil then
mt = {__index = function () return d end}
metas[d] = mt -- memorize
end
setmetatable(t, mt)
end

-- 测试环境要求至少Lua 5.2
o = {x = "hi"}
setmetatable(o, {__gc = function (o) print(o.x) end})
o = nil
collectgarbage() --> hi

-- 测试环境要求至少Lua 5.2
mt = {__gc = function (o) print(o[1]) end}
list = nil
for i = 1, 3 do
    list = setmetatable({i, link = list}, mt)
end
list = nil
collectgarbage()
--> 1
--> 2
--> 3

-- 因为当前测试环境是Lua 5.1(基于LuaTo#插件学习的，JIT支持到5.1的版本)所以不支持Talbe的__gc Metamethod，这里暂时没有写测试程序。

for i = 0, 3, 1 do
	print("========================")
	print(i)
	local number = i
	local result = ~number
	print(result)
end

print("========================")
local num1 = 1
print(num1 << 1)
local num2 = -1
print(num2 << 1)

print("========================")
-- 01101(原码)
-- 01101(补码)
local num3 = 13
-- 11011(原码)
-- 10100(反码)
-- 10101(补码)
local num4 = -11
-- 01101(补码) & 10011(补码)
-- 00101(异后补码)
-- 00101(异后原码)
print(num3 & num4)
-- 01101(补码) | 10101(补码)
-- 11101(或后补码)
-- 11100(或后反码)
-- 10011(或后原码)
print(num3 | num4)
-- 01101(补码) ~ 10101(补码)
-- 11000(异或后)
-- 10111(异或后反码)
-- 11000(异或后原码)
print(num3 ~ num4)
print("========================")
-- 11001(原码)
-- 10111(补码)
local num5 = -9
-- 00011(原码)
-- 00011(补码)
local num6 = 3
-- 10111(补码) ~ 00011(补码)
-- 10100(异或后)
-- 10011(异或后反码)
-- 11100(异或后原码)
print(num5 ~ num6)

-- File Name:    Class.lua
-- Description:    模拟Lua里OOP特性(不支持多重继承)
-- Author:       TangHuan
-- Create Date:    2018/11/09

-- 使用方法：
-- 1. 定义类
-- local ClassName = Class("ClassName", nil)
-- ***(自定义类数据方法等)
-- 参数说明：
-- clsname类名，super父类
-- 返回结果:
-- ClassName(含Class基本信息结构的table)

-- 2. 实例化类对象
-- 参数说明：
-- BaseClass含类定义的Class Table
-- ...构造类实例对象的构造函数ctor()的参数
-- 返回结果：
-- 基于BaseClass的实例对象
-- new(BaseClass, ...)

---克隆对象(建议用于克隆Class对象)
---@param  any 对象
---@return  any 克隆对象
function Clone(object)
    local lookup_table = {}
    local function _copy(object)
        if type(object) ~= "table" then
            return object
        elseif lookup_table[object] then
            return lookup_table[object]
        end
        local new_table = {}
        lookup_table[object] = new_table
        for key, value in pairs(object) do
            new_table[_copy(key)] = _copy(value)
        end
        return setmetatable(new_table, getmetatable(object))
    end
    return _copy(object)
end

---判定是否是指定类或者继承至该类
---@param self Class@类实例对象或者类
---@param cname string | Class@类名或者类定义table
local function IsClass(self, cname)
    if type(self) ~= "table" then
        return false;
    end

    if type(cname) == "table" then
        if self.class == cname then
            return true;
        elseif self.super then
            return self.super.IsClass(self.super, cname);
        end
    elseif type(cname) == "string" then
        if self.class.className == cname then
            return true;
        elseif self.super then
            return self.super.IsClass(self.super, cname);
        end
    end
    return false;
end

--- 提供Lua的OOP实现，快速定义一个Class(不支持多重继承)
--- 模拟Class封装，继承，多态，类型信息，构造函数等
--- 模拟一个基础的Class需要的信息
---@param clsname string@类名
---@param super super@父类
---@return Class@含Class所需基本信息的Class table
function Class(clsname, super)
    local classtable = {}
    -- ctor模拟构造函数
    classtable.Ctor = false
    -- className模拟类型信息，负责存储类名
    classtable.className = clsname
    -- super模拟父类
    -- Note: 外部逻辑层不允许直接._super访问父类
    classtable._super = super
    -- 自身class类table
    classtable.class = classtable;
    -- 指定索引元方法__index为自身,模拟类访问
    -- 后面实例化对象时会将classtable作为元表，从而实现访问类封装的数据
    classtable.__index = classtable
    -- 是否是指定类或者继承至某类的方法接口
    classtable.IsClass = IsClass;
    -- 如果指定了父类，通过设置Class的元表为父类模拟继承
    if super then
        setmetatable(classtable, super)
    else
        --print("如果定义的不是最基类，请确认是否require了父类!")
    end
    return classtable
end

--- 提供实例化对象的方法接口
--- 模拟构造函数的递归调用，从最上层父类构造开始调用
---@param cls cls@类定义
---@param ... ...@构造函数变长参数
---@return cls@cls类的实例对象table
function New(cls, ...)
    -- 实例对象表
    local instance = {}
    -- 设置实例对象元表为cls类模拟类的封装访问
    setmetatable(instance, cls)
    -- create模拟面向对象里构造函数的递归调用(从父类开始构造)
    local create
    create = function(cls, ...)
        if cls._super then
            create(cls._super, ...)
        end
        if cls.Ctor then
            cls.Ctor(instance, ...)
        end
    end
    create(cls, ...)
    return instance
end

---静态类
function  StaticClass(clsname)
    return {}
end

类名 = Class("类名")

--构造函数
function 类名:Ctor()
    --成员变量定义
end

--方法定义
function 类名:方法名()

end

子类名 = Class("子类名", 父类名)

--构造函数
function 子类名:Ctor()
    --成员变量定义
end

--方法定义
function 子类名:方法名()

end

local 变量名 = New(类名)
变量名.成员变量
变量名:成员方法()
变量名.静态方法()

function readOnly (t)
    local proxy = {}
    local mt = {       -- create metatable
        __index = t,
        __newindex = function (t,k,v)
            error("attempt to update a read-only table", 2)
        end
    }
    setmetatable(proxy, mt)
    return proxy
end

days = readOnly{"Sunday", "Monday", "Tuesday", "Wednesday",
    "Thursday", "Friday", "Saturday"}

print(days[1])     --> Sunday
days[2] = "Noday"  --> stdin:1: attempt to update a read-only table

function ReadOnly (t, name)
    local proxy = {}
    local mt = {       -- create metatable
        __index = t,
        __newindex = function (t,k,v)
            error(string.format("attempt to update a read-only table:%s", name))
        end,
        __len = function()
        	return #t
	    end,
        __pairs = function()
        	return next, t, nil
	    end
    }
    setmetatable(proxy, mt)
    return proxy
end

local originalTable = {}
table.insert(originalTable, "A")
table.insert(originalTable, "C")
table.insert(originalTable, "B")
local readOnlyTable = ReadOnly(originalTable, "readOnlyTable")
print(#readOnlyTable)
print("==========================")
for key, value in pairs(readOnlyTable) do
	print(key)
	print(value)
end
print("==========================")
for index, value in ipairs(readOnlyTable) do
	print(index)
	print(value)
end
print("==========================")
readOnlyTable[3] = "BB"
--readOnlyTable[4] = "D"

--- 转换table成只读table
---@param t table @需要变成ReadOnly的table
---@param name string @ReadOnly table的名字(方便报错打印定位)
---@param depth number @只读table深度
---@return table @转换后的只读table
function ReadOnlyTable(t, name, depth)
    if type(t) ~= "table" then
        error("not support none table to a recusive read-only table!")
 		return t
    end
	depth = depth or 1
    if depth > 1 then
    	local nextDepth = depth - 1
	    for key, value in pairs(t) do
	    	if type(value) == "table" then
	    		t[key] = ReadOnlyTable (t[key], name, nextDepth)
	    	end
		end
	end
    local proxy = {}
    local mt = {
        __index = t,
        __newindex = function (t,k,v)
            error(string.format("attempt to update a read-only table:%s", name))
        end,
        __len = function()
        	return #t
	    end,
        __pairs = function()
        	return next, t, nil
	    end
    }
    setmetatable(proxy, mt)
    return proxy
end

local originalTable = {}
originalTable["A"] = "A"
originalTable["NestTable"] = {
	["Nest_A"] = "Nest_A",
	["Nest_B"] = "Nest_B",
	["NestNestTable"] = {
		["Nest_Nest_A"] = "Nest_Nest_A",
		["Nest_Nest_B"] = "Nest_Nest_B",
	}
}
originalTable["B"] = "B"
local readOnlyTable = ReadOnlyTable(originalTable, "readOnlyTable", 2)
print_table(readOnlyTable)
print(#readOnlyTable)
print("==========================")
for key, value in pairs(readOnlyTable) do
	print(key)
	print(value)
end
print("==========================")
--readOnlyTable["A"] = "AA" --> ReadOnly Error
--readOnlyTable["NestTable"]["Nest_A"] = "Nest_AA" --> ReadOnly Error
readOnlyTable["NestTable"]["NestNestTable"]["Nest_Nest_A"] = "Nest_Nest_AA"
print_table(readOnlyTable)

local testHandler = {}

function testHandler:FuncWithoutParams()
	print("testHandler:FuncWithoutParams()")
end

function testHandler:TestHandler(cb)    
	cb()
end

testHandler:TestHandler(testHandler.FuncWithoutParams)

-- File Name:      Handler.lua
-- Description:    带self的回调绑定
-- Author:         TonyTang
-- Create Date:    2021/6/5

--- 无参委托绑定
---@param obj table @对象
---@param method func() @方法
---@return func() @委托绑定无参方法
function handler(obj, method)
	return function()
		method(obj)
	end
end

--- 带参委托绑定
---@param obj table @对象
---@param method func() @方法
---@param ... any @参数
---@return func(...) @委托绑定带参方法
function handlerBind(object, method, ...)
	local params = table.pack(...)
	return function()
		method(obj, table.unpack(params))
	end
end

local testHandler = {}

function testHandler:FuncWithoutParams()
	print("testHandler:FuncWithoutParams()")
end

function testHandler:FuncWithParams(param1, param2, param3)
	print(string.format("testHandler:FuncWithParams(%s, %s, %s)", param1, param2, param3))
end

function testHandler:TestHandler()
	local handler = _G.handler(self, self.FuncWithoutParams)
	handler()
end

function testHandler:TestHandlerBind(param1, param2, param3)
	local handlerBind = _G.handlerBind(self, self.FuncWithParams, param1, param2, param3)
	handlerBind()
end

testHandler:TestHandler()
testHandler:TestHandlerBind(1, 2, 3)
testHandler:TestHandlerBind(1, nil, 3)
testHandler:TestHandlerBind(nil, 2, 3)

tab = {}
function tab.dotFunc(param)
    print("self = ", self)
    print(param)
end

function tab:colonFunc(param)
    print("self = ", self)
    print(param)
end

tab.dotFunc(1)
tab:colonFunc(1)

print(type(1))
print(type("Tony"))

print("SerpentStudy!")

require "DIYLog"

local serpent = require "serpent"

local serializeDataTable = {
	["Name"] = "TonyTang",
	detailInfo = {
		["Age"] = 18,
		["BirthDate"] = "2000/01/01",
		["Adrress"] = "SiChuan"		
	}
}

print("=================")
local serializeString = serpent.dump(serializeDataTable)
print(serializeString)

print("=================")

local formatSerializeString = serpent.block(serializeDataTable)
print(formatSerializeString)

print("=================")

local result, deserializeDataTable = serpent.load(formatSerializeString)
print_table(deserializeDataTable)

print("LpegStudy")

require "DIYLog"

--- 最终目标：
--- 1. {***}占位替换 
--- 2. {num string1 | string2 | string3 }根据num选择对应字符串

local lpeg = require("lpeg")
local match = lpeg.match
local P = lpeg.P
local R = lpeg.R

--- 普通匹配
print("普通匹配:")
--- 不匹配，返回nil
print(match(P("hello"), "world"))
--- 一个匹配，返回6
print(match(P("hello"), "hello"))
--- 一个匹配，返回6
print(match(P("hello"), "helloworld"))

--- 模式组合
print("模式组合:")
local helloPattern = P("hello")
local worldPattern = P("world")
--- *表示匹配pattern1后面跟随pattern2
local helloAndworldPattern = helloPattern * worldPattern
--- +表示匹配pattern1或者pattern2
local helloOrworldPattern = helloPattern + worldPattern
--- 一个匹配，返回11
print(match(helloAndworldPattern, "helloworld"))
--- 不匹配，返回nil
print(match(helloAndworldPattern, "worldhello"))
--- 1个匹配，返回6
print(match(helloOrworldPattern, "helloworld"))
--- 1个匹配，返回6
print(match(helloOrworldPattern, "worldhello"))

--- 解析数字
print("解析数字:")
local integerPattern = R("09")^1
--- 解析数字带捕获函数
local integerCapturePattern = R("09")^1 / tonumber
--- 匹配，返回5
print(match(integerPattern, "2923 2924"))
--- 匹配，返回2923
print(match(integerCapturePattern, "2923 2924"))

--- 解析数字或者字符
print("解析数字或者字符：")
local charPattern = P(1)
--- 匹配，返回2
print(match(charPattern, "hello 123"))
local integerOrchaPattern = integerCapturePattern-- + charPattern
--- 利用Capture.Ct函数存储所有匹配结果到表中
local integerOrcharCapture = lpeg.Ct(integerOrchaPattern^0)
--- 未匹配输出 {}
print_table(match(integerOrcharCapture, "hello!"))
--- 匹配，输出：{123}
print_table(match(integerOrcharCapture, "hello 123"))
--- 匹配，输出：{5,5,5,7,7,7}
print_table(match(integerOrcharCapture, "5 5 5 yeah 7 7 7"))
--- 匹配，输出：{5,5,5,7,7,7}
print_table(match(integerOrcharCapture, "5 5 5 a b c d 7 7 7"))

--- 计算器语法解析器
print("计算器语法解析器:")
local white = lpeg.S(" \t\r\n") ^ 0

local integer = white * lpeg.R("09") ^ 1 / tonumber
local muldiv = white * lpeg.C(lpeg.S("/*"))
local addsub = white * lpeg.C(lpeg.S("+-"))

local factor = integer * muldiv * integer + integer

--- 匹配，输出:{5}
print_table(match(lpeg.Ct(factor), "5"))
--- 匹配，输出:{2,"*",1}
print_table(match(lpeg.Ct(factor), "2*1"))

--- 字符串匹配替换
--- 实现类似gsub的方法的效果
print("字符串匹配替换：")
--- lpeg.Ct -- 仅仅捕获到table
function find(s, patt)
	patt = P(patt) / tostring
	local p = lpeg.Ct((patt + 1)^0)
	return match(p, s)
end

--- lpeg.Cs -- 捕获并替换
function gsub(s, patt, repl)
	patt = P(patt)
	local p = lpeg.Cs((patt / repl + 1)^0)
	return match(p, s)
end

--- 匹配，输出:{"dog","dog"}
print_table(find("hello dog, dog!", "dog"))
--- 匹配，输出:{"hello cat, cat!"}
print_table(gsub("hello dog, dog!", "dog", "cat"))

--- 最终目标1: {***}占位替换
--- 指定字符串，采用table里的key替换{key}成key对应的value
function tableGsub(s, tb)
	local result = s
	local replaceKey = nil
	local replaceValue = nil
	for key, value in pairs(tb) do
		replaceKey = string.format("{%s}", key)
		replaceValue = tostring(value)
		print(string.format("字符串:%s 替换:%s为%s", result, replaceKey, replaceValue))
		result = gsub(result, replaceKey, replaceValue)
		print(string.format("替换后结果:%s", result))
	end
	return result
end

local content = "测试table替换,名字:{name} 年龄:{age} 性别:{sex} 名字2:{name} 名字3:{name}"
local replaceTable = {
	name = "TonyTang",
	sex = "Man",
	age = 18,
	luckyNumber = 7,
}
local timeCounter = New(TimeCounter, "tableGsub")
timeCounter:Start()
content = tableGsub(content, replaceTable)
timeCounter:Stop()
print("替换后结果:replaceValue")
print(content)
print(string.format("替换耗时:%s", timeCounter.EllapseTime))

{
    "Lua File Title Sneppits": {
        "prefix": "LuaFileTitle",
        "body": [
            "-- File Name:    $TM_FILENAME",
            "-- Description:    This file is used to ${1:Staff}",
            "-- Author:       ${2:TangHuan}",
            "-- Create Date:    ${3:Year}/${4:Month}/${5:Day}",
        ],
        "description": "Lua File Title Sneppits"
    }
}

-- File Name:    Base.lua
-- Description:    This file is used to Staff
-- Author:       TangHuan
-- Create Date:    Year/Month/Day

-- File Name:    Test.lua
-- Description:    This file is used to Test EmmyLua
-- Author:       TangHuan
-- Create Date:    2019/04/29

--- 自定义table类型，测试Emmylua注释提示
---@class diytable
---@field field1 number 字段1
---@field field2 string 字段2
local diytable = {
    field1 = 321,
    field2 = "field2"
}

---@param para1 number 参数1
---@return diytable 返回diytable
function Test(para1)
    print("Test(" .. para1 .. ")")
    return diytable
end

local table = Test(123)
print(table.field1)
print(table.field2)