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.codeVersion ~= globalCsv.codeVersion 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()
		role:startActionUcode()
		role:setProperty("ltime", now)
	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(true) -- 冒险赛季更新检查

	-- 跨天登陆事件
	role:updateTimeReset(now)
	redisproxy:zadd(FRIEND_RECOMMEND, now, roleId)

	for _, name in ipairs({"dailyData", "dinerData"}) 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

	

	-- 注册全服广播
	if not role._channelIdx then
		local channel = math.randomInt(1, 1)
		role._channelIdx = channel
	end
	if not mcast_util.channel_world() then
		local w_channel = datacenter.get( ("MC_W_CHANNEL" .. role._channelIdx) )
		if w_channel then
			mcast_util.sub_world(w_channel)
		end
	end

	-- 发下缓存的世界消息
	local worldChatResponse = {worldChats = {}}
	local ok, msgs = pcall(skynet.call, '.globald', "lua", "getWorldMsg", role._channelIdx)
	if not ok then 
		msgs = {} 
	end
	worldChatResponse.worldChats = msgs
	local redret = redisproxy:pipelining(function(red)
		red:lrange(CHAT_OFFLINE:format(roleId), 0, -1)
		red:del(CHAT_OFFLINE:format(roleId))
	end)
	worldChatResponse.p2pChats = redret[1]
	worldChatResponse.chatWave = curWave + 1
	curWave = curWave + 1

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

	datacenter.set("agent", roleId, {
		serv = skynet.self(),
		fd = agent.client_fd,
		gate_serv = agent.gate_serv,
	})
	agent.role = role

	start_agent_timer()


	-- 玩家登陆做的一些操作
	role:saveHangTeam()
	role:savePvpCTeam()
	role:savePvpHTeam()

	local hangPass = role:getProperty("hangPass")
	role:log("login", {key1 = agent.ip:toArray(false, ":")[1], int1 = hangPass[1] or 0})
	
	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),
		sid = 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
	newRole:startActionUcode()
	newRole:award(globalCsv.birthItem, {log = {desc = "birth"}, notNotify = true})
	-- 欢迎邮件
	redisproxy:insertEmail({roleId = roleId, emailId = 1})

	newRole:log("create", {key1 = agent.ip:toArray(false, ":")[1]})

	SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
	return true
end

function _M.changeNameRpc(agent, data)
	local role = agent.role
	local roleId = role:getProperty("id")
	local msg = MsgPack.unpack(data)

	local newName = msg.name
	local oldName = role:getProperty("name")

	if not newName or type(newName) ~= "string" then return end
	if newName == oldName then return end
	-- 检查name是否合法
	local checked = validName(newName)
	if checked ~= "ok" then
		--[[
			"existed" 已经存在
			"illegal" 包含非法字符
		]]
		local errCodes = {
			["existed"] = 1,
			["illegal"] = 2
		}
		SendPacket(actionCodes.Role_changeNameRpc, MsgPack.pack({result = errCodes[checked]}))
		return true
	end

	if not roleId then 
		SendPacket(actionCodes.Role_changeNameRpc, MsgPack.pack({result = 3}))
		return true
	end
	local dbName = string.upper(newName)
	local result = redisproxy:setnx(string_format("user:%s", dbName), roleId)
	if result == 0 then
		SendPacket(actionCodes.Role_changeNameRpc, MsgPack.pack({result = 1}))
		return true
	end
	redisproxy:pipelining(function (red)
		red:del(string_format("user:%s", string.upper(oldName)))
		red:set(string_format("uid:%s", role:getProperty("uid")), dbName)
	end)

	role:updateProperties({
		["name"] = newName,
	})

	role:changeCrossServerPvpSelfInfo("name")
	SendPacket(actionCodes.Role_changeNameRpc, MsgPack.pack({result = 0}))
	return true
end

function _M.getRandomNameRpc()
	local name = randomRoleName()
	SendPacket(actionCodes.Role_getRandomNameRpc, MsgPack.pack({name = name}))
	return true
end

