local ipairs = ipairs
  local table = table
  local math = math
  local next = next
  local string = string
  local redisproxy = redisproxy
  local MsgPack = MsgPack
  local getRandomName = getRandomName
  local mcast_util = mcast_util
  local string_format = string.format
  local tonumber = tonumber
  local require = require
  local table_insert = table.insert
  local tconcat = table.concat
  local httpc = require("http.httpc")
  
  local WAVE_HERO_NUMS = 150

  local WAVE_RUNE_NUMS = 150

  
  local function validName(name)
  	name = string.upper(name)
  	local exist = redisproxy:exists(string_format("user:%s", name))
  	if exist then return "existed" end
  
  	local SERV = string_format("NAMED%d", math.random(1, 5))
  	local legal = skynet.call(SERV, "lua", "check", name)
  	return legal and "ok" or "illegal"
  end
  
  -- 随机玩家名
  local function randomRoleName()
  	-- 过滤已经存在的名字
  	local name
  	repeat
  		name = getRandomName()
  	until validName(name) == "ok"
  	return name
  end
  
  local function setRoleName(uid, roleId)
  	local result
  	local name
  	local dbName
  	repeat
  		name = randomRoleName()
  		dbName = string.upper(name)
  		result = redisproxy:setnx(string_format("user:%s", dbName), roleId)
  	until result == 1
  	redisproxy:set(string_format("uid:%s", uid), dbName)
  	return name
  end
  
  local _M = {}
  function _M.loginRpc( agent, data )
  	local msg = MsgPack.unpack(data)
  	local response = {}

  	-- if msg.version ~= globalCsv.version then
  	-- 	response.result = "UPDATE_TIP"
  	-- 	SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  	-- 	return true
  	-- end

  
  	-- 1.
  	local roleId = redisproxy:get(string_format("user:%s", string.upper(msg.name)))
  	if not roleId then
  		response.result = "NOT_EXIST"
  		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  		return true
  	end
  
  	roleId = tonumber(roleId)
  
  	--维护不能登录
  	local maintain = tonumber(redisproxy:hget("autoincrement_set", "maintain"))
  	if maintain and maintain > 0 then

  		if tonumber(redisproxy:hget(string_format("role:%d", roleId), "ignoreMt")) ~= 1 then

  			response.result = "MAINTAIN_TIP"
  			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  			return true
  		end
  	end
  
  	local now = skynet.timex()
  	local role = agent.role
  	-- 2
  	if not role then
  		local roleKey = string_format("role:%d", roleId)
  		if not redisproxy:exists(roleKey) then
  			response.result = "DB_ERROR"
  			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  			return true
  		end
  		-- 2a
  		role = require("models.Role").new({key = roleKey})
  		role:load()
  		role:loadAll()
  	else
  		role:reloadWhenLogin()
  	end

  	if not msg.isGMlogin then
  		local banTime = role:getProperty("banTime")
  		if banTime > now then
  			response.result = "BAN_TIP"
  			response.banTime = banTime
  			response.banType = role:getProperty("banType")
  			response.roleId = roleId
  			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  			return true
  		end
  		if banTime ~= 0 then
  			-- 清除封号状态
  			role:setBan(0)
  		end
  	end

  	SERV_OPEN = redisproxy:hget("autoincrement_set", "server_start")

  	role:changeStructVersion() -- 数据结构 版本更新

  	role:advEndlessSeasonCheck() -- 冒险赛季更新检查

  	-- 跨天登陆事件

  	role:onCrossDay(now)

  	role:onResetRank(now)

  	role:setProperty("ltime", now)

  	redisproxy:zadd(FRIEND_RECOMMEND, now, roleId)

  	for _, name in ipairs({"dailyData", "dinerData", "pvpData"}) do

  		response[name] = role[name]:data()
  	end
  

  	response.role = role:data()
  	response.result = "SUCCESS"
  	response.serverTime = now
  

  	local modules = {}
  
  	local heroIds = {}
  	for heroId, _ in pairs(role.heros) do
  		table.insert(heroIds, heroId)
  	end
  	local heroWave = math.ceil(#heroIds / WAVE_HERO_NUMS)

  	if #heroIds <= 50 then

  		heroWave = 0
  		table_insert(modules, "heros")
  	end
  

  	local runeIds = {}
  	for id ,_ in pairs(role.runeBag) do
  		table.insert(runeIds, id)
  	end 
  	local runeWave = math.ceil(#runeIds / WAVE_RUNE_NUMS)
  	if #runeIds <= 50 then
  		runeWave = 0
  		table_insert(modules, "runeBag")
  	end
  

  	for _, name in ipairs(modules) do
  		response[name] = {}
  		for id, unit in pairs(role[name]) do
  			response[name][id] = unit:data()
  		end
  	end
  

  	response.wave = 1 + heroWave + runeWave + 1

  
  	SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  

  	local curWave = 1 
  
  	local runeIndex = 1
  	for index = curWave + 1, curWave + runeWave do
  		local runeResponse = {runeBag = {}}
  		for i = runeIndex, runeIndex + WAVE_RUNE_NUMS do
  			local runeId = runeIds[i]
  			if not runeId then
  				break
  			end
  			local rune = role.runeBag[runeId]
  			table.insert(runeResponse.runeBag, rune:data())
  			runeIndex = runeIndex + 1
  		end
  		runeResponse.runeWave = index
  		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(runeResponse))

  	end

  	curWave = curWave + runeWave

  	local heroIndex = 1

  	for index = curWave + 1, curWave + heroWave do

  		local heroResponse = {heros = {}}
  		for i = heroIndex, heroIndex + WAVE_HERO_NUMS do
  			local heroId = heroIds[i]
  			if not heroId then
  				break
  			end
  			local hero = role.heros[heroId]
  			table_insert(heroResponse.heros, hero:data())
  			heroIndex = heroIndex + 1
  		end
  		heroResponse.heroWave = index
  		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(heroResponse))
  	end

  	curWave = curWave + heroWave

  
  	-- role:log("login", { ip = agent.ip, diamond = role:getProperty("diamond"), reDiamond = role:getProperty("reDiamond")})
  
  	datacenter.set("agent", roleId, {
  		serv = skynet.self(),
  		fd = agent.client_fd,
  		gate_serv = agent.gate_serv,
  	})
  	agent.role = role

  	start_agent_timer()
  	-- 注册全服广播
  	local channel = math.randomInt(1, 1)

  	role._channelIdx = channel

  	local w_channel = datacenter.get( ("MC_W_CHANNEL" .. channel) )
  	if w_channel then
  		mcast_util.sub_world(w_channel)
  	end

  
  	-- 发下缓存的世界消息
  	local worldChatResponse = {worldChats = {}}
  	local ok, msgs = pcall(skynet.call, 'GLOBALD', "lua", "getWorldMsg", channel)
  	if not ok then 
  		msgs = {} 
  	end
  	worldChatResponse.worldChats = msgs

  	worldChatResponse.p2pChats = redisproxy:lrange(CHAT_OFFLINE:format(roleId), 0, -1)

  	worldChatResponse.chatWave = curWave + 1
  	curWave = curWave + 1
  
  	SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(worldChatResponse))
  

  	return true
  end
  
  function _M.createRpc(agent, data)
  	local msg = MsgPack.unpack(data)
  	local response = {}
  
  	-- 再次检查uid
  	local uid = tostring(msg.uid)
  	local user = redisproxy:get(string_format("uid:%s", uid))
  	if user then
  		response.result = "SUCCESS"
  		response.roleName = user
  		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
  		return true
  	end
  
  	local roleId = getNextRoleId()
  	if not roleId then
  		response.result = "DB_FULL"
  		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
  		return true
  	end
  	local roleName = setRoleName(msg.uid, roleId)

  	local newRole = require("models.Role").new({
  		key = string_format("role:%d", roleId),
  		id = roleId,
  		uid = tostring(msg.uid),
  		subId = msg.subId or 0,
  		name = roleName,
  		uname = msg.uname or "",
  		device = tostring(msg.device)
  	})
  
  	if newRole:create() then
  		--更新USER表
  		response.result = "SUCCESS"
  		response.roleId = roleId
  		response.roleName = string.upper(roleName)
  	else
  		response.result = "DB_ERROR"
  		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
  		return true
  	end
  

  	-- 欢迎邮件
  	-- redisproxy:insertEmail({roleId = roleId, emailId = 1})
  	-- redisproxy:insertEmail({roleId = roleId, emailId = 2})
  
  	newRole:log("create", { ip = agent.ip, ucode = ucode})
  
  	SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
  	return true
  end
  
  function _M.syncTimeRpc(agent, data)
  	SendPacket(actionCodes.Role_syncTimeRpc, MsgPack.pack({nowTime = skynet.timex()}))
  	return true
  end
  

  function _M.saleItemRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	local backs = msg.backs
  	if not backs then return end
  
  	local reward = {}

  	local fragCount = 0

  	for itemId, count in pairs(backs) do
  		if math.illegalNum(count, 1, role:getItemCount(itemId)) then return end
  		local itemData = csvdb["itemCsv"][itemId]
  		if itemData.sell_effect == "" then return end

  		if itemData.type == ItemType.HeroFragment or itemData.type == ItemType.HeroFCommon then
  			fragCount = fragCount + count
  		end

  		local sellEffect = itemData.sell_effect:toArray(true, "=")
  		reward[sellEffect[1]] = (reward[sellEffect[1]] or 0) + sellEffect[2] * count
  	end	
  	
  	role:costItems(backs)
  	local reward = role:award(reward)

  	role:checkTaskEnter("DecoFrag", {count = fragCount})

  	SendPacket(actionCodes.Role_saleItemRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  
  function _M.openItemRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local itemId = msg.itemId
  	local count = msg.count
  	if math.illegalNum(count, 1, role:getItemCount(itemId)) then return end
  	local itemData = csvdb["itemCsv"][itemId]
  	if itemData.use_type ~= 2 then return end
  	local randomData = csvdb["item_randomCsv"][tonumber(itemData.use_effect)]

  	if not randomData or randomData.openTime > 0 then return end

  
  	local reward = randomData.gift:toNumMap()
  	for _id, _count in pairs(reward) do
  		reward[_id] = _count * count
  	end
  	if randomData.random_num > 0 and randomData.random_gift ~= "" then
  		for i = 1, count do
  			local pool = {}
  			for _, temp in ipairs(randomData.random_gift:toArray()) do
  				table.insert(pool, temp:toArray(true, "="))
  			end
  			local needCount = math.min(#pool, randomData.random_num)
  			for j = 1, needCount do
  				local idx = math.randWeight(pool, 3)
  				reward[pool[idx][1]] = (reward[pool[idx][1]] or 0) + pool[idx][2]
  				table.remove(pool, idx)
  			end
  		end
  	end

  	role:costItems({[itemId] = count})

  	reward = role:award(reward)

  	SendPacket(actionCodes.Role_openItemRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  

  function _M.openTimeBoxRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local oper = msg.oper  -- 操作 1 - 3
  	local slot = msg.slot  -- 位置 1 - 6
  	if math.illegalNum(slot, 1, globalCsv.box_timeOpen_maxNum) then return end
  
  	local boxL = role:getProperty("boxL")
  	local reward
  	if oper == 1 then	-- 打开
  		local itemId = msg.itemId
  		if role:getItemCount(itemId) < 1 then return end
  		local itemData = csvdb["itemCsv"][itemId]

  		local randomData = csvdb["item_randomCsv"][itemId]

  		if not randomData or randomData.openTime <= 0 then return end
  
  		if boxL[slot] then return end
  		role:costItems({[itemId] = 1})
  		boxL[slot] = {id = itemId, time = skynet.timex() + randomData.openTime}
  		
  	elseif oper == 2 then -- 上宝石
  		local gemId = msg.gem or 0
  		if not boxL[slot] then return end
  		if boxL[slot].gem or boxL[slot].time <= skynet.timex() then return end
  		local itemData = csvdb["itemCsv"][boxL[slot].id]

  		local randomData = csvdb["item_randomCsv"][itemId]

  		local num = randomData[gemId .. "_gem_num"] 
  		if not num then return end

  		if not role:checkItemEnough({[gemId] = 1}) then return end
  		role:costItems({[gemId] = 1})

  		boxL[slot].gem = gemId
  	elseif oper == 3 then -- 领取
  		local quick = msg.quick
  		if not boxL[slot] then return end
  		if boxL[slot].time > skynet.timex() then -- 没开完
  			if not quick then return end

  			local cost_pre = globalCsv.box_timeOpen_diamond:toArray(true, "=")

  			local costD = math.ceil((boxL[slot].time - skynet.timex()) / (cost_pre[1] * 60)) * cost_pre[2]
  			if not role:checkItemEnough({[ItemId.Diamond] = costD}) then return end
  			role:costItems({[ItemId.Diamond] = costD})
  		end

  		local itemData = csvdb["itemCsv"][boxL[slot].id]

  		local randomData = csvdb["item_randomCsv"][itemId]

  		reward = randomData.gift:toNumMap() -- 固定奖励
  		-- 随机奖励
  		local randomGift = randomData.random_gift

  		local randomNum = randomData.random_num

  		if boxL[slot].gem then

  			randomNum = randomData[boxL[slot].gem .. "_gem_num"]

  			randomGift = randomData[boxL[slot].gem .. "_gem_gift"]
  		end

  
  		if randomNum > 0 and randomGift and randomGift ~= "" then

  			local pool = {}
  			for _, temp in ipairs(randomGift:toArray()) do
  				table.insert(pool, temp:toArray(true, "="))
  			end

  			local needCount = math.min(#pool, randomNum)

  			for j = 1, needCount do
  				local idx = math.randWeight(pool, 3)
  				reward[pool[idx][1]] = (reward[pool[idx][1]] or 0) + pool[idx][2]
  				table.remove(pool, idx)
  			end
  		end
  
  
  		boxL[slot] = nil
  		reward = role:award(reward)

  		role:checkTaskEnter("OpenBox")

  	else
  		return
  	end
  

  	role:setProperty("boxL") --刷新
  	role:changeUpdates({{type = "boxL", field = slot, value = boxL[slot], isOnlyToC = true}}) -- 通知客户端

  	SendPacket(actionCodes.Role_openTimeBoxRpc, MsgPack.pack({reward = reward}))

  	return true

  end
  

  function _M.storyBookRewardRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local storyId = msg.id
  	local storyBookData = csvdb["story_bookCsv"][storyId]
  	if not storyBookData then return end

  	local storyStatus = role:getProperty("storyB")

  	if not storyStatus[storyId] or not storyStatus[storyId].s or storyStatus[storyId].s ~= 1 then 

  		return 
  	end

  	-- 获取奖励

  	storyStatus[storyId].s = -1

  	role:changeUpdates({{ type = "storyB", field = storyId, value = storyStatus[storyId] }})

  	local reward = role:award(storyBookData.gift)
  	SendPacket(actionCodes.Role_storyBookRewardRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  

  function _M.unLockStoryBookRpc(agent, data)

  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local storyId = msg.id
  	local storyBookData = csvdb["story_bookCsv"][storyId]
  	if not storyBookData or storyBookData.lockItem == "" then return end -- 不能解锁
  
  	local storyStatus = role:getProperty("storyB")
  	if storyStatus[storyId] and storyStatus[storyId].s then return end  --不需要解锁
  
  	local cost = storyBookData.lockItem:toNumMap()
  	if not cost or not next(cost) then return end
  	if not role:checkItemEnough(cost) then return end  -- 消耗品不足
  
  	role:costItems(cost)
  
  	-- 解锁
  	storyStatus[storyId] = storyStatus[storyId] or {}
  	table.clear(storyStatus[storyId])
  	storyStatus[storyId].s = 1
  	role:changeUpdates({{ type = "storyB", field = storyId, value = storyStatus[storyId] }})
  	SendPacket(actionCodes.Role_unLockStoryBookRpc, '')
  	return true

  end
  

  function _M.taskRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local taskType = msg.type -- 1 日常 2 周长
  	local taskId = msg.id --任务id
  	local roleField = {"dTask", "wTask"}
  	if not roleField[taskType] then return 1 end
  
  	local taskData = csvdb["task_loopCsv"][taskType][taskId]
  	if not taskData then return 2 end
  
  	local taskStatus = role:getProperty(roleField[taskType])
  	local tStatus = taskStatus["t"] or {}
  
  	if (tStatus[taskId] or 0) < taskData.condition1 then
  		return 3
  	end
  
  	local reward = role:award(taskData.reward)
  	local active = (taskStatus["a"] or 0) + taskData.active
  
  	role:changeUpdates({
  		{ type = roleField[taskType], field = {"t", taskId}, value = -1 },
  		{ type = roleField[taskType], field = "a", value = active}
  	})
  
  	SendPacket(actionCodes.Role_taskRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  
  function _M.taskActiveRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local taskType = msg.type -- 1 日常 2 周长
  	local taskId = msg.id --任务id
  	local roleField = {"dTask", "wTask"}
  	if not roleField[taskType] then return end
  
  	local taskData = csvdb["task_activeCsv"][taskType][taskId]
  	if not taskData then return end
  
  	local taskStatus = role:getProperty(roleField[taskType])
  	local tStatus = taskStatus["at"] or {}
  
  	if tStatus[taskId] == -1 or (taskStatus["a"] or 0) < taskData.active then
  		return
  	end
  
  	local reward = role:award(taskData.reward)
  	role:changeUpdates({
  		{ type = roleField[taskType], field = {"at", taskId}, value = -1 }
  	})
  	
  	SendPacket(actionCodes.Role_taskActiveRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  
  function _M.achiveRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local taskId = msg.id --任务id
  
  	local achiveTask = csvdb["achievementCsv"][taskId]
  	if not achiveTask then return end
  
  	local achiveT = role:getProperty("achiveT")
  	local achiveV = role:getProperty("achiveV")
  

  	if achiveV[taskId] then return end

  
  	local curStatus = achiveT[achiveTask.type] or 0
  	local maxc = achiveTask.condition1
  
  	if maxc > curStatus then
  		return 
  	end
  
  	local reward = role:award(achiveTask.reward)
  
  	role:changeUpdates({

  		{ type = "achiveV", field = taskId, value = skynet.timex() }

  	})
  	
  	SendPacket(actionCodes.Role_achiveRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  

  function _M.chatRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  
  	local cmd = msg.cmd
  	local content = msg.content
  
  	if not content then return end
  
  	local now = skynet.timex()
  	-- 判断禁言
  	local result = nil
  
  	local SERV = string_format("CHATED%d", math.random(1, 5))
  	local legal, mod = skynet.call(SERV, "lua", "check", content)
  	if not legal then
  		content = mod or ""
  	end
  
  	if content == "" then
  		result = -1
  	end
  
  	local response = {
  		chatType = cmd,
  		player = {
  			roleId = role:getProperty("id"),
  			name = role:getProperty("name"),
  			level = role:getProperty("level"),
  			headId = role:getProperty("headId"),
  		},
  		content = content,
  		time = now,
  	}
  

  
  	local waitTime = nil
   	local check = {
  		-- 世界聊天
  		[1] = function ()

  			if role:getProperty("silent") > now then  --禁言
  				result = 1
  				return
  			end

  
  			role._worldChatLimit = role._worldChatLimit or {start = 0, count = 0, canSayt = 0}  --第一次开始说话时间  从第一次说话次数  能说话的时间
  
  			if now < role._worldChatLimit.canSayt then
  				result = 2
  				waitTime = canSayt - now
  				return
  			end
  
  			if now - role._worldChatLimit.start >= globalCsv.chat_world_limit.time then
  				role._worldChatLimit.start = now
  				role._worldChatLimit.count = 1
  			else
  				role._worldChatLimit.count = role._worldChatLimit.count + 1
  				if role._worldChatLimit.count > globalCsv.chat_world_limit.count then
  					role._worldChatLimit.count = 0
  					role._worldChatLimit.start = 0
  					role._worldChatLimit.canSayt = now + globalCsv.chat_world_limit.wait
  					result = 2
  					waitTime = globalCsv.chat_world_limit.wait
  					return
  				end
  			end
  			

  			mcast_util.pub_world(actionCodes.Role_chat, MsgPack.pack(response))
  			pcall(skynet.call, 'GLOBALD', "lua", "sendWorldMsg", role._channelIdx, response)
  		end,

  		-- 私聊
  		[2] = function ()
  			local objectId = msg.roleId
  
  			if 0 == redisproxy:exists(string.format("role:%d", objectId)) then
  				result = 1
  				return
  			end
  
  			-- 若在线，实时发送聊天信息

  			local agent = datacenter.get("agent", objectId)

  			local bin = MsgPack.pack(response)

  			if agent then
  				SendPacket(actionCode, bin, agent.fd)
  			else
  				redisproxy:pipelining(function(red)
  					red:rpush(CHAT_OFFLINE:format(objectId), bin)
  					red:ltrim(CHAT_OFFLINE:format(objectId), 0, 200)
  				end)
  			end

  			SendPacket(actionCode, bin, fromFd)

  		end,
  	}
  	if not check[cmd] then return end
  	
  	if not result then
  		check[cmd]()
  	end

  	SendPacket(actionCodes.Role_chatRpc, MsgPack.pack({result = result, waitTime = waitTime}))

  	return true
  end
  

  return _M