HomeServer/Server/AllServer/GameServer/Activity/ActivityDailyRiddle.lua

local skynet = require "skynet"
local oo = require "Class"
local log = require "Log"
local pb = require "pb"
local dataType = require "DataType"
local errorInfo = require "ErrorInfo"
local activity = require "Activity"
local json =require "json"
local dataType = require "DataType"
local ActivityDailyRiddle = oo.class()

ActivityDailyRiddle.ActivityType = dataType.ActivityType_DailyRiddle

--构造函数
function ActivityDailyRiddle:Init()

end

--获取默认题目
function ActivityDailyRiddle:GetDefaultRiddle(player,riddleId)

    local today= self:GetTodayOpenNum(player)
    --默认题目
    local data ={riddleId=riddleId,state= riddleId == today and 1 or 0,answerTime=0,buyTip = false,buyAnswer=false}
    if riddleId < today then
        data.state = 2
    end
    return data
end

-- 每次登录需要进行修改的数据
function ActivityDailyRiddle:LoginInitData(player)

    --功能未开启
    if not player:IsUnlockSystem( dataType.UnlockSystem_ActivityDailyRiddle ) then

        log.debug("每日灯谜未开启-等级不足")
        return
    end

    --结算
    self:ActivitySettle(player)

    --活动是否开启
    if not self:CheckDataAndGetActivity(player) then

        log.debug("每日灯谜未开启")        
        return
    end

    -- 处理红点
    skynet.server.msgTips:Reset(player, 119)
    skynet.server.msgTips:Reset(player, 120)

    log.debug("每日灯谜活动进行中")
end

--初始玩家数据，返回活动信息,
function ActivityDailyRiddle:CheckDataAndGetActivity(player)

    --默认空活动
    local cfgRiddle = nil

    if player==nil then
        log.debug("每日灯谜未开启")
        return cfgRiddle
    end

    --判断等级是否开启
    if not player:IsUnlockSystem( dataType.UnlockSystem_ActivityDailyRiddle)  then
        log.debug("每日灯谜等级不足")
        return cfgRiddle
    end

    --获取开启的活动
    local activityId,_, _, _ = activity:GetActivityInfo(player, ActivityDailyRiddle.ActivityType)

    --没有开启的活动
    if  activityId == 0 then
        return cfgRiddle
    end

    --初始化
    if player.gameData.DailyRiddleMap==nil then
        player.gameData.DailyRiddleMap={}
    end    

    --获取活动配置
    local cfgRiddle=self:GetRiddleConfig(player,activityId)

    --未获取到有效的活动
    if cfgRiddle == nil then
        log.debug("每日灯谜未开启-未获取到有效的活动2")
        return  cfgRiddle
    end 

    --如果玩家已经存在活动不需要检查
    if player.gameData.DailyRiddleMap[activityId] then 

        --是否跨天
        if os.date("%Y-%m-%d",player.gameData.DailyRiddleMap[activityId].LoginDate) ~= os.date("%Y-%m-%d",skynet.GetTime()) then
            player.gameData.DailyRiddleMap[activityId].adSkipCount=0
            player.gameData.DailyRiddleMap[activityId].adAnswerCount=0
            player.gameData.DailyRiddleMap[activityId].LoginDate=skynet.GetTime()

            local day=self:GetTodayOpenNum(player)
            for _, riddleInfo in ipairs(player.gameData.DailyRiddleMap[activityId].riddleInfoList) do

                --过期的题目，没有购买，状态不是已完成的
                if riddleInfo.riddleId<day and not riddleInfo.buyAnswer and riddleInfo.state == 1 then
                    riddleInfo.state = 2
                end
            end
        end

         --删除过期活动，减少数据产生
         local removeKeyList = {}
         for exceedActivityId, value in pairs(player.gameData.DailyRiddleMap) do
             if exceedActivityId ~= activityId and value.id ~= cfgRiddle.id then
                 table.insert(removeKeyList, exceedActivityId)
             end
         end
         if next(removeKeyList) then
             for _, removeKey in ipairs(removeKeyList) do
                 player.gameData.DailyRiddleMap[removeKey]=nil
             end
         end

        return cfgRiddle
    end
    
    --存在活动初始化玩家数据
    local playerActivityDailyRiddle = {}
    playerActivityDailyRiddle.id = cfgRiddle.id

    --累计答题次数
    playerActivityDailyRiddle.totalAnswerNum=0

    --今日查看广告次数
    playerActivityDailyRiddle.adSkipCount=0

    --今日补答题广告次数
    playerActivityDailyRiddle.adAnswerCount=0

    --最近一次答题时间
    playerActivityDailyRiddle.lastAnswerTime=0

    --已答题的题目信息
    playerActivityDailyRiddle.riddleInfoList = {}

    --已领取的累计奖励信息
    playerActivityDailyRiddle.rewardInfoList = {}
    playerActivityDailyRiddle.LoginDate=skynet.GetTime()

    --更新缓存
    player.gameData.DailyRiddleMap[activityId] = playerActivityDailyRiddle

    return cfgRiddle