function _M.changeIntroRpc(agent, data)
	local role = agent.role
	local roleId = role:getProperty("id")
	local msg = MsgPack.unpack(data)
	local content = msg.content
	if not content or type(content) ~= "string" then return end

	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

	role:updateProperty({field = "intro", value = content})
	
	SendPacket(actionCodes.Role_changeIntroRpc, '')
	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, {log = {desc = "saleItem"}})
	local reward = role:award(reward, {log = {desc = "saleItem"}})
	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 = {}
	for _i = 1, count do
		for i = 1, 10 do
			local num = randomData["num" .. i] 
			local gift = randomData["gift" .. i]
			if num and gift and num > 0 and gift ~= "" then
				local pool = {}
				for _, temp in ipairs(gift:toArray()) do
					table.insert(pool, temp:toArray(true, "="))
				end
				local needCount = math.min(#pool, 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
	end
	reward[0] = nil

	role:costItems({[itemId] = count}, {log = {desc = "openItem"}})
	reward = role:award(reward, {log = {desc = "openItem", int1 = itemId, int2 = count}})

	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 - 2
	local slot = msg.slot  -- 位置 1 - 6
	if math.illegalNum(slot, 1, role:getFuncLv(FuncOpenType.TimeBoxSlot)) 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 itemData or not randomData or randomData.openTime <= 0 then return end

		if boxL[slot] then return end
		role:costItems({[itemId] = 1}, {log = {desc = "openTimeBox"}})
		boxL[slot] = {id = itemId, time = skynet.timex() + randomData.openTime}

	elseif oper == 2 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.BoxKey] = costD}) then return end
			role:costItems({[ItemId.BoxKey] = costD}, {log = {desc = "openTimeBox"}})
		end
		local boxId = boxL[slot].id
		local itemData = csvdb["itemCsv"][boxId]
		local randomData = csvdb["item_randomCsv"][itemData.id]
		-- 随机奖励
		reward = {}
		for i = 1, 10 do
			local num = randomData["num" .. i] 
			local gift = randomData["gift" .. i]
			if num and gift and num > 0 and gift ~= "" then
				local pool = {}
				for _, temp in ipairs(gift:toArray()) do
					local set = temp:toArray(true, "=")
					table.insert(pool, set)
				end

				local needCount = math.min(#pool, 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
		reward[0] = nil

		boxL[slot] = nil
		reward = role:award(reward, {log = {desc = "openTimeBox", int1 = boxId}})
		role:checkTaskEnter("OpenBox", {id = boxId})
	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.openSpeedUpBoxRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)

	local id = msg.id
	local count = msg.count
	local itemData = csvdb["itemCsv"][id]
	if not itemData or itemData.type ~= ItemType.SpeedBox then return end

	if math.illegalNum(count, 1, role:getItemCount(id)) then return end
	local useType, hour = table.unpack(itemData.use_effect:toArray(true, "="))
	local time = hour * 60 * 60

	local reward = {}
	if useType == 1 then -- 挂机齿轮
		local hangInfo = role:getProperty("hangInfo")
		if not hangInfo.carbonId then
			return
		end
		local carbonData = csvdb["idle_battleCsv"][hangInfo.carbonId]
		reward[ItemId.Gold] = math.floor(time / globalCsv.idle_money_produce_cd) * carbonData.money * count
	elseif useType == 2 then -- 挂机经验
		local hangInfo = role:getProperty("hangInfo")
		if not hangInfo.carbonId then
			return
		end
		local carbonData = csvdb["idle_battleCsv"][hangInfo.carbonId]
		reward[ItemId.Exp] = math.floor(time / globalCsv.idle_money_produce_cd) * carbonData.exp * count
	elseif useType == 3 then  -- 食材商人收入
		local buildType = 6
		local level = role.dinerData:getProperty("buildL"):getv(buildType, 1)
		local buildingData = csvdb["diner_buildingCsv"][buildType][level]
		if not buildingData then
			return 1
		end
		local gfood = role.dinerData:getProperty("gfood")
		if not next(gfood) then return end
		for k , v in pairs(gfood) do
			local itemId = v.id
			local speed = globalCsv.diner_get_food_speed[csvdb["itemCsv"][itemId].quality] * buildingData.speed / 100
			reward[itemId] = math.floor(time / speed) * count
		end
	else
		return
	end

	role:costItems({[id] = count}, {log = {desc = "speedUpBox"}})
	reward = role:award(reward, {log = {desc = "speedUpBox"}, int1 = id, int2 = count})

	SendPacket(actionCodes.Role_openSpeedUpBoxRpc, 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, {log = {desc = "storybookReward", int1 = storyId}})
	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, {log = {desc = "unlockStory", int1 = storyId}})

	-- 解锁
	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)

	if not role:isFuncUnlock(FuncUnlock.TaskAchiv) then return end

	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, {log = {desc = "finishTask", int1 = taskType, int2 = taskId}})
	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)

	if not role:isFuncUnlock(FuncUnlock.TaskAchiv) then return end

	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, {log = {desc = "taskActive", int1 = taskType, int2 = taskId}})
	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

	if not role:isFuncUnlock(FuncUnlock.TaskAchiv) then return end
	
	local achiveTask = csvdb["achievementCsv"][taskId]
	if not achiveTask then return 1 end

	local achiveT = role:getProperty("achiveT")
	local achiveV = role:getProperty("achiveV")

	if achiveV[taskId] then return 2 end

	local curStatus = achiveT[achiveTask.type] or 0
	local maxc = achiveTask.condition1

	if maxc > curStatus then
		return 3
	end

	local reward = role:award(achiveTask.reward, {log = {desc = "finishAchive", int1 = taskId}})
	role:changeUpdates({
		{ type = "achiveV", field = taskId, value = skynet.timex() }
	})

	-- 复兴奖励
	if csvdb["achievement_groupCsv"][achiveTask.group].bookmark == 3 then
		local overCount = 0
		for tId, status in pairs(achiveV) do
			local tData = csvdb["achievementCsv"][tId]
			if tData then
				local groupData = csvdb["achievement_groupCsv"][tData.group]
				if groupData.bookmark == 3 then
					overCount = overCount + 1
				end
			end
		end

		for level, pData in pairs(csvdb["achievement_rewardCsv"]) do
			if pData.request == overCount then
				-- 发放奖励
				redisproxy:insertEmail({
					roleId = role:getProperty("id"), 
					emailId = 101,
					attachments = pData.reward,
					contentPms = {pData.level},
				})
			elseif pData.request > overCount then
				 break
			end
		end
	end
	
	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 = role._worldChatLimit.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.send, '.globald', "lua", "sendWorldMsg", role._channelIdx, response)
		end,
		-- 私聊
		[2] = function ()
			local objectId = msg.roleId
			response.objId = objectId
			local redret = redisproxy:pipelining(function(red)
				red:exists(string.format("role:%d", objectId))
				red:sismember(FRIEND_BLACK_KEY:format(roleId), objectId)
				red:sismember(FRIEND_BLACK_KEY:format(objectId), roleId)
			end)
			if redret[1] ~= 1 then
				result = 1	
				return
			end
			-- 你把对方拉黑拉黑
			if redret[2] == 1 then
				result = 2
				return
			end
			-- 对方把你拉黑
			local isBlock = redret[3] == 1

			local bin = MsgPack.pack(response)
			if not isBlock then
				redisproxy:pipelining(function(red)
					red:rpush(CHAT_OFFLINE:format(objectId), bin)
					red:ltrim(CHAT_OFFLINE:format(objectId), -200, -1)
				end)
				-- 若在线，实时发送聊天信息
				local agent = datacenter.get("agent", objectId)
				if agent then
					SendPacket(actionCodes.Role_chat, bin, agent.fd)
				end
			end
			SendPacket(actionCodes.Role_chat, bin)
		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

