local ipairs = ipairs
  local table = table
  local math = math
  local string = string
  local redisproxy = redisproxy
  local MsgPack = MsgPack
  local string_format = string.format
  local tonumber = tonumber
  local table_insert = table.insert
  local table_unpack = table.unpack
  local table_find = table.find
  local table_nums = table.nums
  local math_random = math.randomInt
  
  
  local _M = {}
  
  
  function _M.sudokuRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local id = msg.id
  
  	local sudoku = role:getProperty("sudoku")
  	local phase = sudoku[-1] or 1
  	local curData = (csvdb["guide_sudokuCsv"][phase] or {})[id]
  	if phase == -1 or not curData then return 1 end
  
  	sudoku.task = sudoku.task or {}
  	sudoku.task[phase] = sudoku.task[phase] or {}
  
  	if (sudoku.task[phase][id] or 0) < curData.con1 then return 2 end
  
  	sudoku.task[phase][id] = -1

  	local task, tchange = role:award(curData.reward, {log = {desc = "sudoku", int1 = id, int2 = phase}}) -- 任务奖励

  	local reward, rchange = {}

  	local rId = {}
  	for pid, pdata in pairs(csvdb["guide_sudoku_rewardCsv"][phase] or {}) do
  		local pos = pdata.pos:toArray(true, "=")
  		local ok, is = true, false
  		for _, one in pairs(pos) do
  			if one == id then
  				is = true
  			end
  			if sudoku.task[phase][one] ~= -1 then
  				ok = false
  				break
  			end
  		end
  
  		if ok and is then
  			for itemId, count in pairs(pdata.reward:toNumMap()) do
  				reward[itemId] = (reward[itemId] or 0) + count
  			end
  			table.insert(rId, pid)
  		end
  	end
  
  	if not next(reward) then
  		reward = nil
  	else

  		reward, rchange = role:award(reward, {log = {desc = "sudokuR", int1 = id, int2 = phase}})

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

  	role:log("activity", {
  		activity_id = id, -- 活动ID（或活动指定任务的ID）
  		activity_type = 0, -- 活动类型，见活动类型枚举表

  		activity_reward = reward or {}, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}

  	})

  	role:mylog("act_action", {desc = "sudoku", int1 = id, int2 = phase})

  	SendPacket(actionCodes.Activity_sudokuRpc, MsgPack.pack({task = role:packReward(task, tchange), reward = role:packReward(reward, rchange), rId = rId}))

  	return true
  end
  
  function _M.sudokuRewardRpc(agent, data)
  	local role = agent.role
  
  
  	local sudoku = role:getProperty("sudoku")
  	local phase = sudoku[-1] or 1
  
  	local curData = csvdb["guide_sudokuCsv"][phase]
  	if not curData then return end
  	if not globalCsv.guide_sudoku_reward[phase] then return end
  
  	local curTask = (sudoku.task or {})[phase] or {}
  
  	for id, _ in pairs(curData) do
  		if curTask[id] ~= -1 then
  			return
  		end
  	end
  

  	local reward, change = role:award(globalCsv.guide_sudoku_reward[phase], {log = {desc = "sudokuRP", int1 = phase}})

  
  	sudoku[-1] = phase + 1
  	sudoku.task[phase] = nil
  	if not csvdb["guide_sudokuCsv"][sudoku[-1]] then
  		sudoku[-1] = -1
  		sudoku.task = nil
  	end
  	role:updateProperty({field = "sudoku", value = sudoku})
  

  	role:log("activity", {
  		activity_id = 10000 + phase, -- 活动ID（或活动指定任务的ID）
  		activity_type = 0, -- 活动类型，见活动类型枚举表

  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}

  	})
  

  	SendPacket(actionCodes.Activity_sudokuRewardRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true
  end
  
  
  function _M.signRpc(agent, data)
  	local role = agent.role
  
  	local serverT = skynet.timex()
  	local tm = os.date("*t", serverT)
  
  	local curDay = tm.day
  	
  	local yearMonth = tm.year * 100 + tm.month
  	local monthData = csvdb["daily_signInCsv"][yearMonth]
  	if not monthData or not monthData[curDay] then
  		return 1
  	end
  
  	local signs = role:getProperty("sign")
  	if signs[curDay] == yearMonth then  -- 未重置的还可以签到正常（本月已经签到）
  		return 2
  	end
  	signs[curDay] = yearMonth
  

  	local reward, change = role:award(monthData[curDay].item, {log = {desc = "sign", int1 = yearMonth, int2 = curDay}})

  	role:changeUpdates({{type = "sign", field = curDay, value = yearMonth}})

  	role:checkTaskEnter("SignIn")

  	SendPacket(actionCodes.Activity_signRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true
  end
  
  

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

  	if not role.activity:isOpen("Sign") then return 1 end

  
  	local curData = role.activity:getActData("Sign")

  	local reward, change = {}

  	for day, csvData in ipairs(csvdb["new_signInCsv"]) do

  		if day <= (curData[0] or 0) then
  			if not curData[day] then
  				curData[day] = -1
  				-- 奖励
  				for itemId, count in pairs(csvData.reward:toNumMap()) do
  					reward[itemId] = (reward[itemId] or 0) + count
  				end
  			end
  		else
  			break
  		end
  	end
  	if next(reward) then

  		role.activity:updateActData("Sign", curData)

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

  	end

  
  	role:log("activity", {
  		activity_id = curData[0], -- 活动ID（或活动指定任务的ID）
  		activity_type = role.activity.ActivityType.Sign, -- 活动类型，见活动类型枚举表

  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}

  	})
  

  	SendPacket(actionCodes.Activity_actSignRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true
  end
  

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

  	local dayIndex = msg.day

  	local actGoodsFlag = role.storeData:getProperty("actGoodsFlag")
  	local index = GetActGoodsIndex("paySignIn")

  	local ts = actGoodsFlag[index] or 0
  	if ts == 0 then return 1 end

  	local open, actId = role.activity:isOpen("PaySignIn")
  	if not open then return 2 end

  	local diffDay = diffFromTs(ts) + 1

  
  	local curData = role.activity:getActData("PaySignIn")

  	if not curData then return 3 end

  	local reward, change = {}
  	for day, csvData in ipairs(csvdb["pay_signInCsv"]) do

  		if day <= diffDay and day == dayIndex then

  			if not curData[day] then
  				curData[day] = 1
  				-- 奖励
  				for itemId, count in pairs(csvData.reward:toNumMap()) do
  					reward[itemId] = (reward[itemId] or 0) + count
  				end
  			end

  		--else
  		--	break

  		end
  	end
  	if next(reward) then
  		role.activity:updateActData("PaySignIn", curData)
  		reward, change = role:award(reward, {log = {desc = "actPaySign"}})
  	end
  
  	role:log("activity", {

  		activity_id = actId, -- 活动ID（或活动指定任务的ID）

  		activity_type = role.activity.ActivityType.PaySignIn, -- 活动类型，见活动类型枚举表
  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}
  	})
  
  	SendPacket(actionCodes.Activity_actPaySignRpc, MsgPack.pack(role:packReward(reward, change)))
  	return true
  end

  function _M.actCalendaTaskRpc(agent, data)

  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local taskId = msg.id

  	local calTask = role:getProperty("calTask") or {}

  	local record = calTask["r"] or {}
  	local flag = record[taskId] or 0
  	if flag == 1 then return 1 end
  	local open, actId = role.activity:isOpen("CalendaTask")
  	local actData = csvdb["activity_ctrlCsv"][actId]
  	if not open then return 2 end
  	if not actData then return 3 end
  

  	local taskList = csvdb["activity_taskCsv"][actData.condition]
  	if not taskList then return 4 end
  	local taskCfg = taskList[taskId]
  	if not taskCfg then return 5 end
  	if taskCfg.key ~= actData.condition then return 6 end

  	if (calTask[taskId] or 0) < taskCfg.condition1 then return 7 end

  
  	record[taskId] = 1
  	calTask["r"] = record
  

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

  	local reward, change = role:award(taskCfg.reward, {log = {desc = "calendaTask"}})

  
  	role:log("activity", {
  		activity_id = taskId, -- 活动ID（或活动指定任务的ID）
  		activity_type = role.activity.ActivityType.CalendaTask, -- 活动类型，见活动类型枚举表
  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}
  	})
  
  	SendPacket(actionCodes.Activity_actCalendaTaskRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true

  end
  

  function _M.exchangeRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local actid = msg.actid
  	local id = msg.id

  	if not role.activity:isOpenById(actid) then return 1 end

  
  	local exchangeCfg = csvdb["activity_exchangeCsv"][actid]
  	if not exchangeCfg then return 2 end
  	if not exchangeCfg[id] then return 3 end
  	local curData = role.activity:getActData("Exchange") or {}
  	local exchangeData = curData[actid] or {}
  	local curCount = exchangeData[id] or 0
  	local actCfg = exchangeCfg[id]
  	if curCount >= actCfg then return 4 end
  
  	local costs = actCfg.goods:toNumMap()
  	if not role:checkItemEnough(costs) then return 5 end
  	role:costItems(costs, {log = {desc = "actExchange", int1 = actid, int2 = id}})
  
  	curCount = curCount + 1
  	exchangeData[id] = curCount
  	curData[actid] = exchangeData
  	role.activity:updateActData("Exchange", curData)
  
  	local reward, change = role:award(actCfg.award, {log = {desc = "actExchange", int1 = actid, int2 = id}})
  
  
  	SendPacket(actionCodes.Activity_exchangeRpc, MsgPack.pack(role:packReward(reward, change)))
  	return true
  end
  

  function _M.gachakonRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local actid = msg.actid
  	if not role.activity:isOpenById(actid) then return 1 end
  
  	local actCfg = csvdb["activity_capsuleToysCsv"][actid]
  	if not actCfg then return 2 end
  
  	local gachakonInfo = role.activity:getActData("Gachakon") or {}
  	local tmpCfg = clone(actCfg)
  	local flag = 0
  	for id, cfg in pairs(tmpCfg) do
  		local num = gachakonInfo[id] or 0
  		cfg.amount = cfg.amount >= num and cfg.amount - num or 0
  		cfg.weight = cfg.weight * cfg.amount
  		if cfg.weight > 0 then
  			flag = 1
  		end
  	end
  	if flag == 0 then return 3 end
  
  	local id = math.randWeight(tmpCfg, "weight")
  	local reward, change = role:award(tmpCfg[id].award, {log = {desc = "actGachakon", int1 = actid, int2 = id}})
  
  	gachakonInfo[id] = (gachakonInfo[id] or 0) + 1
  	role.activity:updateActData("Gachakon", gachakonInfo)
  
  	SendPacket(actionCodes.Activity_gachakonRpc, MsgPack.pack(role:packReward(reward, change)))
  	return true
  end
  

  return _M