end

--获取配置信息
function ActivityDailyRiddle:GetRiddleConfig(player,activityId)

    local cfgRiddle=nil

    --获取该活动的默认初始关卡
    local cfgRiddles=skynet.server.gameConfig:GetPlayerAllCfg(player, "Riddle")
    if cfgRiddles==nil then

        log.debug("cfgRiddles is nil")
        return  cfgRiddle
    end

    for _, value in pairs(cfgRiddles) do
        if value.id==activityId then
            cfgRiddle=value
            break
        end
    end

    return cfgRiddle
end

--是否可以领取累计奖励
function ActivityDailyRiddle:isCanDraw( player)

    --活动是否开启
    local cfgDailyRiddle =self:CheckDataAndGetActivity(player)
    if cfgDailyRiddle ==nil then
        return false
    end

    --玩家每日灯谜信息
    local playerDailyRiddle=player.gameData.DailyRiddleMap[cfgDailyRiddle.id]

    for _, value in ipairs(cfgDailyRiddle.limitReward) do

        local rewardInfo = skynet.server.common:Split(value,"_" )
        rewardInfo[1],rewardInfo[2] = tonumber(rewardInfo[1]),tonumber(rewardInfo[2])

        if playerDailyRiddle.totalAnswerNum >=  rewardInfo[1] then

            --是否领取
            local ifDraw=false
            for _, value in ipairs(playerDailyRiddle.rewardInfoList) do
                if rewardInfo[1] == value then
                    ifDraw=true
                    break
                end
            end   
            
            --没有领取
            if not ifDraw then
                return true
            end
        end     
    end

    return false
end

--获取当日是开启的多少天
function ActivityDailyRiddle:GetTodayOpenNum( player)

    --获取开启的活动
    local activityId, startTime, _, _ = activity:GetActivityInfo(player, ActivityDailyRiddle.ActivityType)
    if activityId == 0 then
        return 0
    end

    local startTimeDate = os.date("*t", startTime)

    --由于活动开启时间是10点，这里统计时间设置成0点
    local startTimeTemp=os.time({ year = startTimeDate.year, month = startTimeDate.month, day=startTimeDate.day, hour=0, min=0, sec=0 })

    --计算当前是哪天
    local day =math.ceil((skynet.GetTime()-startTimeTemp)/dataType.OneDaySec)

    --log.debug(string.format("获取每日灯谜开启天数 day:%d",day))

    return day
end

