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")

require "utils.MysqlUtil"

local WAVE_HERO_NUMS = 150
local WAVE_RUNE_NUMS = 150
local WAVE_SPARK_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("%d", roleId)
		if not roleExists(roleId) 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()
	else
		role:reloadWhenLogin()
	end


	role.sysVersion = msg.sysVersion
	role.ip = agent.ip:toArray(false, ":")[1]
	role.clientVersion = msg.clientVersion
	role.network = msg.network

	if msg.subId then
		role:setProperty("sid", msg.subId)
	end

	if msg.deviceMode then
		local deviceMode = tostring(msg.deviceMode)
		if role:getProperty("dmode") ~= deviceMode then
			role:setProperty("dmode", deviceMode)
		end
	end
	if msg.device then
		local device = tostring(msg.device)
		if role:getProperty("device") ~= device then
			role:setProperty("device", device)
		end
	end
	if msg.token then
		role._pushToken = msg.token
	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

	if msg.deviceMode then
		local deviceMode = tostring(msg.deviceMode)
		if role:getProperty("dmode") ~= deviceMode then
			role:setProperty("dmode", deviceMode)
		end
	end
	if msg.device then
		local device = tostring(msg.device)
		if role:getProperty("device") ~= device then
			role:setProperty("device", device)
		end
	end
	
	SERV_OPEN = getDbCfgVal("server_info", "server_start", "str_value")

	role:changeStructVersion() -- 数据结构 版本更新
	role:getAdvData(true) -- 清掉不合格的数据
	role:advEndlessSeasonCheck(true) -- 冒险赛季更新检查
	role:checkSeaportTrade() -- 检查海港贸易季活动
	if not next(role:getProperty("workBattle")) then
		role:setProperty("workBattle", {round = math.floor((now - START_RESET_TIME) / 604800)})
	end

	-- 跨天登陆事件
	local resetMode = role:updateTimeReset(now)
	if not resetMode or not resetMode["CrossDay"] then -- 没有跨天
		role.activity:checkActivityStatus(now, false, false)
		role:log("onLogin")
	end

	redisproxy:zadd(FRIEND_RECOMMEND, now, roleId)

	for _, name in ipairs({"dailyData", "dinerData", "activity", "storeData"}) do
		response[name] = role[name]:data()
		--print("["..name.."]")
		--dump(response[name])
	end

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

	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

	local sparkIds = {}
	for id ,_ in pairs(role.sparkBag) do
		table.insert(sparkIds, id)
	end 
	local sparkWave = math.ceil(#sparkIds / WAVE_SPARK_NUMS)
	if #sparkIds <= 50 then
		sparkWave = 0
		table_insert(modules, "sparkBag")
	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 + sparkWave + 1

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

	local curWave = 1 

	local sparkIndex = 1
	for index = curWave + 1, curWave + sparkWave do
		local sparkResponse = {sparkBag = {}}
		for i = sparkIndex, sparkIndex + WAVE_SPARK_NUMS do
			local sparkId = sparkIds[i]
			if not sparkId then
				break
			end
			local spark = role.sparkBag[sparkId]
			table.insert(sparkResponse.sparkBag, spark:data())
			sparkIndex = sparkIndex + 1
		end
		sparkResponse.sparkWave = index
		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(sparkResponse))
	end
	curWave = curWave + sparkWave

	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 online = datacenter.get("onlineCount") or 0
        local channel = math.floor(online / 500) + 1
		--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)
	local ok, msgs = true, {}
	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:updateHangTeamInfo()
	role:savePvpCTeam()
	role:savePvpHTeam()

	local hangPass = role:getProperty("hangPass")
	role:mylog("login", {key1 = agent.ip:toArray(false, ":")[1], int1 = hangPass[1] or 0})
	role:onUploadLoginout(1, agent.client_fd)

	-- 是否是新设备
	local deviced = cluster.query("center", "deviced")
	if deviced then
		local status, back = pcall(cluster.call, "center", deviced, "isNewDevice", {device = msg.device})
		if status and back  then
			role:mylog("newdevice", {key1 = agent.ip:toArray(false, ":")[1]})
		end
	end

	-- 临时处理方式，清空电台活动队伍
		local radioTask = role:getProperty("radioTask")
		for id, data in pairs(radioTask) do
			if (data["actid"] or 0) ~= 0 then
				radioTask[id] = nil
			end
		end
	---

	return true
end