function _M.chatGet(agent, data)
	local role = agent.role
	local roleId = role:getProperty("id")
	redisproxy:del(CHAT_OFFLINE:format(roleId))
	return true
end


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

	local id = msg.id
	local status = msg.status

	local statusEnum = SettingStatus[id]
	if not statusEnum then return 1 end

	if not statusEnum[status] then return 2 end

	local setting = role:getProperty("setting")
	setting[id] = status
	role:updateProperty({field = "setting", value = setting})

	role:log("role_action", {desc = "changeSetting", int1 = id, int2 = status})

	SendPacket(actionCodes.Role_changeSettingRpc,  '')
	return true
end

function _M.drawCodeRpc(agent, data)
	local msg = MsgPack.unpack(data)
	local codeurl = skynet.getenv("codeurl")
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local code = msg.code

	if type(code) ~= "string" then return end
	if code:find("[^0-9a-zA-Z]") then return end

	local codestr = role:getProperty("codeStr")
	local content = {
		["platformId"] = role:getProperty("sid"),
		["code"] = code,
		["itemIds"] = codestr,
		["key"] = "zhaolugame20170831",
	}
	local status, body = httpc.get(codeurl, "/libaoma?" .. httpGetFormatData(content), {})
	if status == 200 then
		local result = json.decode(body)
		local ret = tonum(result.ret)
		if ret == 0 then
			local giftId = tonumber(result.giftId)
			role:setProperty("codeStr", codestr:setv(giftId, 1))
			local reward = role:award(result.gift, {log = {desc = "drawCode", key1 = code, int1 = giftId}})
			
			SendPacket(actionCodes.Role_drawCodeRpc, MsgPack.pack({
				result = ret,
				reward = reward,
			}))
			return true
		end
        -- 1 不存在的礼包码
        -- 2 已经领取过相同类型物品
        -- 3 领取数量达到上限
        -- 4 过期了
		SendPacket(actionCodes.Role_drawCodeRpc, MsgPack.pack({result = ret}))
		return true
	end
	SendPacket(actionCodes.Role_drawCodeRpc, MsgPack.pack({result = -1}))
	return true