--当日是否有灯谜可答
function ActivityDailyRiddle:isCanAnswer( player)

    --活动是否开启
    local cfgDailyRiddle =self:CheckDataAndGetActivity(player)
    if cfgDailyRiddle ==nil then
        return false
    end

    --玩家每日灯谜信息
    local playerDailyRiddle=player.gameData.DailyRiddleMap[cfgDailyRiddle.id]

    local openDay=self:GetTodayOpenNum(player)

    for _, day in ipairs(cfgDailyRiddle.riddleId) do
            
        --是否完成
        local ifComplete=true

        --是否存在
        local ifExist=false

        --如果是当日 可能为空数据
        if day==openDay  then
            for _, playerData in pairs(playerDailyRiddle.riddleInfoList) do     
                if day == playerData.riddleId then
                    ifExist = true
                    break
                end
            end
            
            --当日未作答
            if not ifExist then                
                return true
            end
        end

        for _, playerData in pairs(playerDailyRiddle.riddleInfoList) do     
            if day == playerData.riddleId 
                and (playerData.answerTime==0 or (playerData.answerTime+cfgDailyRiddle.answerCd ) <= skynet.GetTime())--未在cd中
                and playerData.state == 1 then--可答题
                ifComplete=false
                break
            end
        end

        if not ifComplete  then
            log.info("存在可答题的灯谜",ifComplete,ifExist)
            return true
        end
    end

    return false
end

--活动结束补发奖励
function ActivityDailyRiddle:ActivitySettle(player)

    if player.gameData.DailyRiddleMap == nil or not next(player.gameData.DailyRiddleMap) then
        return
    end

    local cfgActivitys = skynet.server.gameConfig:GetPlayerAllCfg(player, "Activity")
    if cfgActivitys == nil then
       return
    end

    --获取开启的活动
    local openActivityId,_, _, _ = activity:GetActivityInfo(player, ActivityDailyRiddle.ActivityType)


    --循环玩家活动数据
    for activityId, dailyRiddle in pairs(player.gameData.DailyRiddleMap) do

        --当前活动正在开启
        if activityId == openActivityId or activityId == 0 then
            goto continue
        end

        --获取配置
        local cfgRiddle=self:GetRiddleConfig(player,activityId)

        --配置不存在
        if cfgRiddle== nil then
            goto continue
        end

        if #cfgRiddle.limitReward == #dailyRiddle.rewardInfoList then
            goto continue
        end

        --奖励列表
        local award = {}

        for _, value in ipairs(cfgRiddle.limitReward) do

            local rewardInfo = skynet.server.common:Split(value,"_" )
            local rewardInfo1,rewardInfo2 = tonumber(rewardInfo[1]),tonumber(rewardInfo[2])

            if dailyRiddle.totalAnswerNum >=  rewardInfo1 then

                --是否领取
                local ifDraw=false
                for _, value in ipairs(dailyRiddle.rewardInfoList) do
                    if value==rewardInfo1 then
                        ifDraw=true
                        break
                    end
                end
                
                if not ifDraw then
                    local reward = skynet.server.playerLand:GetRewardInfo(player , rewardInfo2)--对应的奖励信息
                    for _ ,v1 in pairs( reward ) do
                        table.insert(award , v1 )
                    end

                    table.insert(dailyRiddle.rewardInfoList,rewardInfo1)
                end
            end
        end

        --存在未领取的奖励
        if next(award) then
            skynet.server.mail:AddNewMail( player , skynet.server.mail.MailType_Award,"灯谜奖励补发", "本次灯谜活动已结束，小蜗们忘记领取的奖励已经通过邮件发放咯，请小蜗们及时领取！", award, true)
            log.info(string.format("玩家 %d 每日灯谜奖励补发", player.userId  ))
        end

        ::continue::
    end
end