local function onCb1Back(newRole)
	-- cb1活跃返利
    skynet.timeout(0, function()
		local cbbackd = cluster.query("center", "cb1backd")
		local uid = newRole:getProperty("uid")
		local roleId = newRole:getProperty("id")
		local start = uid:find("_")
		if start then
			uid = uid:sub(start + 1)
		end
		if cbbackd then
			local status, back = pcall(cluster.call, "center", cbbackd, "getCb1Reward", {uid = uid, id = roleId})
			if status then
				if back then
                    if back == 0 then
						mysqlproxy:insertEmail({roleId = roleId, emailId = MailId.CB1BackAward1, createtime = skynet.timex()})
                    elseif back == 1 then
						mysqlproxy:insertEmail({roleId = roleId, emailId = MailId.CB1BackAward2, createtime = skynet.timex()})
                    end
					newRole:mylog("cb1back", {key1 = uid, int2 = roleId, int1=back})
				end
			else
				skynet.error("[ERROR] cb1backd cant call center uid: " .. uid .. " roleId:" .. roleId)
			end
		else
			skynet.error("[ERROR] cb1backd cant call center uid: " .. uid .. " roleId:" .. roleId)
		end
    end)
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))
	local res, user = roleUidExists(uid)
	if user then
		response.result = "SUCCESS"
		response.roleName = user
		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
		return true
	end
	local stopcreate = tonumber(redisproxy:hget("autoincrement_set", "stopcreate"))
	if stopcreate and stopcreate > 0 then
		response.result = "STOP_CREATE"
		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("%d", roleId),
		id = roleId,
		uid = tostring(msg.uid),
		sid = msg.subId or 0,
		name = roleName,
		uname = msg.uname or "",
		device = tostring(msg.device),
		dmode = msg.deviceMode and tostring(msg.deviceMode) or nil
	})

	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:loadRoleIncre()
	newRole:startActionUcode()
	newRole.sysVersion = msg.sysVersion
	newRole.ip = agent.ip:toArray(false, ":")[1]
	newRole.clientVersion = msg.clientVersion
	newRole.network = msg.network

	newRole:award(globalCsv.birthItem, {log = {desc = "birth"}, notNotify = true})
	-- 欢迎邮件
	--mysqlproxy:insertEmail({roleId = roleId, emailId = 1})
	newRole:sendMail(1)

	if msg.newuser then
		newRole:log("onCreateAccount")
	end
	newRole:log("onCreateRole")
	newRole:mylog("create", {key1 = agent.ip:toArray(false, ":")[1]})

	-- 是否是新设备
	local deviced = cluster.query("center", "deviced")
	if deviced then
		local status, back = pcall(cluster.call, "center", deviced, "isNewDevice", {device = msg.device})
		if status and back  then
			newRole:mylog("newdevice", {key1 = agent.ip:toArray(false, ":")[1]})
		end
	end

	-- 整体保存一次
	newRole:update()

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

	-- cb付费返利
	skynet.timeout(0, function()
		local cbbackd = cluster.query("center", "cbbackd")
		local uid = newRole:getProperty("uid")
		local start = uid:find("_")
		if start then
			uid = uid:sub(start + 1)
		end
		if cbbackd then
			local status, back = pcall(cluster.call, "center", cbbackd, "getCbBack", {uid = uid, id = roleId})
			if status then
				if back and next(back) and back.reward and next(back.reward) then
					local reward = ""
					for itemId, count in pairs(back.reward) do
						reward = reward:setv(itemId, count)
					end
					if back.reward[70] then
						mysqlproxy:insertEmail({roleId = roleId, emailId = MailId.CBBackAward2, contentPms = {back.money}, createtime = skynet.timex(), attachments = reward})
					else
						mysqlproxy:insertEmail({roleId = roleId, emailId = MailId.CBBackAward, contentPms = {back.money}, createtime = skynet.timex(), attachments = reward})
					end
					newRole:mylog("cbback", {key1 = uid, int2 = roleId})
				end
			else
				skynet.error("[ERROR] cbbackd cant call center uid: " .. uid .. " roleId:" .. roleId)
			end
		else
			skynet.error("[ERROR] cbbackd cant call center uid: " .. uid .. " roleId:" .. roleId)
		end
	end)
	
    -- cb1活跃回馈
    onCb1Back(newRole)

	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.dinerData:updateRankRoleName(newName)
	role:updateTowerRankName(newName)
	role:updateAdvRankName(newName)

	role:changeCrossServerPvpSelfInfo("name")
	role:checkTaskEnter("Rename", {})
	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 or not next(backs) then return 0 end

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

	local reward = {}
	local fragCount = 0
	for itemId, count in pairs(backs) do
		local itemData = csvdb["itemCsv"][itemId]
		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

		role:log("carriage_decals", {
			item_id = itemId, --道具id
			item_type = itemData.type, --道具类型，具体见枚举表中道具类型枚举表
			item_level = 0, --道具等级
			item_number = count, --道具变化数量的绝对值
			carriage_decals_rwdid = sellEffect[1], --拆解获得物资ID
			carriage_decals_rwdnum = sellEffect[2] * count, --拆解获得物资数量
		})
	end	
	
	role:costItems(backs, {log = {desc = "saleItem"}})
	local reward, change = role:award(reward, {log = {desc = "saleItem"}})
	role:checkTaskEnter("DecoFrag", {count = fragCount})
	
	SendPacket(actionCodes.Role_saleItemRpc, MsgPack.pack(role:packReward(reward, change)))
	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 1 end
	local itemData = csvdb["itemCsv"][itemId]
	if itemData.use_type ~= 2 then return 2 end
	local randomData = csvdb["item_randomCsv"][tonumber(itemData.use_effect)]
	if not randomData or randomData.openTime > 0 then return 3 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"}})
	local change
	reward, change = role:award(reward, {log = {desc = "openItem", int1 = itemId, int2 = count}})

	SendPacket(actionCodes.Role_openItemRpc, MsgPack.pack(role:packReward(reward, change)))
	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

	-- 特权卡时间箱额外栏位
	-- local privExtraCnt = role.storeData:getTimeBoxSlotExtraCount()
	-- if oper == 1 then
	-- 	if math.illegalNum(slot, 1, role:getFuncLv(FuncOpenType.TimeBoxSlot) + privExtraCnt) then return end
	-- end

	local boxL = role:getProperty("boxL")
	local reward, change
	if oper == 1 then -- 构建开始(包括切换构建的id)
		local itemId = msg.itemId
		local itemData = csvdb["itemCsv"][itemId]
		if not itemData then return 1 end
		if not boxL[slot] then
			boxL[slot] = {}
		else
			local oldId, process, time = boxL[slot].id, boxL[slot].process, boxL[slot].time
			local unitTime = globalCsv.box_key_time[oldId] * 60
            unitTime = unitTime + role:getBnousDismantlingImproved(unitTime)
			local doneCnt = time == 0 and 0 or math.floor((process + skynet.timex() - time) / unitTime)
			if doneCnt > 0 then
				reward = role:award({[oldId] = doneCnt}, {log = {desc = "openTimeBox", int1 = slot, int2 = oper}})
			end
		end
		local limit = globalCsv.box_key_max[itemId] or 5
		if role:getItemCount(itemId) >= limit then return 3 end

		boxL[slot] = {id = itemId, process = 0, time = skynet.timex()}
		role:pushMsg({type = "box", slot = slot, time = skynet.timex() + globalCsv.box_productLine_time * 3600 + role:getBnousDismantlingMaximum()})
	elseif oper == 2 then -- 重置运行时间（可以使用加速）
		local quick = msg.quick
		if not boxL[slot] then return 4 end

		local itemId, process, time = boxL[slot].id, boxL[slot].process, boxL[slot].time
		local nowTime = skynet.timex()
		local stopTime = nowTime
		local itemData = csvdb["itemCsv"][itemId]
		local unitTime = globalCsv.box_key_time[itemId] * 60
		unitTime = unitTime + role:getBnousDismantlingImproved(unitTime)
		if quick then
			stopTime = nowTime + quick
			local cost_pre = globalCsv.box_timeOpen_diamond:toArray(true, "=")
			local costKey = math.ceil(quick / (cost_pre[1] * 60)) * cost_pre[2]
			if not role:checkItemEnough({[ItemId.Jade] = costKey}) then return 5 end
			role:costItems({[ItemId.Jade] = costKey}, {log = {desc = "openTimeBox", int1 = slot, int2 = oper}})
		else
			stopTime = math.min(nowTime,time + globalCsv.box_productLine_time * 3600 +  role:getBnousDismantlingMaximum())
		end

		role:pushCancel({type = "box", slot = slot})

		local doneCnt = math.floor((process + stopTime - time) / unitTime)
		if doneCnt > 0 then
			reward = role:award({[itemId] = doneCnt}, {log = {desc = "openTimeBox", int1 = slot, int2 = oper}})
		end
		if role:getItemCount(itemId) >= globalCsv.box_key_max[itemId] then
			nowTime = 0
		end

		boxL[slot] = {id = itemId, process = (process + stopTime - time) % unitTime, time = nowTime}
		role:pushMsg({type = "box", slot = slot, time = nowTime + globalCsv.box_productLine_time * 3600 + role:getBnousDismantlingMaximum()})
	elseif oper == 3 then -- 开箱子
		local costId = msg.costId
		local costs = (msg.costs or ""):toNumMap()
		if not costId or not csvdb["itemCsv"][costId] or not next(costs) then return 6 end

		local costIdData = csvdb["itemCsv"][costId]
		local count, runeCount = 0, 0
		for itemId, num in pairs(costs) do
			local itemIdData = csvdb["itemCsv"][itemId]
			local itemRandomData =  csvdb["item_randomCsv"][itemId]
			if not itemIdData or not itemRandomData or costIdData.quality ~= itemIdData.quality then return 7 end

            local itemRandomOccupy = role:getItemRandomOccupy(itemRandomData)
			if next(itemRandomOccupy) then
                runeCount = runeCount + (itemRandomOccupy[ItemOccupy.Rune] or 0) * num
			end
			count = count + num
		end

        if role:checkRuneFully(runeCount) then return 10 end --开箱子，如果铭文仓库已经满了则不让开铭文箱

		if role:getItemCount(costId) < count then return 8 end
		if not role:checkItemEnough(costs) then return 9 end

		role:costItems({[costId] = count}, {log = {desc = "openTimeBox"}})

		reward = {}
		for itemId, value in pairs(costs) do
			local tempReward = {}
			local randomData = csvdb["item_randomCsv"][itemId]
			local itemData = csvdb["itemCsv"][itemId]
			role:costItems({[itemId] = value}, {log = {desc = "openTimeBox"}})
			for _ = 1, value do
				for i = 1, 10 do
					local num = randomData["num" .. tostring(i)]
					local gift = randomData["gift" .. tostring(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)
							tempReward[pool[idx][1]] = (tempReward[pool[idx][1]] or 0) + pool[idx][2]
							table.remove(pool, idx)
						end
					end
				end
			end
			tempReward[0] = nil
			role:checkTaskEnter("OpenBox", {id = itemId, count=value, quality=itemData.quality})
			role:log("carriage_dismantle", {
				item_id = itemId, -- 道具id
				item_type = itemData.type, -- 道具类型，具体见枚举表中道具类型枚举表
				item_level = 0, -- 道具等级
				item_number = 1, -- 道具变化数量的绝对值
				carriage_dismantle_type = 1, -- 拆解方式，时间到期:0，钥匙开启:1
				carriage_dismantle_time = 0, -- 拆解耗时，填写实际耗时
				carriage_dismantle_cost = value, -- 拆解花费钥匙数量，未使用填写0
				carriage_dismantle_rwd = tempReward, -- 拆解获得物资，json格式记录，{'itemid1':2,'itemid2':3,…………..}
			})

			for id, num in pairs(tempReward) do
				reward[id] = (reward[id] or 0) + num
			end
		end
		reward, change = role:award(reward, {log = {desc = "openTimeBox", int1 = costId, int2 = oper}})
	else
		return
	end

	role:setProperty("boxL",boxL) --刷新
	if slot then
		role:changeUpdates({{type = "boxL", field = slot, value = boxL[slot], isOnlyToC = true}}) -- 通知客户端
	end
	SendPacket(actionCodes.Role_openTimeBoxRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

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

	local reward = {}
	for i = 1, #itemInfo do
		local pair = itemInfo[i]
		local id = pair[1]
		local count = pair[2]
		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 1 end
		local useType, hour = table.unpack(itemData.use_effect:toArray(true, "="))
		local time = hour * 60 * 60

		if useType == 1 then -- 挂机齿轮
			local hangInfo = role:getProperty("hangInfo")
			local expData = hangInfo.expData or {}
			--local carbonData = csvdb["idle_battleCsv"][hangInfo.expCarbonId]
			reward[ItemId.Gold] = (reward[ItemId.Gold] or 0) + math.floor(time / globalCsv.idle_money_produce_cd) * (expData.money or 0) * count
		elseif useType == 2 then -- 挂机经验
			local hangInfo = role:getProperty("hangInfo")
			local expData = hangInfo.expData or {}
			--local carbonData = csvdb["idle_battleCsv"][hangInfo.expCarbonId]
			reward[ItemId.Exp] = (reward[ItemId.Exp] or 0) + math.floor(time / globalCsv.idle_money_produce_cd) * (expData.exp or 0) * 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 4
			end
			local gfood = role.dinerData:getProperty("gfood")
			if not next(gfood) then return 5 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
				speed = speed + role:getBnousDiner(1,speed)
				reward[itemId] = (reward[itemId] or 0) + math.floor((time / speed) * count)
			end
		else
			return 6
		end

		role:costItems({[id] = count}, {log = {desc = "speedUpBox"}})
	end

	local doubleCoef = role.activity:isOpen("DoubleDrop") and 2 or 1
	-- 特权卡获取加速获得额外道具
	local coef = role.storeData:getProduceItemSpeedCoef()
	if coef > 1 or doubleCoef > 1 then
		for k, cnt in pairs(reward) do
			if k == ItemId.Gold or k == ItemId.Exp then
				reward[k] = math.floor(cnt * coef * doubleCoef)
			end
		end
	end

	local change
	reward, change = role:award(reward, {log = {desc = "speedUpBox"}})

	SendPacket(actionCodes.Role_openSpeedUpBoxRpc, MsgPack.pack(role:packReward(reward, change)))
	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 1 end
	local storyStatus = role:getProperty("storyB")

	local status = (storyStatus[storyId] or {}).s

	if status == -1 then 
		SendPacket(actionCodes.Role_storyBookRewardRpc, "")
		return true 
	end
	
	if not status or status ~= 1 then 
		--if storyBookData.unlockType == 1 and (role:getProperty("hangInfo").carbonId == tonumber(storyBookData.unlockData) or storyId == 1 or storyId == 2) then  -- 挂机剧情正在挂机也可以领奖
		if storyBookData.unlockType == 1 then  -- 挂机剧情正在挂机也可以领奖
		else
			return 3
		end
	end
	-- 获取奖励
	storyStatus[storyId] = storyStatus[storyId] or {}
	storyStatus[storyId].s = -1
	role:changeUpdates({{ type = "storyB", field = storyId, value = storyStatus[storyId] }})
	local reward, change = role:award(storyBookData.gift, {log = {desc = "storybookReward", int1 = storyId}})

	role:log("carriage_video", {
		carriage_video_type = storyBookData.type, --放映室类型，剧情CG:0, 角色CG:1, 主线剧情:2, 角色剧情:3, 活动剧情:4, 图鉴:5
		carriage_video_id = storyId, --放映室片段ID
		carriage_video_coinid = reward[ItemId.Jade] and ItemId.Jade or 0, --放映奖励货币类型，无奖励则填写0
		carriage_video_coinnum = reward[ItemId.Jade] or 0, --放映奖励货币数量，无奖励则填写0
		carriage_video_item = reward, --放映奖励其他物品数量，json格式记录，{'itemid1':10,'itemid2':5,…………..}，无奖励则填写0
	})

	SendPacket(actionCodes.Role_storyBookRewardRpc, MsgPack.pack(role:packReward(reward, change)))
	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  --不需要解锁

	if storyBookData.lockItem ~= "free" then
		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}})
	end

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