end

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

	local id = msg.id
	local icon = csvdb["player_iconCsv"][id]
	if not icon then
		return
	end

	local unlock = false
	if role:getItemCount(id) >= 1 then
		unlock = true
	else
		if icon.path == 1 then -- 获得对应英雄
			if role:isHaveHero(icon.condition) then
				unlock = true
			end
		end
	end
	if not unlock then 
		return
	end
	role:changeHead(id)

	SendPacket(actionCodes.Role_changeHeadRpc, "")
	return true
end

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

	local cmdType = msg.cmdType

	local funcGuide = role:getProperty("funcGuide")
	local newerGuide = role:getProperty("newerGuide")
	if cmdType == 1 then
		-- 新手引导
		local master = msg.master or -1
		local slave = msg.slave or -1
		if master < 0 or slave < 0 then return end
		newerGuide = string.format("%d=%d",master,slave)
		role:updateProperty({field = "newerGuide", value = newerGuide})
		role:log("guide", {desc = "guide_new",int1 = master*1000+slave})
	elseif cmdType == 2 then
		-- 系统引导
		if not msg.skip then return end
		local new = math.min(funcGuide:getv(0, 0), msg.skip)
		if new < 0 then
			funcGuide = funcGuide:setv(0, new)
		else
			funcGuide = funcGuide:setv(0, funcGuide:getv(0, 0) + msg.skip)
		end
		
		if msg.funcType then
			funcGuide = funcGuide:setv(msg.funcType, 1)
			role:log("guide", {desc = "guide_sys", int1 = msg.funcType})
		end
		role:updateProperty({field = "funcGuide", value = funcGuide})
	elseif cmdType == 3 then
		-- 弱引导
		if msg.funcType then
			local value = msg.value or 1
			for _, funcIdx in pairs(msg.funcType:toArray(true,"=")) do
				role:log("guide", {desc = "guide_weak", int1 = funcIdx})
				funcGuide = funcGuide:setv(funcIdx, value)
			end
			role:updateProperty({field = "funcGuide", value = funcGuide})
		end
	else
		return
	end

	SendPacket(actionCodes.Role_guideRpc, "")
	return true
end

function _M.goldBuyRpc(agent, data)
	local role = agent.role
	local curT = role.dailyData:getProperty("goldBuyT")
	local costD = globalCsv.idle_quickMoney_cost[curT]
	if not costD then
		return 1
	end
	if costD ~= 0 and not role:checkItemEnough({[ItemId.Diamond] = costD}) then
		return 2
	end
	local goldC = 0
	local hangPass = role:getProperty("hangPass")
	for i = 1, 3 do
		if hangPass[i] then
			local carbonData = csvdb["idle_battleCsv"][hangPass[i]]
			goldC = math.max(goldC, carbonData.money * globalCsv.idle_quickMoney_effect)
		end
	end
	local carbonId = role:getProperty("hangInfo").carbonId
	if carbonId then
		local carbonData = csvdb["idle_battleCsv"][carbonId]
		goldC = math.max(goldC, carbonData.money * globalCsv.idle_quickMoney_effect)
	end
	if goldC == 0 then
		return 3
	end
	role.dailyData:updateProperty({field = "goldBuyT", value = curT + 1})
	role:costItems({[ItemId.Diamond] = costD}, {log = {desc = "goldBuy"}})
	local reward = role:award({[ItemId.Gold] = goldC}, {log = {desc = "goldBuy"}})
	SendPacket(actionCodes.Role_goldBuyRpc, MsgPack.pack({reward = reward}))
	return true
end

return _M