--获取每日灯谜信息
function ActivityDailyRiddle:Show( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityDailyRiddleShow", c2sData.data ))
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityDailyRiddleShow")
    local data = {}   

    --检查并且获取活动信息
    local cfgRiddle=self:CheckDataAndGetActivity(player)

    if cfgRiddle == nil then
        s2cData.code = errorInfo.ErrorCode.ActivityClosed 
        return
    end

    local playerDailyRiddle=player.gameData.DailyRiddleMap[cfgRiddle.id]
    data.curDay=self:GetTodayOpenNum(player)
    data.totalAnswerNum=playerDailyRiddle.totalAnswerNum
    data.adAnswerCount=playerDailyRiddle.adAnswerCount
    data.adSkipCount=playerDailyRiddle.adSkipCount

    data.riddleInfoList={}

    --组装每日灯谜信息
    for _, day in ipairs(cfgRiddle.riddleId) do

        --默认未解锁
        local dataInfo=self:GetDefaultRiddle(player,day)

        --是否解锁
        if day > data.curDay then
            table.insert(data.riddleInfoList,dataInfo)
            goto  continue
        end

        for playerDay, value in pairs(playerDailyRiddle.riddleInfoList) do
            if day == playerDay then
                dataInfo.state=value.state
                dataInfo.buyTip=value.buyTip
                dataInfo.buyAnswer=value.buyAnswer
                dataInfo.answerTime=value.answerTime
                table.insert(data.riddleInfoList,dataInfo)
                goto continue
            end
        end

        --不是今天的
        if dataInfo.state == 0 then            
            dataInfo.state=2
        end
        table.insert(data.riddleInfoList,dataInfo)

        ::continue::
    end

    data.rewardInfoList={}
    
    --组装累计奖励信息
    for _, value in ipairs(cfgRiddle.limitReward) do

        local rewardInfo = skynet.server.common:Split(value,"_" )
        rewardInfo[1],rewardInfo[2] = tonumber(rewardInfo[1]),tonumber(rewardInfo[2])

        --默认未解锁
        local dataInfo={id = rewardInfo[1],status = 0,needCount=rewardInfo[1],rewardId=rewardInfo[2]}

        --是否解锁
        if playerDailyRiddle.totalAnswerNum < rewardInfo[1] then
            table.insert(data.rewardInfoList,dataInfo)
            goto  continue
        end

        for _, num in ipairs(playerDailyRiddle.rewardInfoList) do
            if rewardInfo[1] == num then
                dataInfo.status = 2
                table.insert(data.rewardInfoList,dataInfo)
                goto continue
            end
        end

        dataInfo.status = 1
        table.insert(data.rewardInfoList,dataInfo)

        ::continue::
    end

    --返回信息
    s2cData.data = assert(pb.encode("S2CActivityDailyRiddleShow", data))
end

--购买提示
function ActivityDailyRiddle:BuyTip( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityDailyRiddleBuyTip", c2sData.data ))
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityDailyRiddleBuyTip")
    local riddleId =c2sData.data.riddleId
    local data = {riddleId=riddleId}   

    --检查并且获取活动信息
    local cfgRiddle=self:CheckDataAndGetActivity(player)

    if cfgRiddle == nil then
        s2cData.code = errorInfo.ErrorCode.ActivityClosed 
        return
    end

    local playerDailyRiddle=player.gameData.DailyRiddleMap[cfgRiddle.id]
    if  playerDailyRiddle.riddleInfoList[riddleId] == nil then
        playerDailyRiddle.riddleInfoList[riddleId]=self:GetDefaultRiddle(player,riddleId)
    end
    
    --是否已经购买
    if playerDailyRiddle.riddleInfoList[riddleId].buyTip then
        s2cData.code = errorInfo.ErrorCode.AlreadyBuyTip
        return
    end

    --扣除奖励
    local helpCoin=skynet.server.common:Split(cfgRiddle.helpCoin,"_" )
    local type,num =tonumber(helpCoin[1]),tonumber(helpCoin[2])

    local eventId = pb.enum("EnumMoneyChangeEventID","EventID_139" )
    if not player:MoneyChange( type,-num , eventId ) then  
        log.info(string.format("每日灯谜 购买提示 扣除物品失败 data:%s",cfgRiddle.helpCoin))
    
        s2cData.code = errorInfo.ErrorCode.NotEnoughGoods
        return
    end

    --修改数据
    playerDailyRiddle.riddleInfoList[riddleId].buyTip = true
    
    --返回信息
    s2cData.data = assert(pb.encode("S2CActivityDailyRiddleBuyTip", data))
end

--开始答题
function ActivityDailyRiddle:Start( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityDailyRiddleStart", c2sData.data ))
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityDailyRiddleStart")
    local riddleId =c2sData.data.riddleId
    local answer =c2sData.data.answer
    local answerType =c2sData.data.answerType
    local data = {riddleId=riddleId}   

    --检查并且获取活动信息
    local cfgRiddle=self:CheckDataAndGetActivity(player)

    if cfgRiddle == nil then
        s2cData.code = errorInfo.ErrorCode.ActivityClosed 
        return
    end

    --获取今日题目
    local day = self:GetTodayOpenNum(player)

    if riddleId > day then
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end

    local playerDailyRiddle=player.gameData.DailyRiddleMap[cfgRiddle.id]
    if  playerDailyRiddle.riddleInfoList[riddleId] == nil then
        playerDailyRiddle.riddleInfoList[riddleId]=self:GetDefaultRiddle(player,riddleId)
    end
    
    --是否已经购买
    if playerDailyRiddle.riddleInfoList[riddleId].state ~=1 then-- 0:未解锁 1:可答题 2:补答题 3:已答对
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end

    --判断CD
    if playerDailyRiddle.riddleInfoList[riddleId].answerTime>skynet.GetTime() then
        log.info(string.format("每日灯谜 开始答题 CD中 %d",playerDailyRiddle.riddleInfoList[riddleId].answerTime))
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end

    --答案错误
    local cfgRiddleLevel=skynet.server.gameConfig:GetPlayerCurCfg(player, "RiddleLevel",riddleId)
    if cfgRiddleLevel==nil then
        log.info(string.format("每日灯谜 开始答题 未找到配置 %d",day))
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end

    --log.info(string.format("每日灯谜 开始答题 答题%s，答案:%s",answer,cfgRiddleLevel.answer))

    --判断答案
    --回答错误
    if answer ~= cfgRiddleLevel.answer then
        playerDailyRiddle.riddleInfoList[riddleId].answerTime=skynet.GetTime()
    else
        --发奖
        local eventId = pb.enum("EnumMoneyChangeEventID","EventID_137")
        player:GiveReward(cfgRiddleLevel.rewardId ,eventId,1)           
        playerDailyRiddle.riddleInfoList[riddleId].answerTime=0
        playerDailyRiddle.riddleInfoList[riddleId].state = 3-- 0:未解锁 1:可答题 2:补答题 3:已答对
        playerDailyRiddle.totalAnswerNum =playerDailyRiddle.totalAnswerNum + 1
    end

    if not self:isCanAnswer(player) then        
        skynet.server.msgTips:ReduceAll(player, 119)
    end

    if self:isCanDraw(player) then        
        skynet.server.msgTips:Add(player, 120)
    end

    data.curDay=day
    data.totalAnswerNum=playerDailyRiddle.totalAnswerNum
    data.riddleId=riddleId
    data.isRight=answer == cfgRiddleLevel.answer
    data.rewardId=cfgRiddleLevel.rewardId

    data.riddleInfoList={}

    --组装每日灯谜信息
    for _, day in ipairs(cfgRiddle.riddleId) do

        --默认未解锁
        local dataInfo=self:GetDefaultRiddle(player,day)

        --是否解锁
        if day > data.curDay then
            table.insert(data.riddleInfoList,dataInfo)
            goto  continue
        end

        for playerDay, value in pairs(playerDailyRiddle.riddleInfoList) do
            if day == playerDay then
                dataInfo.state=value.state
                dataInfo.buyTip=value.buyTip
                dataInfo.answerTime=value.answerTime
                table.insert(data.riddleInfoList,dataInfo)
                goto continue
            end
        end

        --不是今天的
        if dataInfo.state == 0 then            
            dataInfo.state=2
        end
        table.insert(data.riddleInfoList,dataInfo)

        ::continue::
    end

    data.rewardInfoList={}
    
    --组装累计奖励信息
    for _, value in ipairs(cfgRiddle.limitReward) do

        local rewardInfo = skynet.server.common:Split(value,"_" )
        rewardInfo[1],rewardInfo[2] = tonumber(rewardInfo[1]),tonumber(rewardInfo[2])

        --默认未解锁
        local dataInfo={id = rewardInfo[1],status = 0,needCount=rewardInfo[1],rewardId=rewardInfo[2]}

        --是否解锁
        if playerDailyRiddle.totalAnswerNum < rewardInfo[1] then
            table.insert(data.rewardInfoList,dataInfo)
            goto  continue
        end

        for _, num in ipairs(playerDailyRiddle.rewardInfoList) do
            if rewardInfo[1] == num then
                dataInfo.status = 2
                table.insert(data.rewardInfoList,dataInfo)
                goto continue
            end
        end

        dataInfo.status = 1
        table.insert(data.rewardInfoList,dataInfo)

        ::continue::
    end

    --返回信息
    s2cData.data = assert(pb.encode("S2CActivityDailyRiddleStart", data))
end

--领取累计奖励
function ActivityDailyRiddle:GetReward( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityDailyRiddleGetReward", c2sData.data ))
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityDailyRiddleGetReward")
    local totalNum =c2sData.data.num
    local data = {}   

    --检查并且获取活动信息
    local cfgRiddle=self:CheckDataAndGetActivity(player)

    if cfgRiddle == nil then
        s2cData.code = errorInfo.ErrorCode.ActivityClosed 
        return
    end
   
    local playerDailyRiddle=player.gameData.DailyRiddleMap[cfgRiddle.id]

    --判断进度
    if playerDailyRiddle.totalAnswerNum < totalNum then
        log.info(string.format("每日灯谜 领取奖励 未解锁 %d",totalNum))
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end

    local ifExist =false
    local rewardId =nil

    --判断配置是否存在
    for _, value in ipairs(cfgRiddle.limitReward) do

        local rewardInfo = skynet.server.common:Split(value,"_" )
        if tonumber(rewardInfo[1]) == totalNum then
            ifExist =true
            rewardId=tonumber(rewardInfo[2])
            break
        end
    end

    if not ifExist then
        log.info(string.format("每日灯谜 领取奖励 配置不存在 %d",totalNum))
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end
    
    --是否已经领取
    for _, value in ipairs(playerDailyRiddle.rewardInfoList) do
        if value == totalNum then
            log.info(string.format("每日灯谜 领取奖励 已领取 %d",totalNum))
            s2cData.code = errorInfo.ErrorCode.OpFailed
            return
        end
    end

    --发奖励
    local eventId = pb.enum("EnumMoneyChangeEventID","EventID_139")
    player:GiveReward(rewardId ,eventId,1)

    --添加领取内容
    table.insert(playerDailyRiddle.rewardInfoList,totalNum)

    --红点
    if not self:isCanDraw(player) then        
        skynet.server.msgTips:ReduceAll(player, 120)
    end

    data.curDay=self:GetTodayOpenNum(player)
    data.totalAnswerNum=playerDailyRiddle.totalAnswerNum
    data.rewardId=rewardId

    data.riddleInfoList={}

    --组装每日灯谜信息
    for _, day in ipairs(cfgRiddle.riddleId) do

        --默认未解锁
        local dataInfo=self:GetDefaultRiddle(player,day)

        --是否解锁
        if day > data.curDay then
            table.insert(data.riddleInfoList,dataInfo)
            goto  continue
        end

        for playerDay, value in pairs(playerDailyRiddle.riddleInfoList) do
            if day == playerDay then
                dataInfo.state=value.state
                dataInfo.buyTip=value.buyTip
                dataInfo.answerTime=value.answerTime
                table.insert(data.riddleInfoList,dataInfo)
                goto continue
            end
        end

        --不是今天的
        if dataInfo.state == 0 then            
            dataInfo.state=2
        end
        table.insert(data.riddleInfoList,dataInfo)

        ::continue::
    end

    data.rewardInfoList={}
    
    --组装累计奖励信息
    for _, value in ipairs(cfgRiddle.limitReward) do

        local rewardInfo = skynet.server.common:Split(value,"_" )
        rewardInfo[1],rewardInfo[2] = tonumber(rewardInfo[1]),tonumber(rewardInfo[2])

        --默认未解锁
        local dataInfo={id = rewardInfo[1],status = 0,needCount=rewardInfo[1],rewardId=rewardInfo[2]}

        --是否解锁
        if playerDailyRiddle.totalAnswerNum < rewardInfo[1] then
            table.insert(data.rewardInfoList,dataInfo)
            goto  continue
        end

        for _, num in ipairs(playerDailyRiddle.rewardInfoList) do
            if rewardInfo[1] == num then
                dataInfo.status = 2
                table.insert(data.rewardInfoList,dataInfo)
                goto continue
            end
        end

        dataInfo.status = 1
        table.insert(data.rewardInfoList,dataInfo)

        ::continue::
    end

    --返回信息
    s2cData.data = assert(pb.encode("S2CActivityDailyRiddleGetReward", data))
end

--跳过CD
function ActivityDailyRiddle:SkipCD( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityDailyRiddleSkipCD", c2sData.data ))
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityDailyRiddleSkipCD")
    local riddleId =c2sData.data.riddleId
    local skipType =c2sData.data.skipType --跳过类型 1:广告 2:加速器 3:蜗壳币
    local data = {}   

    --检查并且获取活动信息
    local cfgRiddle=self:CheckDataAndGetActivity(player)

    if cfgRiddle == nil then
        s2cData.code = errorInfo.ErrorCode.ActivityClosed 
        return
    end
   
    local playerDailyRiddle=player.gameData.DailyRiddleMap[cfgRiddle.id]

    --判断是否存在CD,不在CD中
    if playerDailyRiddle.riddleInfoList[riddleId] == nil 
        or playerDailyRiddle.riddleInfoList[riddleId].answerTime + cfgRiddle.answerCd < skynet.GetTime() then
        log.info(string.format("每日灯谜 跳过CD 不存在/不在CD中 %d",riddleId))
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end

    --获取配置
    local cfgSValue = skynet.server.gameConfig:GetPlayerAllCfg( player , "SValue")

    if skipType ==1  then--广告
        if playerDailyRiddle.adSkipCount >= cfgRiddle.limit then
            log.info(string.format("每日灯谜 跳过CD 广告次数已用完 %d",riddleId))
            s2cData.code = errorInfo.ErrorCode.OpFailed
            return
        end

        playerDailyRiddle.adSkipCount=playerDailyRiddle.adSkipCount+1
        playerDailyRiddle.riddleInfoList[riddleId].answerTime=0

    elseif skipType == 2 then--加速券

        --指定加速券
        local goodsId = 6

        --是否正确
        if skynet.server.bag:GetGoodsCount(player,dataType.GoodsType_Prop,goodsId) <= 0 then        
            s2cData.code = errorInfo.ErrorCode.NotEnoughGoods
            return
        end

        --扣除资源
        skynet.server.bag:RemoveGoods(player,dataType.GoodsType_Prop,goodsId,1)

        --移除cd
        playerDailyRiddle.riddleInfoList[riddleId].answerTime=playerDailyRiddle.riddleInfoList[riddleId].answerTime-(cfgSValue.speedCouponTime*60)
        if playerDailyRiddle.riddleInfoList[riddleId].answerTime + cfgRiddle.answerCd < skynet.GetTime() then
            playerDailyRiddle.riddleInfoList[riddleId].answerTime=0
        end
    else --蜗壳币

        --剩余秒钟
        local time = playerDailyRiddle.riddleInfoList[riddleId].answerTime+cfgRiddle.answerCd-skynet.GetTime()
        if time<0 then
            log.info(string.format("每日灯谜 跳过CD 秒数不足 %d",time))
            return
        end

        --扣除奖励
        local type,num =dataType.GoodsType_Volute,math.ceil(math.ceil(time/60)/cfgSValue.timeExchangeVoluteCoin[1])*cfgSValue.timeExchangeVoluteCoin[1]

        local eventId = pb.enum("EnumMoneyChangeEventID","EventID_139" )
        if not player:MoneyChange( type,-num , eventId ) then   
            log.info(string.format("每日灯谜 跳过CD 蜗壳币不足 %d",num))   
            s2cData.code = errorInfo.ErrorCode.NotEnoughGoods
            return
        end
        playerDailyRiddle.riddleInfoList[riddleId].answerTime=0
    end

    --红点
    if not self:isCanAnswer(player) then        
        skynet.server.msgTips:Add(player, 119)
    end

    data.riddleInfoList={}
    data.curDay=self:GetTodayOpenNum(player)

    --组装每日灯谜信息
    for _, day in ipairs(cfgRiddle.riddleId) do

        --默认未解锁
        local dataInfo=self:GetDefaultRiddle(player,day)

        --是否解锁
        if day > data.curDay then
            table.insert(data.riddleInfoList,dataInfo)
            goto  continue
        end

        for playerDay, value in pairs(playerDailyRiddle.riddleInfoList) do
            if day == playerDay then
                dataInfo.state=value.state
                dataInfo.buyTip=value.buyTip
                dataInfo.answerTime=value.answerTime
                table.insert(data.riddleInfoList,dataInfo)
                goto continue
            end
        end

        --不是今天的，未初始化，直接就需要补卡
        if dataInfo.state == 0 then            
            dataInfo.state=2
        end
        table.insert(data.riddleInfoList,dataInfo)

        ::continue::
    end

    --返回信息
    s2cData.data = assert(pb.encode("S2CActivityDailyRiddleSkipCD", data))
end

--购买补答题
function ActivityDailyRiddle:BuyAnswer( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityDailyRiddleBuyAnswer", c2sData.data ))
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityDailyRiddleBuyAnswer")
    local riddleId =c2sData.data.riddleId
    local answerType =c2sData.data.answerType --跳过类型 1:货币购买 2:广告购买
    local data = {}   

    --检查并且获取活动信息
    local cfgRiddle=self:CheckDataAndGetActivity(player)

    if cfgRiddle == nil then
        s2cData.code = errorInfo.ErrorCode.ActivityClosed 
        return
    end
   
    local playerDailyRiddle=player.gameData.DailyRiddleMap[cfgRiddle.id]

    --是否是当日题目
    local todayRiddileId =self:GetTodayOpenNum(player)
    if todayRiddileId <= riddleId then
        log.info(string.format("每日灯谜 购买补答题 大于/等于当日题目 %d",riddleId))
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end

    if playerDailyRiddle.riddleInfoList[riddleId] == nil  then
        playerDailyRiddle.riddleInfoList[riddleId]=self:GetDefaultRiddle(player,riddleId)
    end

    --判断是否是可答题
    if  playerDailyRiddle.riddleInfoList[riddleId].buyAnswer then--0:未解锁 1:可答题 2:补答题 3:已答对
        log.info(string.format("每日灯谜 购买补答题 不可补答题 %d",riddleId))
        s2cData.code = errorInfo.ErrorCode.OpFailed
        return
    end

    if answerType ==2  then--广告
        if playerDailyRiddle.adAnswerCount >= cfgRiddle.limit then
            log.info(string.format("每日灯谜 购买补答题 广告次数已用完 %d",riddleId))
            s2cData.code = errorInfo.ErrorCode.OpFailed
            return
        end

        playerDailyRiddle.adAnswerCount=playerDailyRiddle.adAnswerCount+1

    else --蜗壳币
        --资源是否足够
        local answerCoin = skynet.server.common:Split(cfgRiddle.answerCoin,"_" )
        local type,num = tonumber(answerCoin[1]),tonumber(answerCoin[2])

        local eventId = pb.enum("EnumMoneyChangeEventID","EventID_139" )
        if not player:MoneyChange( type,-num , eventId ) then     
            s2cData.code = errorInfo.ErrorCode.NotEnoughGoods
            return
        end

    end

    playerDailyRiddle.riddleInfoList[riddleId].state=1
    playerDailyRiddle.riddleInfoList[riddleId].buyAnswer=true        

    if self:isCanAnswer(player) then       
        skynet.server.msgTips:Add(player, 119)
    end
    
    data.riddleInfo=playerDailyRiddle.riddleInfoList[riddleId]

    --返回信息
    s2cData.data = assert(pb.encode("S2CActivityDailyRiddleBuyAnswer", data))
end

skynet.server.activityDailyRiddle = ActivityDailyRiddle
return ActivityDailyRiddle