local function getTaskReward(role, taskId, roleField, taskType, taskData)
	if not taskData then return nil end

	local taskStatus = role:getProperty(roleField[taskType])
	local tStatus = taskStatus["t"] or {}

	if (tStatus[taskId] or 0) < taskData.condition1 then
		return nil
	end

	local reward, change = role:award(taskData.reward, {log = {desc = "finishTask", int1 = taskType, int2 = taskId}})
	local active = (taskStatus["a"] or 0) + taskData.active

	-- 日常活动完成
	if taskType == 1 then
		role:checkTaskEnter("DailyTask", {pre = (taskStatus["a"] or 0), cur = active})
		role:mylog("role_action", {desc="dayTask", int1=taskId, int2=active})
	else
		role:checkTaskEnter("WeekTask", {pre = (taskStatus["a"] or 0), cur = active})
		role:mylog("role_action", {desc="weekTask", int1=taskId, int2=active})
	end

	role:changeUpdates({
		{ type = roleField[taskType], field = {"t", taskId}, value = -1 },
		{ type = roleField[taskType], field = "a", value = active},
	})

	local oldVal = role:getProperty("battlePoint") or 0
	role:updateProperty({field = "battlePoint", value = oldVal + taskData.active})

	role:log("task_reward", {
		task_reward_id = taskId, --任务奖励ID
		task_reward_type = taskType, --任务奖励类型，见 任务奖励类型枚举表
		task_reward_detail = reward, --任务奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}
	})
	return reward, change
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 reward, change = {}, {}
	if not taskId then

		for id, taskData in pairs(csvdb["task_loopCsv"][taskType]) do
			local tmpreward, tmpchange = getTaskReward(role, id, roleField, taskType, taskData)
			if tmpreward then
				for k, v in pairs(tmpreward) do
					reward[k] = (reward[k] or 0) + v
				end
				if tmpchange then table.insert(change, tmpchange) end
			end
		end
	else
		local taskData = csvdb["task_loopCsv"][taskType][taskId]
		if not taskData then return 2 end
		reward, change= getTaskReward(role, taskId, roleField, taskType, taskData)
	end

	SendPacket(actionCodes.Role_taskRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end


local function getTaskActiveReward(role, taskId, roleField, taskType, taskData)
	local taskStatus = role:getProperty(roleField[taskType])
	local tStatus = taskStatus["at"] or {}

	if tStatus[taskId] == -1 or (taskStatus["a"] or 0) < taskData.active then
		return nil
	end

	local needReward = taskData.reward:toNumMap()
	if taskData.reward_2 ~= 0 then
		local day = weekday(skynet.timex())
		local workMainCsv = csvdb["work_mainCsv"][day]
		if workMainCsv then
			needReward[workMainCsv.ticket] = taskData.reward_2
		end
	end
	local reward, change = role:award(needReward, {log = {desc = "taskActive", int1 = taskType, int2 = taskId}})
	role:changeUpdates({
		{ type = roleField[taskType], field = {"at", taskId}, value = -1 }
	})

	role:log("task_reward", {
		task_reward_id = taskId * 100 + taskType, --任务奖励ID
		task_reward_type = 3, --任务奖励类型，见 任务奖励类型枚举表
		task_reward_detail = reward, --任务奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}
	})
    return reward, change
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 reward, change = {}, {}
	if not taskId then
		for id, taskData in pairs(csvdb["task_activeCsv"][taskType]) do
			local tmpreward, tmpchange = getTaskActiveReward(role, id, roleField, taskType, taskData)
			if tmpreward then
				for k, v in pairs(tmpreward) do
					reward[k] = (reward[k] or 0) + v
				end
				if tmpchange then table.insert(change, tmpchange) end
			end
		end
	else
		local taskData = csvdb["task_activeCsv"][taskType][taskId]
		if not taskData then return end
		reward, change= getTaskActiveReward(role, taskId, roleField, taskType, taskData)
	end

	SendPacket(actionCodes.Role_taskActiveRpc, MsgPack.pack(role:packReward(reward, change)))
	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 achiveT = role:getProperty("achiveT")
	local achiveV = role:getProperty("achiveV")
	local fuxRecord = role:getProperty("fuxR") or 0

	local groups = {}

	if not taskId then
		local awards = {}
		for id, cfg in pairs(csvdb["achievementCsv"]) do
			-- 没领过
			if not achiveV[id] then
				if (achiveT[cfg.type] or 0) >= cfg.condition1 then
					local award = cfg.reward:toNumMap()
					for k, v in pairs(award) do
						awards[k] = (awards[k] or 0) + v
					end
					achiveV[id] = skynet.timex()
					groups[cfg.group] = 1

					role:log("achievement", {
						achievement_id = cfg.id, -- 成就id
						achievement_type = cfg.type, -- 成就类型，具体枚举表中成就类型枚举表
						achievement_reward = award, -- 达成成就奖励，json格式记录，{"itemid1":123,"itemid2":12,……….}
					})

					role:mylog("role_action", {desc="finishAchieve", int1=cfg.id})
				end
			end
		end
		if not next(awards) then
			return 5
		end
		local reward, change = role:award(awards, {log = {desc = "finishAchive", int1 = 0}})
		role:updateProperty({field = "achiveV", value = achiveV})

		SendPacket(actionCodes.Role_achiveRpc, MsgPack.pack(role:packReward(reward, change)))
	else
		local achiveTask = csvdb["achievementCsv"][taskId]
		if not achiveTask then return 1 end

		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, change = role:award(achiveTask.reward, {log = {desc = "finishAchive", int1 = taskId}})
		role:changeUpdates({
			{ type = "achiveV", field = taskId, value = skynet.timex() }
		})
		groups[achiveTask.group] = 1

		role:log("achievement", {
			achievement_id = taskId, -- 成就id
			achievement_type = achiveTask.type, -- 成就类型，具体枚举表中成就类型枚举表
			achievement_reward = reward, -- 达成成就奖励，json格式记录，{"itemid1":123,"itemid2":12,……….}
		})
		role:mylog("role_action", {desc="finishAchieve", int1=taskId})

		SendPacket(actionCodes.Role_achiveRpc, MsgPack.pack(role:packReward(reward, change)))
	end
	
	for group, _ in pairs(groups) do
		-- 复兴奖励
		if csvdb["achievement_groupCsv"][group].bookmark == 3 then
			local overCount = 0
			local preMaxCount = fuxRecord or 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
			local flag = false
			for level, pData in pairs(csvdb["achievement_rewardCsv"]) do
				if preMaxCount < pData.request and overCount >= pData.request then
					role:sendMail(101, skynet.timex(), pData.reward, {pData.level})
					flag = true
					role:mylog("role_action", {desc="fux", int1=pData.level})
				end
			end
			if flag then
				role:updateProperty({field = "fuxR", value = overCount, notNotify = true})
			end
			break
		end
	end

	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 sdkResult
	if role:getProperty("sid") == UO_SID then
		sdkResult = role:uoChatSDK(content)
	else
		sdkResult = role:biliChatSDK(content)
	end

	if sdkResult then
		content = sdkResult
	else
		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
	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
			if role:getProperty("level") < (globalCsv.chat_level or 15) then
				result = 3
				return
			end

			local dailyChatTimes = role.dailyData:getProperty("chatTimes")
			if dailyChatTimes > (globalCsv.chat_world_day_limit or 15) then
				result = 4
				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
            if result == 1 then
                SendPacket(actionCodes.Role_chat, MsgPack.pack(response))
                result = 0
            else
                mcast_util.pub_world(actionCodes.Role_chat, MsgPack.pack(response))
            end
			dailyChatTimes = dailyChatTimes + 1
			role.dailyData:updateProperty({field="chatTimes", value=dailyChatTimes})
			-- pcall(skynet.send, '.globald', "lua", "sendWorldMsg", role._channelIdx, response)
			role:mylog("role_action", {desc = "chatWorld", text1 = content})
		end,
		-- 私聊
		[2] = function ()
			local objectId = msg.roleId
			response.objId = objectId
			local redret = redisproxy:pipelining(function(red)
				red:sismember(FRIEND_BLACK_KEY:format(roleId), objectId)
				red:sismember(FRIEND_BLACK_KEY:format(objectId), roleId)
			end)
			if not roleExists(objectId) then
				result = 1	
				return
			end
			-- 你把对方拉黑拉黑
			if redret[1] == 1 then
				result = 2
				return
			end
			-- 对方把你拉黑
			local isBlock = redret[2] == 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)

				if role:getProperty("silent") < now then  --禁言
					-- 若在线，实时发送聊天信息
					local agent = datacenter.get("agent", objectId)
					if agent then
						SendPacket(actionCodes.Role_chat, bin, agent.fd)
					end
				end
			end
			SendPacket(actionCodes.Role_chat, bin)
		end,
	}
	if not check[cmd] then return end
	
	if not result then
		check[cmd]()
	end

	role:log("communication", {
		publish_type = cmd, --发言类型，1，世界  2私聊 
		publish_status = 0, --发送状态，发送成功:0，发送失败:1，被屏蔽:2，其他:3
		publish_receive_roleid = msg.roleId or 0, --接收者角色ID
		publish_text = content, --发言内容
	})
	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:mylog("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 role = agent.role
	local code = msg.code

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

	local ret, reward = role:getCodeGift(code)
	if ret == 0 then
		SendPacket(actionCodes.Role_drawCodeRpc, MsgPack.pack({
			result = ret,
			reward = reward:toNumMap(),
		}))
        return true
	end

	SendPacket(actionCodes.Role_drawCodeRpc, MsgPack.pack({result = ret}))
	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")
	if cmdType == 1 then
		-- 新手引导
		if msg.masters then
			for _, master in pairs(msg.masters) do
				role:saveGuide(master,1,true)
			end		
		else
			local master = msg.master or -1
			local slave = msg.slave or -1
			if master < 0 or slave < 0 then return end
			role:saveGuide(master, slave)
		end
		
	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("onGuidePoint", {guild_type = 2, guild_id = msg.funcType, guild_point = 0, guild_pass = 0})
			role:mylog("guide", {desc = "guide_weak", int1 = msg.funcType})
		end
		role:updateProperty({field = "funcGuide", value = funcGuide})
	elseif cmdType == 3 then
		-- 系统引导（强制进行）
		if msg.funcType and csvdb["guide_unlockCsv"][msg.funcType] then
			role:saveGuide(csvdb["guide_unlockCsv"][msg.funcType].guideId,1)
			funcGuide = funcGuide:setv(msg.funcType, 1)
			role:updateProperty({field = "funcGuide", value = funcGuide})
			role:log("onGuidePoint", {guild_type = 1, guild_id = msg.funcType, guild_point = 0, guild_pass = 0})
			role:mylog("guide", {desc = "guide_sys", int1 = msg.funcType})
		end
	elseif cmdType == 4 then
		-- 弹出一个tips（进入功能界面也许要自动弹说明，value要区分1、2）
		if msg.funcType then
			local value = msg.value or 1
			for _, funcIdx in pairs(msg.funcType:toArray(true,"=")) do
				role:log("onGuidePoint", {guild_type = 3, guild_id = funcIdx, guild_point = 0, guild_pass = 0})
				role:mylog("guide", {desc = "guide_tips", 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 costs = clone(globalCsv.idle_quickMoney_cost)
	-- 增加今日齿轮加速次数
	local maxIdx = #globalCsv.idle_quickMoney_cost
	local maxCount = maxIdx + role:getBnousUpSpeedNum(UpSpeedType.GearUpSpeed)
	if curT > maxCount then return end
	if curT > maxIdx then
		for idx = maxIdx+1, curT do
			costs[idx] = costs[maxIdx]
		end
	end

	local costD = costs[curT]

	if not costD then
		return 1
	end
	if costD ~= 0 and not role:checkItemEnough({[ItemId.Jade] = costD}) then
		return 2
	end

    --特权卡倍数
	local goldC = 0
    local multiple = role.storeData:getGearExchangeCoef()

    local hangInfo = role:getProperty("hangInfo")
    local expCarbon_Data = hangInfo.expData or globalCsv.oriCarbonData
    goldC = expCarbon_Data.money * globalCsv.idle_quickMoney_effect * multiple

    if goldC == 0 then
		return 3
	end

	role.dailyData:updateProperty({field = "goldBuyT", value = curT + 1})
	role:costItems({[ItemId.Jade] = costD}, {log = {desc = "goldBuy"}})
	local reward, change = role:award({[ItemId.Gold] = math.floor(goldC)}, {log = {desc = "goldBuy"}})
	SendPacket(actionCodes.Role_goldBuyRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

function _M.diamondConvertRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	
	local oper = msg.oper
	if oper ~= 1 and oper ~= 2 then return 0 end

	local cost = math.ceil(msg.cost or 0)
	if cost <= 0 then return 1 end
	if role:getAllDiamond() < cost then return 2 end

	local get = globalCsv.legal_tender_cost * cost
	role:costDiamond({count = cost, log = {desc = "convert", int1 = oper, int2 = get}})
	local reward, change
	if oper == 1 then -- 钻石兑换成虹光玉
		reward, change = role:award({[ItemId.Jade] = get}, {log = {desc = "convert", short1=oper}})
	elseif oper == 2 then -- 钻石兑换成虹光玉再兑换成招募券
		local old = role:getItemCount(ItemId.Jade)
		get = old + get

		local quan = math.floor(get/globalCsv.recruit_cost)
		local remain = get - quan * globalCsv.recruit_cost

		local allReward = {}
		if remain > old then
			allReward[ItemId.Jade] = remain - old
			role:checkWorldChangePoints({[ItemWorldLine.CostJade]= quan * globalCsv.recruit_cost})
		elseif remain == old then
		else
			role:costItems({[ItemId.Jade] = old - remain}, {log = {desc = "convert", short1=oper}})
			role:checkWorldChangePoints({[ItemWorldLine.CostJade]= quan * globalCsv.recruit_cost - (old - remain)})
		end

		if quan > 0 then
			allReward[ItemId.RecruitmentCard] = quan
		end

		reward, change = role:award(allReward, {log = {desc = "convert"}})
	end

	SendPacket(actionCodes.Role_diamondConvertRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

function _M.getDownloadCvRewardRpc(agent, data)
	local role = agent.role
	local flag = role:getProperty("downCvR") or 0
	if flag ~= 0 then
		return 1
	end
	local r = globalCsv.role_download_cv_reward
	local reward, change = role:award(r, {log = {desc = "downloadCv"}})
	role:updateProperty({field="downCvR", value=1})
	SendPacket(actionCodes.Role_getDownloadCvRewardRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

function _M.updateFeedbackInfoRpc(agent, data)
	local role = agent.role
	local info = role:getProperty("feedback") or {}
	local msg = MsgPack.unpack(data)
	info["flag"] = msg.flag
	info["count"] = msg.count
	info["ts"] = skynet.timex()
	role:updateProperty({field="feedback", value=info})
	SendPacket(actionCodes.Role_updateFeedbackInfoRpc, MsgPack.pack({}))
	return true
end

function _M.useSelectItemRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local itemId = msg.itemId
	local subId = msg.subId
	local count = msg.count
	if math.illegalNum(count, 1, role:getItemCount(itemId)) then return end
	local itemData = csvdb["itemCsv"][itemId]
	if not (itemData.type == ItemType.SelectItemBox or itemData.type == ItemType.CommonPaster or itemData.type == ItemType.Stick) then return end
	local itemMap = itemData.use_effect:toNumMap()
	local reward, change = {}
	for k, v in pairs(itemMap) do
		if k == subId then
			reward[k] = v * count
			break
		end
	end

	if next(reward) then
		reward, change = role:award(reward, {log = {desc = "openItem", int1 = itemId, int2 = count}})
		role:costItems({[itemId] = count}, {log = {desc = "openItem"}})
	end
	SendPacket(actionCodes.Role_useSelectItemRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

function _M.renameTeamRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local title = msg.title
	local index = msg.index
	local ispve = msg.ispve
	if ispve then
		local teams = role:getProperty("hangTeams")
		local team = role:getTeamFormat(index)
		team.title = title
		teams[index] = team
		role:updateProperty({field = "hangTeams", value = teams, notNotify = false})
	else
		local teams = role:getProperty("advTeams")
		local team = role:getAdvTeamFormat(index)
		team.title = title
		teams[index] = team
		role:updateProperty({field = "advTeams", value = teams, notNotify = false})
	end

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

function _M.accuseRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local targetId = msg.targetId
	local atype = msg.type
	local note = msg.note

	role:mylog("role_action", {desc = "accuse", int1 = targetId, short1 = atype, text1 = note})
	SendPacket(actionCodes.Role_accuseRpc, "")
	return true
end

function _M.getTimeGiftRpc(agent, data)
	local role = agent.role

	local GiftCsv = csvdb["time_giftCsv"]
	local timeGift = role:getProperty("timeGift")
	if timeGift >= #GiftCsv then return 0 end

	local nextL = timeGift + 1
	local gift = GiftCsv[nextL]
	if not gift then return 1 end

	local createtime = role:getProperty("ctime")
	if skynet.timex() - createtime < gift.time then return 2 end

	role:updateProperty({field = "timeGift", value = nextL})
	local reward, change = role:award(gift.gift, {log = {desc = "giftTime", int1 = nextL}})
	role:mylog("role_action", {desc = "giftTime", int1 = nextL})

	SendPacket(actionCodes.Role_getTimeGiftRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

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

	local glodCount = globalCsv.rune_exchange * count
	if not role:checkItemEnough({[ItemId.Gold] = glodCount}) then return end
	role:costItems({[ItemId.Gold] = glodCount}, {log = {desc = "glodConvertRune", int1 = count, int2 = glodCount}})
	local reward, change = {}
	reward[ItemId.RuneFragment] = count
	reward, change = role:award(reward, {log = {desc = "glodConvertRune"}})
	SendPacket(actionCodes.Role_runeBuyRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

function _M.setFriendTeamRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
    local team = msg.team
    local info = {}
    info.team = role:getTeamHerosInfo(team)
    info.bInfo = role:getTeamBattleInfo(team)
    info.v = role:getTeamBattleValue(team.heros)
    role:updateProperty({field="friendTeam", value=info})

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

function _M.setBgRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
    role:updateProperty({field="bgId", value=msg.id})

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

function _M.itemConvertSpecialRpc(agent, data)
    local role = agent.role
	local msg = MsgPack.unpack(data)
    local itemId = msg.item_id
	local exchangeId = tonumber(msg.exchange_id)

    local itemData = csvdb["itemCsv"][itemId]
    if not itemData then return 1 end

	local rechargeData = csvdb["shop_rechargeCsv"][exchangeId]
	if not rechargeData then
		skynet.error("[recharge] recharge id not exist", exchangeId)
		return 2
	end

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

	local reward = {}

	if not role.storeData:checkRechargeRecord(rechargeData.limit, exchangeId)then
		return 5
	end

	if rechargeData.type == CardType.ActBattleCommandCard then
		if role.activity:isOpenById(rechargeData.activity_id, "ActShopGoods") then
			local tmpreward, _ = role.storeData:onBuyCard(rechargeData.type, rechargeData.time, rechargeData.id, rechargeData.activity_id)
			if tmpreward then
				table.rewardMerge(reward, tmpreward)
			end
		else
			skynet.error("not open id: ".. rechargeData.id .. "; actid: " .. rechargeData.activity_id)
			SendPacket(actionCodes.Role_itemConvertSpecialRpc, MsgPack.pack({result = 4}))
            return true
		end
	else
		local tmpreward, _ = role.storeData:onBuyCard(rechargeData.type, rechargeData.time, rechargeData.id, rechargeData.activity_id)
		if tmpreward then
			table.rewardMerge(reward, tmpreward)
		else
			return 6
		end
	end

	role:costItems({[itemId] = 1}, {log = {desc = "itemConvertSpecial", int1 = itemId, int2 = itemData.type}})

	SendPacket(actionCodes.Role_itemConvertSpecialRpc, MsgPack.pack(role:packReward(reward)))
    return true
end

function _M.worldLineRouletteRpc(agent, data)
	local role = agent.role

	local worldChangePoints = role:getProperty("worldChangePoints") or {}
    local rouletteCount =  worldChangePoints[ItemWorldLine.RouletteCount] or 0
	if rouletteCount == 0 then return 1 end

	local worldline_gift_base_10, worldline_gift_base_1, worldline_gift_magnification_1, worldline_gift_magnification_0 = {}, {}, {}, {}
	for k, v in pairs(globalCsv.worldline_gift_base_10) do
		worldline_gift_base_10[k] = {v}
	end
	for k, v in pairs(globalCsv.worldline_gift_base_1) do
		worldline_gift_base_1[k] = {v}
	end
	for k, v in pairs(globalCsv.worldline_gift_magnification_1) do
		worldline_gift_magnification_1[k] = {v}
	end
	for k, v in pairs(globalCsv["worldline_gift_magnification_0.1"]) do
		worldline_gift_magnification_0[k] = {v}
	end

    local gift_base_10 = (math.randWeight(worldline_gift_base_10, 1) or 0) * 10
	local gift_base_1 = math.randWeight(worldline_gift_base_1, 1) or 0

	local gift_magnification_1 = math.randWeight(worldline_gift_magnification_1, 1) or 0
	local gift_magnification_0 = (math.randWeight(worldline_gift_magnification_0, 1) or 0) * (0.1)

	local points = math.floor((gift_base_10 + gift_base_1) * (gift_magnification_1 + gift_magnification_0))
	worldChangePoints[ItemWorldLine.RouletteCount] = worldChangePoints[ItemWorldLine.RouletteCount] - 1
	worldChangePoints[ItemWorldLine.Points] = (worldChangePoints[ItemWorldLine.Points] or 0) + points
    role:updateProperty({field = "worldChangePoints", value = worldChangePoints})

	SendPacket(actionCodes.Role_worldLineRouletteRpc, MsgPack.pack({base_10 = gift_base_10, base_1 = gift_base_1, magnification_1 = gift_magnification_1, magnification_0 = gift_magnification_0}))
    return true
end

function _M.worldLineRewardRpc(agent, data)
	local role = agent.role
    local worldLineReward = role:getProperty("worldLineReward") or {}
	local worldChangePoints = role:getProperty("worldChangePoints") or {}
	local points =  worldChangePoints[ItemWorldLine.Points] or 0

	local reward, change = {}
	for key, val in pairs(csvdb["worldline_awardCsv"]) do
		if points >= key and not worldLineReward[key] then
			for k, v in pairs(val.award:toNumMap()) do
				reward[k] = (reward[k] or 0) + v
			end
			worldLineReward[key] = 1
		end
	end

	role:updateProperty({field = "worldLineReward", value = worldLineReward})

	if next(reward) then
		reward, change = role:award(reward,  {log = {desc = "worldLine", int1 = role:getProperty("id")}})
	end
	SendPacket(actionCodes.Role_worldLineRewardRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

function _M.itemConvertDevilTicketRpc(agent, data)
	local role = agent.role
	local msg = MsgPack.unpack(data)
	local itemId = msg.itemId    --道具id
	local count = msg.count or 1 --兑换生成的数量
	local itemData = csvdb["itemCsv"][itemId]
	if itemData.use_type ~= 11 then return 2 end

	local createCost = globalCsv.moguixunlianying_create_cost[itemId]:toArray(true, "=")
	if not next(createCost) then return 3 end

    local cost = {[itemId] = createCost[1] * count}
	if not role:checkItemEnough(cost) then return 4 end
	role:costItems({cost}, {log = {desc = "itemConvertDevilTicket"}})
	local reward, change = role:award({[createCost[2]] = count}, {log = {desc = "itemConvertDevilTicket", int1 = itemId, int2 = cost[itemId]}})

	SendPacket(actionCodes.Role_itemConvertDevilTicketRpc, MsgPack.pack(role:packReward(reward, change)))
	return true
end

return _M