require "ProtocolCode"
  require "shared.init"
  require "utils.init"
  require "GlobalVar"
  require "RedisKeys"
  require "skynet.manager"
  
  local harbor = require "skynet.harbor"
  local queue = require "skynet.queue"
  local netpack = require "skynet.netpack"
  local socket = require "skynet.socket"
  local sharedata = require "skynet.sharedata"
  local xxtea = require "xxtea"
  
  skynet = require "skynet"
  redisproxy = require "shared.redisproxy"
  datacenter = require "skynet.datacenter"
  mcast_util = require "services/mcast_util"
  globalCsv = require "csvdata/GlobalDefine"
  
  local CMD = {}
  local agentInfo = {}  -- { client_fd, role, gate_serv, open_timer}
  
  local agent_util, cs
  
  --- {{{ 定时器相关
  local function handle_timeout()
  	if not agentInfo.open_timer then return end
  
  	if not agentInfo.role then
  		skynet.timeout(100, handle_timeout)
  		return
  	end
  
  	agent_util:update(agentInfo)
  	skynet.timeout(100, handle_timeout)
  end
  
  function start_agent_timer()
  	agentInfo.open_timer = true
  	skynet.timeout(150, handle_timeout)
  end
  
  function cancel_agent_timer()
  	agentInfo.open_timer = false
  end
  ---- 定时器相关 }}}
  
  function SendPacket(actionCode, bin, client_fd)
  	if #bin > 0 then bin = xxtea.encrypt(bin, XXTEA_KEY) end
  
  	local handlerName = actionHandlers[actionCode]
  	if string.sub(handlerName, -3, -1) == "Rpc" then
  		actionCode = actionCode + rpcResponseBegin
  	end
  
  	local client_fd = client_fd or agentInfo.client_fd
  	local head = string.pack("H", actionCode)
  	return socket.write(client_fd, netpack.pack(head .. bin))
  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 rediskey = string_format("role:%d", roleId)
  		if funcName == "setProperty" then
  			return false, redisproxy:hset(rediskey, ...)
  		elseif funcName == "getProperty" then
  			return false, redisproxy:hget(rediskey, ...)
  		elseif funcName == "getProperties" then
  			local sRole = require("models.Role")
  			local returnValue = redisproxy:hmget(rediskey, table_unpack(...))
  			local ret = {}
  			for index, key in ipairs(fields) do
  			    local typ = sRole.schema[key][1]
  			    local def = sRole.schema[key][2]
  			    if typ == "number" then
  			    	ret[key] = tonumber(returnValue[index] or def)
  				else
  			    	ret[key] = returnValue[index]
  			    end
  			end
  			return false, ret
  		elseif funcName == "setProperties" then
  			local result = {}
  			for k,v in pairs(fields) do
  				result[#result+1] = k
  				result[#result+1] = v
  			end
  			return false, redisproxy:hmset(rediskey, table_unpack(result))
  		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)
  		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
  			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
  
  			local method = action[funcName]
  
  			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
  			local result = method(agentInfo, data)
  			if not result then
  				SendPacket(actionCodes.Sys_innerErrorMsg, MsgPack.pack({id = cmd}))
  			end
  		end)
  	end
  }
  
  skynet.register_protocol {
  	name = "role",
  	id = 12,
  	pack = skynet.pack,
  	unpack = skynet.unpack,
  	dispatch = function(session, address, submethod, ...)
  		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, fd, ip)
  	ignoreHeartbeat = false
  
  	agentInfo.client_fd = fd
  	agentInfo.gate_serv = gate
  	agentInfo.ip = ip
  
  	agent_util:reset()
  	math.randomInit()
  
  	-- 这里将消息伪装成 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
  	role:log("logout", {online = skynet.timex()-role:getProperty("lastLoginTime")})
  	role:onOfflineEvent()
  end
  
  function CMD.exit()
  	if agentInfo.role then
  		-- role:log("logout", {online = skynet.timex()-role:getProperty("lastLoginTime")})
  		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
  
  local function routeGM(cmd, params)
  	if type(params) ~= "table" or not agentInfo.role then
  		return "指令失败"
  	end
  	local _M = require "actions.GmAction"
  	return _M[cmd](agentInfo.role, params)
  end
  
  skynet.start(function()
  	skynet.dispatch("lua", function(session, source, command, ...)
  		local f = CMD[command]
  		if f then
  			if command == "exit" then
  				f(...)
  			elseif command == "start" then
  				f(session, source, ...)
  			else
  				skynet.ret(skynet.pack(f(...)))
  			end
  		else
  			skynet.ret(skynet.pack(routeGM(command, ...)))
  		end
  	end)
  
  	redisd = harbor.queryname("REDIS")
  	if tonumber(skynet.getenv "logd") == 1 then
  		logd = harbor.queryname("LOGD")
  	end
  
  	cs = queue()
  
  	-- csv
  	csvdb = sharedata.query("csvdata")
  	-- 错误码特殊处理
  	-- todo
  	-- for key, value in pairs(csvdb["sys_codesCsv"]) do
  	-- 	_G[string.upper(value.varname)] = key
  	-- end
  
  	agent_util = require "services/agent_util"
  end)