require "ProtocolCode"
  require "shared.init"
  require "utils.init"
  require "GlobalVar"
  require "RedisKeys"
  require "skynet.manager"
  

  local queue = require "skynet.queue"
  local netpack = require "skynet.netpack"
  local socket = require "skynet.socket"

  local xxtea = require "xxtea"
  
  skynet = require "skynet"
  redisproxy = require "shared.redisproxy"

  mysqlproxy = require "shared.mysqlproxy"

  datacenter = require "skynet.datacenter"
  mcast_util = require "services/mcast_util"

  csvdb = require "shared.csvdata"

  cluster = require "skynet.cluster"

  
  local CMD = {}
  local agentInfo = {}  -- { client_fd, role, gate_serv, open_timer}
  
  local agent_util, cs
  

  _hotfixActions = _hotfixActions or {}

  _hotfixClass = _hotfixClass or {}

  _codeSession = {}
  

  --- {{{ 定时器相关
  local function handle_timeout()
  	if not agentInfo.open_timer then return end

  	agent_util:update(agentInfo)
  	skynet.timeout(100, handle_timeout)
  end
  

  local function handle_gc()

  	if not agentInfo.open_timer then return end

      collectgarbage("collect")
  	skynet.timeout(6000, handle_gc)
  end
  

  function start_agent_timer()

  	if agentInfo.open_timer then return end

  	agentInfo.open_timer = true
  	skynet.timeout(150, handle_timeout)

  	skynet.timeout(6000, handle_gc)

  end
  
  function cancel_agent_timer()
  	agentInfo.open_timer = false
  end
  ---- 定时器相关 }}}
  

  local _pipelinings = {}  --可同时多个序列  栈的形式保证嵌套不出错

  function SendPacket(actionCode, bin, client_fd)

  	--print(actionHandlers[actionCode])
  	--dump(MsgPack.unpack(bin))

  	-- 内部消息不扩散出去
  	if actionCode == actionCodes.Sys_endlessSeason then
  		if agentInfo.role then
  			agentInfo.role:advEndlessSeasonCheck()
  		end
  		return
  	end

  	client_fd = client_fd or agentInfo.client_fd
  	

  	local handlerName = actionHandlers[actionCode]

  	local isRpc = string.sub(handlerName, -3, -1) == "Rpc"
  	local session = _codeSession[actionCode] or 0
  	if isRpc then

  		actionCode = actionCode + rpcResponseBegin
  	end

  	--  查看是否是在 流水线操作中
  	if #_pipelinings > 0 then
  		local _curPipelining = _pipelinings[#_pipelinings]
  		_curPipelining[client_fd] = _curPipelining[client_fd] or {} --区分不同客户端

  		if not isRpc then
  			session = nil
  		end
  		table.insert(_curPipelining[client_fd], {actionCode, bin, session})

  	else
  		if #bin > 0 then bin = xxtea.encrypt(bin, XXTEA_KEY) end
  		local head = string.pack("H", actionCode)

  		if isRpc then
  			-- 是回复 -- 有session号
  			head = head .. string.pack("H", session)
  		end

  		return socket.write(client_fd, netpack.pack(head .. bin))
  	end
  end

  function SendPipelining(callback)
  	if type(callback) ~= "function" then return end
  	--push 当前队列
  	table.insert(_pipelinings, {})
  	-- 执行代码块  输出错误信息
  	local ok, err = pcall(callback)
  	--弹出当前队列
  	local curPipelining = table.remove(_pipelinings)
  	-- 查看是否有消息
  	if next(curPipelining) then  
  		for client_fd, msg in pairs(curPipelining) do
  			SendPacket(actionCodes.Role_pipelining, MsgPack.pack(msg), client_fd)
  		end
  	end
  	if not ok then error(err) end

  end
  
  function rpcAgent(roleId, funcName, ...)
  	local agent = datacenter.get("agent", roleId)
  	if agent then
  		return skynet.call(agent.serv, "lua", funcName, ...)
  	end
  end
  
  function rpcParter(serv, func, ...)
  	if serv then
  		local ok, result = pcall(skynet.call, serv, "role", func, ...)
  		if ok then
  			return result
  		end
  	end
  end
  
  local string_format = string.format
  local table_unpack = table.unpack
  function rpcRole(roleId, funcName, ...)
  	local fields = ...
  	local agent = datacenter.get("agent", roleId)
  	if agent and agent.serv then
  		if funcName == "getProperties" then
  			return true, skynet.call(agent.serv, "role", funcName, fields)
  		else
  			return true, skynet.call(agent.serv, "role", funcName, ...)
  		end
  	else

  		local roleCross = require("models.RoleCross")

  		if funcName == "getProperties" then
  			return false, roleCross.handle(funcName, roleId, fields)
  		else
  			return false, roleCross.handle(funcName, roleId, ...)
  		end

  	end
  end
  
  function rpcUnion(funcName, ...)
  	local serv = agentInfo.userv
  	if not serv then
  		local consortiaId = agentInfo.role:getProperty("consortiaId")
  		if consortiaId == 0 then return true,1000 end
  		local union = datacenter.get("union", consortiaId)
  		if not union or not union.serv then
  			skynet.error("rpcUnion error: union serv addr not exist", funcName, consortiaId)
  			return
  		end
  		serv = union.serv
  	end
  	return skynet.call(serv, "lua", funcName, ...)
  end
  
  function rpcOtherUnion(id, funcName, ...)
  	local union = datacenter.get("union", id)
  	if union and union.serv then
  		return skynet.call(union.serv, "lua", funcName, ...)
  	end
  end
  

  skynet.register_protocol {
  	name = "client",
  	id = skynet.PTYPE_CLIENT,
  	unpack = function (msg, sz)
  		local data = skynet.tostring(msg, sz)
  		local cmd = string.unpack("H", string.sub(data, 1, 2))
  		return cmd, string.sub(data, 3)
  	end,
  	dispatch = function(session, address, cmd, data)

  		skynet.ignoreret()

  		-- skynet.trace() --执行序的跟踪统计

  		cs(function()
  			if cmd == actionCodes.Sys_heartBeat then
  				agent_util:heart_beat(agentInfo)
  				return
  			end
  			local actionName = actionHandlers[cmd]
  			if not actionName then
  				print("actionName not exist", actionName)
  				return
  			end

  			if string.sub(actionName, -3, -1) == "Rpc" then
  				-- 是请求 -- 有session号
  				local codeSession = string.unpack("H", string.sub(data, 1, 2))
  				_codeSession[cmd] = codeSession
  				data = string.sub(data, 3)
  			end
  

  			local method
  			if _hotfixActions[actionName] then
  				method = _hotfixActions[actionName]
  			else
  				local modName, funcName = actionName:match("(%w+)%.(%w+)")
  
  				local ok, action = pcall(require, "actions." .. modName .. "Action")
  				if not ok then
  					print("require module name error", action, modName)
  					return
  				end
  				method = action[funcName]

  			end

  			if type(method) ~= "function" then
  				print("ERROR_SERVER_INVALID_ACTION", modName, funcName)
  				return
  			end
  
  			if #data > 0 then data = xxtea.decrypt(data, XXTEA_KEY) end

  
  			-- 一次操作是一个关联操作 记录 ucode 是一样的
  			if agentInfo.role then
  				agentInfo.role:startActionUcode()
  			end
  			

  			local result = method(agentInfo, data)

  
  			if agentInfo.role then
  				agentInfo.role:endActionUcode()
  			end
  

  			-- 清掉请求session
  			_codeSession[cmd] = nil
  

  			if not result or type(result) == "number" then
  				SendPacket(actionCodes.Sys_innerErrorMsg, MsgPack.pack({id = cmd * 100 + (result or 0)}))

  			end
  		end)
  	end
  }
  
  skynet.register_protocol {
  	name = "role",

  	id = 101,

  	pack = skynet.pack,
  	unpack = skynet.unpack,
  	dispatch = function(session, address, submethod, ...)

  		-- skynet.trace() --执行序的跟踪统计

  		local result
  		if not agentInfo.role then
  			result = "__OFFLINE__"
  		else
  			result = agentInfo.role[submethod](agentInfo.role, ...)
  		end
  
  		skynet.ret(skynet.pack(result))
  	end,
  }
  
  -- function CMD.start(gate, fd, ip)

  function CMD.start(session, source, gate, capsuled, fd, ip, hotfixs)

  	ignoreHeartbeat = false
  
  	agentInfo.client_fd = fd
  	agentInfo.gate_serv = gate

      agentInfo.capsule_serv = capsuled

  	agentInfo.ip = ip
  
  	agent_util:reset()
  	math.randomInit()
  

  	if hotfixs then
  		for _, hotfix in ipairs(hotfixs) do
  			CMD.hotfix(hotfix)
  		end

  	end

  	start_agent_timer()
  

  	-- 这里将消息伪装成 watchdog 发出，这样就由 A->B->C->B->A 变成 A->B->C->A
  	skynet.redirect(gate, source, "lua", session, skynet.pack("forward", fd, 0, skynet.self()))
  end
  
  function CMD.close()
  	cancel_agent_timer()
  	mcast_util.usub_world()
  	mcast_util.usub_union()

  	local role = agentInfo.role
  	if not role then return end

  	skynet.call(agentInfo.capsule_serv, "lua", "exit", role:getProperty("id"))

  	role:log("onLogout", {logtime = skynet.timex()-role:getProperty("ltime")})

  	role:mylog("logout", {int1 = skynet.timex()-role:getProperty("ltime")})

  	role:onOfflineEvent()
  end
  
  function CMD.exit()
  	if agentInfo.role then

  		datacenter.set("agent", agentInfo.role:getProperty("id"), nil)
  	end
  	skynet.exit()
  end
  
  function CMD.subUnion(consortiaId, union)
  	mcast_util.sub_union(consortiaId, union.chan)
  	agentInfo.userv = union.serv
  end
  
  function CMD:usubUnion()
  	mcast_util.usub_union()
  	agentInfo.userv = nil
  end
  

  function CMD.hotfix(code)
  	local ok, func = pcall(load, code)
  	if ok then

  		ok = pcall(func, agentInfo.role)

  	end
  	if not ok then

  		skynet.error("hotfix_code error by code " .. code)

  	end
  end
  

  local function routeGM(cmd, params)
  	if type(params) ~= "table" or not agentInfo.role then
  		return "指令失败"
  	end
  	local _M = require "actions.GmAction"

  
  	agentInfo.role:startActionUcode()
  	local status = _M[cmd](agentInfo.role, params)
  	agentInfo.role:endActionUcode()
  	
  	return status

  end
  
  skynet.start(function()
  	skynet.dispatch("lua", function(session, source, command, ...)

  		-- skynet.trace() --执行序的跟踪统计

  		local f = CMD[command]
  		if f then
  			if command == "exit" then

  				skynet.ignoreret()

  				f(...)
  			elseif command == "start" then

  				skynet.ignoreret()

  				f(session, source, ...)

  			elseif command == "hotfix" then
  				skynet.ignoreret()
  				f(...)

  			else
  				skynet.ret(skynet.pack(f(...)))
  			end
  		else
  			skynet.ret(skynet.pack(routeGM(command, ...)))
  		end
  	end)
  

  	skynet.info_func(function()
  		local info = {}
  		info.ip = agentInfo.ip
  		if agentInfo.role then
  			info.roldId = agentInfo.role:getProperty("id")
  		end
  		return info
  	end)
  

  	cs = queue()
  

  	pvpd = skynet.localname(".pvpcross")

  	-- 错误码特殊处理
  	-- todo
  	-- for key, value in pairs(csvdb["sys_codesCsv"]) do
  	-- 	_G[string.upper(value.varname)] = key
  	-- end

  	globalCsv = csvdb["GlobalDefineCsv"]

  	agent_util = require "services/agent_util"
  end)