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 taskListEvent = require "TaskListEvent"

local PassCheck = oo.class()
PassCheck.RewardType_Normal = 1             --普通奖励
PassCheck.RewardType_Pay = 2                    --付费奖励

PassCheck.TaskType_Normal = 1                   --常规任务
PassCheck.TaskType_LimitTime = 2                --限时任务
PassCheck.TaskType_Daily = 3                        --每日任务

PassCheck.surplusTime = 100                        --剩余时间

PassCheck.MaxShowItem = 4              --任务最大显示多少个 (要打开所有通行证，这里可以输入100)

PassCheck.infiniteRewardID = 31             --无限奖励ID
function PassCheck:Init()

end

--初始化数据
function PassCheck:CheckNew( player )
    if not player:IsUnlockSystem( dataType.UnlockSystem_PassCheck ) then
        return 
    end

    --根据开始和结束时间找到当期的任务
    local curCfgPassCheck = self:GetCurPeriodCfg( player )
    local passCheck = player.gameData.passCheck
    if curCfgPassCheck and curCfgPassCheck.id ~= passCheck.curId then
        --新的一期初始化数据
        passCheck.curId = curCfgPassCheck.id   --获取最新的通行证ID
        passCheck.rewards = {}
        passCheck.tasks = {}
        passCheck.score = 0
        passCheck.isVip = false            
        passCheck.infiniteRewardCount = 0
        passCheck.infiniteScore = 0

        --奖励配置
        local cfgPassCheckClass = skynet.server.gameConfig:GetPlayerAllCfg( player , "PassCheckClass")
        for k, v in pairs( cfgPassCheckClass ) do
            if curCfgPassCheck.id == v.passCheckId then
                table.insert( passCheck.rewards , { id = v.id , normalStatus = dataType.RewardStatus_NoGet , payStatus = dataType.RewardStatus_NoGet })
            end
        end

        local tmpCfgPassCheckTask = self:GetRandTask( player , curCfgPassCheck )
        for k, v in pairs( tmpCfgPassCheckTask ) do
            --任务类型(注意配置中用的是taskTime)，任务种类，当前进度,是否完成
            if self.TaskType_Normal == v.taskTime then
                --if v.id >=1 and v.id <= 18 then
                --    table.insert( passCheck.tasks , { id = v.id , type = v.taskTime , kind = v.taskType , progress = 0 , status = skynet.server.task.TaskStatus_AlreadyGet})
                --else
                    table.insert( passCheck.tasks , { id = v.id , type = v.taskTime , kind = v.taskType , progress = 0 , status = skynet.server.task.TaskStatus_NoComplete})
                --end            
            elseif self.TaskType_LimitTime == v.taskTime then
                --if v.id >=21 and v.id <= 39 then
                --    table.insert( passCheck.tasks , { id = v.id , type = v.taskTime , kind = v.taskType , progress = 0 , status = skynet.server.task.TaskStatus_OutOfTime , endTime = 0})
                --else
                    table.insert( passCheck.tasks , { id = v.id , type = v.taskTime , kind = v.taskType , progress = 0 , status = skynet.server.task.TaskStatus_NoComplete , endTime = 0})
                --end
            elseif self.TaskType_Daily == v.taskTime then
                table.insert( passCheck.tasks , { id = v.id , type = v.taskTime , kind = v.taskType , progress = 0 , status = skynet.server.task.TaskStatus_NoComplete })
            end
        end
    end
end

--通行证奖励显示
function PassCheck:RewardShow( player ,  c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SPassCheckRewardShow", c2sData.data ))
    local passCheck = player.gameData.passCheck
    self:CheckNew( player )
    self:CheckMsgTips( player )
    local curInfiniteRewardID = passCheck.curId * self.infiniteRewardID
    local curCfgPassCheckClass =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckClass" , curInfiniteRewardID )
    local rewardLevel,rewardScore = self:GetRewardLevel( player )
    local isGetInfiniteReward = false
    if curCfgPassCheckClass and passCheck.infiniteScore >= curCfgPassCheckClass.Integral and rewardLevel >= curCfgPassCheckClass.level then
        --无限奖励分数已经够了
        isGetInfiniteReward = true
    end

    for k, v in pairs( passCheck.rewards ) do
        --无限奖励没有领取完，就能获取
        if curInfiniteRewardID == v.id then 
            if dataType.RewardStatus_AlreadyGet ~= v.payStatus and isGetInfiniteReward then
                v.payStatus = dataType.RewardStatus_CanGet
            else
                v.payStatus = dataType.RewardStatus_NoGet
            end
            break
        end
    end
    
    self:CheckInfiniteReward( player )

    local data = {}
    data.basicInfo = { score = passCheck.score , surplusTime = self.surplusTime , passCheckId = passCheck.curId }
    data.rewards = passCheck.rewards
    data.isVip = passCheck.isVip
    data.infiniteRewardCount = passCheck.infiniteRewardCount

    s2cData.cmd = pb.enum("MsgType","CMD_S2C_PassCheckRewardShow")
    s2cData.data = assert(pb.encode("S2CPassCheckRewardShow", data))
end

--获得当前期配置
function PassCheck:GetCurPeriodCfg( player )
    local curCfgPassCheck = nil

    local activityId = skynet.server.activity:GetActivityInfo( player , dataType.ActivityType_PassCheck )
    if activityId > 0 then
        local cfgPassCheck = skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheck" , activityId)
        curCfgPassCheck = cfgPassCheck                                     --获取当前通行证信息
    end

    return curCfgPassCheck
end

--随机任务
function PassCheck:GetRandTask( player , curCfgPassCheck )
    --打乱现有配置顺序
    local cfgPassCheckTask = skynet.server.gameConfig:GetPlayerAllCfg( player , "PassCheckTask")                --任务配置
    local tmpCfgPassCheckTask = {}
    local level = player.gameData.level
    for k, v in pairs(cfgPassCheckTask) do
        if level >= v.taskLevel then                                        --达到等级要求才能加入
            --每日任务直接加入
            if self.TaskType_Daily  == v.taskTime then 
                v.randValue = 0
                table.insert(tmpCfgPassCheckTask , v)
            else
                --常规和限时任务部分任务才能加入
                if self:IsJoinTask( curCfgPassCheck , v.taskTime , v.id ) then
                    v.randValue = math.random(1,1000)
                    table.insert(tmpCfgPassCheckTask , v)
                end
            end
        end
    end

    --根据随机值进行排序
    table.sort(tmpCfgPassCheckTask , function (a,b)
        if a.randValue >b.randValue then            --降序
            return
        end
    end)
    return tmpCfgPassCheckTask
end

--获取普通奖励信息
function PassCheck:GetNormalReward( player , rewardId )
    local isGainReward = false
    local getRewardIds = {}         --奖励的信息
    local passCheck = player.gameData.passCheck
    local curCfgPassCheckClass =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckClass" , rewardId )
    local curCfgPassCheck =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheck" , passCheck.curId )

    --获取当前奖励信息
    local curReward = {}
    for k, v in pairs( passCheck.rewards ) do
        if rewardId == v.id then
            curReward = v
            break
        end
    end

    --非无限奖励领奖
    if dataType.RewardStatus_CanGet == curReward.normalStatus then                                              --普通奖励
        for k, v in pairs( curCfgPassCheckClass.normalReward ) do
            table.insert( getRewardIds , v )
        end
        curReward.normalStatus = dataType.RewardStatus_AlreadyGet
        isGainReward =true
        log.debug(string.format("玩家 %d 通行证 普通奖励获取 奖励ID %d" , player.userId, rewardId))
    end

    if passCheck.isVip and dataType.RewardStatus_CanGet == curReward.payStatus then                  --付费奖励
        for k, v in pairs( curCfgPassCheckClass.payReward ) do
            table.insert( getRewardIds , v )
        end
        curReward.payStatus = dataType.RewardStatus_AlreadyGet
        isGainReward =true
        log.debug(string.format("玩家 %d 通行证 付费奖励获取 奖励ID %d", player.userId , rewardId))
    end

    --发奖
    for k, v in pairs( getRewardIds ) do
        local eventId = pb.enum("EnumMoneyChangeEventID","EventID_60")
        player:GiveReward( v , eventId )
    end

    return getRewardIds,isGainReward
end

--获取无限奖励信息
function PassCheck:GetInfiniteReward( player , rewardId , s2cData)
    local isGainReward = false
    local getRewardIds = {}         --奖励的信息
    local passCheck = player.gameData.passCheck

    local curCfgPassCheckClass =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckClass" , rewardId )
    local curCfgPassCheck =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheck" , passCheck.curId )
    local data = {}
    local rewardLevel,rewardScore = self:GetRewardLevel( player )

    if passCheck.infiniteRewardCount >= curCfgPassCheck.ultimateLimit then
        s2cData.code = errorInfo.ErrorCode.MaxLimit
        return data,isGainReward
    elseif rewardLevel < curCfgPassCheckClass.level then 
        s2cData.code = errorInfo.ErrorCode.ErrRequestParam
        return data,isGainReward
    elseif passCheck.infiniteScore < curCfgPassCheckClass.Integral then
        s2cData.code = errorInfo.ErrorCode.NoEnoughPoint
        return data,isGainReward
    elseif not passCheck.isVip then
        return data,isGainReward
    else
        --获取当前奖励信息
        local curReward = {}
        for k, v in pairs( passCheck.rewards ) do
            if rewardId == v.id then
                curReward = v
                break
            end
        end

        if dataType.RewardStatus_CanGet == curReward.payStatus then                                              --普通奖励
            curReward.payStatus = dataType.RewardStatus_NoGet
            passCheck.infiniteScore = rewardScore
            --发奖
            local weight = curCfgPassCheckClass.ultimateRewardWeight
            local allWeight = 0

            --计算权重总数
            for k, v in pairs( weight ) do
                allWeight = allWeight + v
            end

            --在1和总权重进行随机
            local rand = math.random(1 , allWeight)
            log.debug(string.format("玩家 %d 通行证 随机值 %d 随机区间[ %d , %d ]" , player.userId , rand , 1, allWeight))
            local curCount = 0
            local weightIndex = 0
            for k, v in pairs( weight ) do
                curCount = curCount + v
                if rand <= curCount then
                    weightIndex = k
                    break
                end
            end
            local eventId = pb.enum("EnumMoneyChangeEventID","EventID_60")
            for k, v in pairs( curCfgPassCheckClass.ultimateReward ) do
                data = player:SelectOneReward( v , weightIndex , eventId)
            end

            passCheck.infiniteRewardCount = passCheck.infiniteRewardCount + 1
            --无线领奖状态修改为已获取
            if passCheck.infiniteRewardCount >= curCfgPassCheck.ultimateLimit then
                curReward.payStatus = dataType.RewardStatus_AlreadyGet
            end

            isGainReward = true
            log.debug(string.format("玩家 %d 通行证 无限奖励获取 奖励索引 %d" , player.userId , weightIndex))
        end
        return data,isGainReward
    end
end

--通行证奖励获取
function PassCheck:RewardGet( player ,  c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SPassCheckRewardGet", c2sData.data ))
    local rewardId =  c2sData.data.rewardId

    local data = {}
    data.gainRewards = {}
    data.infiniteMoneys = {}
    if not rewardId then
        s2cData.code = errorInfo.ErrorCode.ErrRequestParam
    else
        local getRewardIds = {}          --获取奖励的ID
        local passCheck = player.gameData.passCheck
        local getRewardIds = {}

        if 0 == rewardId % 31 then 
            local rewardInfo,isGainReward = self:GetInfiniteReward( player , rewardId , s2cData )
            if isGainReward then
                table.insert( data.infiniteMoneys  ,rewardInfo )
            end

            self:CheckInfiniteReward( player )
        else
            data.gainRewards = self:GetNormalReward( player , rewardId )       --当前奖励信息
        end

        for k, v in pairs( passCheck.rewards ) do
            if rewardId == v.id then
                data.reward = v
                break
            end
        end

        data.infiniteRewardCount = passCheck.infiniteRewardCount
    end

    self:CheckMsgTips( player )
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_PassCheckRewardGet")
    s2cData.data = assert(pb.encode("S2CPassCheckRewardGet", data))
end

--通行证奖励一键获取
function PassCheck:RewardAllGet( player ,  c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SPassCheckRewardAllGet", c2sData.data ))

    local data = {}
    data.rewards = {}
    data.gainRewards = {}
    data.infiniteMoneys = {}
    local getRewardIds = {}          --获取奖励的ID
    local passCheck = player.gameData.passCheck
    for k1, v1 in pairs( passCheck.rewards ) do
        if 0 == v1.id % 31 then 
            local curCfgPassCheck =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheck" , passCheck.curId )
            local gainCount = curCfgPassCheck.ultimateLimit - passCheck.infiniteRewardCount
            if gainCount > 0 then
                for i = 1, gainCount, 1 do
                    local rewardInfo,isGainReward = self:GetInfiniteReward( player , v1.id , s2cData )
                    s2cData.code = errorInfo.Suc
                    if isGainReward then
                        table.insert( data.infiniteMoneys  ,rewardInfo )
                        table.insert( data.rewards , v1 )
                    end
                    self:CheckInfiniteReward( player )
                end
            end
        else
            local gainRewards,isGainReward = self:GetNormalReward( player , v1.id )       --当前奖励信息
            for k, v in pairs(gainRewards) do
                table.insert(data.gainRewards ,v)
            end

            if isGainReward then
                table.insert( data.rewards , v1 )
            end
        end
    end

    self:CheckMsgTips( player )
    data.infiniteRewardCount = passCheck.infiniteRewardCount
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_PassCheckRewardAllGet")
    s2cData.data = assert(pb.encode("S2CPassCheckRewardAllGet", data))
end

--通行证任务显示
function PassCheck:TaskShow( player ,  c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SPassCheckTaskShow", c2sData.data ))
    local taskType =  c2sData.data.taskType
    local data = {}

    if not taskType then
        s2cData.code = errorInfo.ErrorCode.ErrRequestParam
    else
        self:CheckNew( player )
        self:CheckOutOfTask( player )
        self:CheckMsgTips( player )
        local passCheck = player.gameData.passCheck
        data.taskType = taskType
        data.basicInfo = { score = passCheck.score , surplusTime = self.surplusTime }
        --获取任务信息
        data.taskInfos = self:GetShowTaskData( player , taskType )
    end

    s2cData.cmd = pb.enum("MsgType","CMD_S2C_PassCheckTaskShow")
    s2cData.data = assert(pb.encode("S2CPassCheckTaskShow", data))
end

--通行证任务获取
function PassCheck:TaskGet( player ,  c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SPassCheckTaskGet", c2sData.data ))
    local taskType =  c2sData.data.taskType
    local taskId =  c2sData.data.taskId
    local data = {}

    if not taskType or not taskId then
        s2cData.code = errorInfo.ErrorCode.ErrRequestParam
    else
        local passCheck = player.gameData.passCheck

        local curTask = self:GetTaskInfo( player , taskType , taskId )
        if curTask.status == skynet.server.task.TaskStatus_AlreadyComplete then                 --已经完成才能领取
            local curCfgPassCheckTask =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckTask" , taskId )
            --local passCheck = player.gameData.passCheck
            --curCfgPassCheckTask.taskPoint = 50000  --测试要删除
            passCheck.score = passCheck.score + curCfgPassCheckTask.taskPoint
            passCheck.infiniteScore = passCheck.infiniteScore + curCfgPassCheckTask.taskPoint

            --领取了积分修改已经领取状态
            curTask.status = skynet.server.task.TaskStatus_AlreadyGet
            --检查下普通和付费奖励是否能领取
            self:CheckNormalReward( player )
            self:CheckPayReward( player )
            log.debug(string.format("玩家 %d 通行证 任务完成领取积分 任务ID %d" , player.userId ,taskId))
        else
            s2cData.code = errorInfo.ErrorCode.GetAwardFailed
        end
        data.taskType = taskType
        data.basicInfo = { score = passCheck.score , surplusTime = self.surplusTime }
        data.taskInfo = self:GetShowTaskData( player , taskType )
    end
    self:CheckMsgTips( player )
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_PassCheckTaskGet")
    s2cData.data = assert(pb.encode("S2CPassCheckTaskGet", data))
end

--通行证充值
function PassCheck:Pay( player , storeId )
    local cfgSValue = skynet.server.gameConfig:GetPlayerAllCfg( player , "SValue")
    local passCheck = player.gameData.passCheck

    passCheck.isVip = true              --开起VIP
    passCheck.score = passCheck.score + cfgSValue.passcheckPayPoints        --充值后默认给点分数
    passCheck.infiniteScore = passCheck.infiniteScore + cfgSValue.passcheckPayPoints

    --修改玩家的充值相关信息
    skynet.server.store:ChangePayInfo( player , storeId )
    --充值了，检查下玩家的是否能领取付费礼包
    self:CheckNormalReward( player )
    self:CheckPayReward( player )
    self:CheckMsgTips( player )
end

--通行证修改任务
function PassCheck:Modify( player , kind , count )
    if not player:IsUnlockSystem( dataType.UnlockSystem_PassCheck ) then
        return
    end

    if 0 == count then
        return
    end

    log.debug(string.format("玩家 %d 通行证 任务修改 种类 %d 数量 %d" , player.userId , kind , count ))
    local maxProgress = 0
    local passCheck = player.gameData.passCheck

    for k, v in pairs( passCheck.tasks ) do
        if (self.TaskType_Normal == v.type or self.TaskType_LimitTime == v.type) and kind == v.kind and skynet.server.task.TaskStatus_NoComplete == v.status and self:IsShowTask( player , v.type ,  v.id ) then
            --获取最大进度
            maxProgress = skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckTask" , v.id ).taskNum
            v.progress = v.progress + count
            --检查是否完成任务
            if v.progress >= maxProgress then
                v.status =skynet.server.task.TaskStatus_AlreadyComplete
                self:CheckMsgTips( player )
                v.progress = maxProgress
                log.debug(string.format("玩家 %d 通行证 任务种类 %d 任务ID %d 完成 " , player.userId , kind ,v.id))
            end
        end
    end

    --每日任务统计
    for k, v in pairs( passCheck.tasks ) do
        if self.TaskType_Daily == v.type and kind == v.kind then
            local curCfgPassCheckTask =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckTask" , v.id )
            if v.progress < curCfgPassCheckTask.limit then
                --每日任务直接更新积分
                v.progress =  v.progress + 1
                --curCfgPassCheckTask.taskPoint = 50000  --测试要删除
                passCheck.score = passCheck.score + curCfgPassCheckTask.taskPoint
                passCheck.infiniteScore = passCheck.infiniteScore + curCfgPassCheckTask.taskPoint

                --检查下普通和付费奖励是否能领取
                self:CheckNormalReward( player )
                self:CheckPayReward( player )
                log.debug(string.format("玩家 %d 通行证 任务种类 %d 任务ID %d 完成 " , player.userId , kind ,v.id))
            end
        end
    end
end

--检查能领取的普通奖励
function PassCheck:CheckNormalReward( player )
    local passCheck = player.gameData.passCheck
    local rewardLevel,rewardScore = self:GetRewardLevel( player )
    for k, v in pairs( passCheck.rewards ) do
        local curCfg = skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckClass" , v.id )
        --检查可以领取的普通奖励
        if not self:IsInfiniteID( v.id ) and curCfg.level <= rewardLevel and dataType.RewardStatus_NoGet == v.normalStatus then
            v.normalStatus = dataType.RewardStatus_CanGet
        elseif curCfg.level > rewardLevel then
            break
        end
    end
end

--检查能领取的付费奖励
function PassCheck:CheckPayReward( player )
    local passCheck = player.gameData.passCheck

    if passCheck.isVip then
        local rewardLevel,rewardScore = self:GetRewardLevel( player )
        --开通了VIP才给付费奖励
        for k, v in pairs( passCheck.rewards ) do
            local curCfg = skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckClass" , v.id )
            --无法领取的付费奖励状态都设为可领取
            if not self:IsInfiniteID( v.id ) and curCfg.level <= rewardLevel and dataType.RewardStatus_NoGet == v.payStatus then
                v.payStatus = dataType.RewardStatus_CanGet
            elseif self:IsInfiniteID( v.id ) and dataType.RewardStatus_AlreadyGet ~= v.payStatus then
                local curInfiniteRewardID = passCheck.curId * self.infiniteRewardID
                local curCfgPassCheckClass =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckClass" , curInfiniteRewardID )
                if curCfgPassCheckClass and passCheck.infiniteScore >= curCfgPassCheckClass.Integral then                   --无限奖励分数已经够了
                    v.payStatus = dataType.RewardStatus_CanGet
                end
            elseif curCfg.level > rewardLevel then
                break
            end
        end
    end
end

--是否为无限ID
function PassCheck:IsInfiniteID( id )
    if 0 == id % 31 then
        return true
    end
    return false
end

--获取奖励等级
function PassCheck:GetRewardLevel( player )
    local score = player.gameData.passCheck.score
    local curId = player.gameData.passCheck.curId               --当前期ID
    local tmpScore = 0                                                            --除去等级后剩余分数

    local level = 0
    local whileCount = 0        --防止死循环
    local cfgPassCheckClass = skynet.server.gameConfig:GetPlayerAllCfg( player , "PassCheckClass")        --奖励配置
    for k, v in pairs( cfgPassCheckClass ) do
        if curId == v.passCheckId then
            if self:IsInfiniteID( v.id ) then
                --无限ID会一直减无限ID的积分
                while true do
                    score = score - v.Integral
                    if score < 0 then
                        tmpScore = score + v.Integral
                        break
                    end
                    level = level + 1

                    whileCount = whileCount + 1
                    if whileCount >= 200 then
                        break
                    end
                end
            else 
                --非无限ID会减当前配置的积分
                score = score - v.Integral
                if score < 0 then
                    tmpScore = score + v.Integral
                    break
                end
                level = level + 1
            end
        end
    end

    return level,tmpScore
end

--获取任务信息
function PassCheck:GetTaskInfo( player , taskType , taskId )
    local passCheck = player.gameData.passCheck
    for k, v in pairs( passCheck.tasks ) do
        if taskType == v.type and taskId == v.id then
            return v
        end
    end    
    return nil
end

--检查有不有消息提示
function PassCheck:CheckMsgTips( player )
    local passCheck = player.gameData.passCheck
    if 0 == passCheck.curId then
        return
    end
    
    local isHaveInfinite = true
    local curCfgPassCheck =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheck" , passCheck.curId )
    if passCheck.infiniteRewardCount >= curCfgPassCheck.ultimateLimit then
        isHaveInfinite = false
    end

    local isRedPoint = false
    skynet.server.msgTips:Reset( player , 24 )
    for k, v in pairs( passCheck.rewards ) do
        if self:IsInfiniteID( v.id ) and not isHaveInfinite then
            --没有无限奖励，把无限奖励的状态设置一下
            v.normalStatus = dataType.RewardStatus_AlreadyGet
            v.payStatus = dataType.RewardStatus_AlreadyGet
        end
        
        if dataType.RewardStatus_CanGet == v.normalStatus  or (true == passCheck.isVip and dataType.RewardStatus_CanGet == v.payStatus) then        --空了看下payStatus初始状态为啥是RewardStatus_CanGet
            isRedPoint = true
        end
    end

    if isRedPoint then
        skynet.server.msgTips:Add( player , 24 )
    end
    
    skynet.server.msgTips:Reset( player , 25 )
    for k, v in pairs( passCheck.tasks ) do
        if self.TaskType_Normal == v.type and skynet.server.task.TaskStatus_AlreadyComplete == v.status and self:IsShowTask( player , v.type , v.id ) then  
            skynet.server.msgTips:Add( player , 25 )
            break
        end
    end

    skynet.server.msgTips:Reset( player , 26 )
    for k, v in pairs( passCheck.tasks ) do
        if self.TaskType_LimitTime == v.type and skynet.server.task.TaskStatus_AlreadyComplete == v.status and self:IsShowTask( player , v.type , v.id ) then
            skynet.server.msgTips:Add( player , 26 )
            break
        end
    end

    skynet.server.msgTips:SendLastTips( player , 24)
    skynet.server.msgTips:SendLastTips( player , 25)
    skynet.server.msgTips:SendLastTips( player , 26)
end

--获取数量
function PassCheck:GetTaskData( player , taskType )
    local data = {}
    local passCheck = player.gameData.passCheck
    local count = 0

    local isArchieveStyle = false           --是否完成了造型间
    local cfgStyleList = skynet.server.gameConfig.StyleList
    local cfgCount = #cfgStyleList - 2     --不晓得为啥配置会多两个,客户端界面上只能完成15个，配置有17个。
    local curShop = player.gameData.shop[ dataType.ShopType_Style ]
    if curShop and curShop.curStyleId > cfgCount then
        isArchieveStyle = true
    end

    local listTaskScene = {}                --存在的任务场景
    --是否存在任务场景
    local function IsExistTaskScene( sceneId )
        for k, v in pairs( listTaskScene ) do
            if sceneId == v then
                return true
            end            
        end
        return false
    end

    for k, v in pairs( passCheck.tasks ) do
        if count >= self.MaxShowItem then
            break
        end

        local cfgCurPassCheckTask = skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckTask" , v.id )
        --限时任务超过时间就改为过期状态
        if self.TaskType_LimitTime == v.type and skynet.server.task.TaskStatus_OutOfTime ~= v.status and skynet.GetTime() >= v.endTime and 0 ~=v.endTime then  
            v.status = skynet.server.task.TaskStatus_OutOfTime
        end

        if isArchieveStyle and taskType == v.type and 12 == v.kind then
            --造型间如果已经完成了，就关闭相关任务
            v.status = skynet.server.task.TaskStatus_AlreadyGet
        end

        --未完成和已完成并且没有相同任务才会显示
        if  taskType == v.type 
            and (skynet.server.task.TaskStatus_NoComplete == v.status or skynet.server.task.TaskStatus_AlreadyComplete == v.status) then

            --取消同种类型判断
            --and not IsExistTaskScene( cfgCurPassCheckTask.taskScene ) then
            if (self.TaskType_Normal == taskType or self.TaskType_Daily == taskType) and taskType == v.type then         
                --常规任务和每日任务
                table.insert( data ,  { id = v.id , progress = v.progress , status = v.status , endTime = 0})
                --table.insert( listTaskScene , cfgCurPassCheckTask.taskScene )
                count = count + 1
            elseif self.TaskType_LimitTime == taskType and taskType == v.type then  
                --限时任务有个截止时间
                if 0 == v.endTime then
                    local runTime = cfgCurPassCheckTask.timeNum * 86400
                    local endTime = skynet.GetTime() + runTime
                    v.endTime = endTime
                end
                table.insert( data ,  { id = v.id , progress = v.progress , status = v.status , endTime = v.endTime })
                --table.insert( listTaskScene , cfgCurPassCheckTask.taskScene )
                count = count + 1
            end
        end
    end
    return data,count
end

--获取显示的任务信息
function PassCheck:GetShowTaskData( player , taskType )
    local data = {}
    local count = 0

    --获取下任务数据
    data,count = self:GetTaskData( player , taskType )

    --如果找出来的数量小于指定数量
    if count < self.MaxShowItem then
        local passCheck = player.gameData.passCheck
        local tmpCount = self.MaxShowItem - count          --需要补足多少个任务
        
        --找出能够恢复的任务
        local allRandTask = {}
        for k, v in pairs( passCheck.tasks ) do
            if skynet.server.task.TaskStatus_AlreadyGet== v.status or skynet.server.task.TaskStatus_OutOfTime == v.status then
                local isAdd = true
                if 12 == v.kind then
                    local cfgCount = skynet.server.gameConfig:GetPlayerAllCfg( player , "StyleList")     --设计奖励配置数量
                    local rewardsCount = #player.gameData.shop[ dataType.ShopType_Style ].gainRewards    --已经获取的奖励数量
                    local count = #cfgCount - rewardsCount
                    local curCfgPassCheckTask = skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheckTask" , v.id )
                    if count < curCfgPassCheckTask.taskNum then           --小于数量就不再添加
                        isAdd = false
                    end
                end

                if isAdd then
                    table.insert( allRandTask , { id = v.id })    
                end
            end
        end

        --随机指定数量
        local randTask = skynet.server.shop:GetNoRepeatGoods( tmpCount , allRandTask )
        for k1, v1 in pairs( randTask ) do
            for k2, v2 in pairs( passCheck.tasks ) do
                if v1 == v2.id then
                    --任务重置
                    v2.status = skynet.server.task.TaskStatus_NoComplete
                    v2.progress = 0

                    --限时任务需要多重置个截止时间
                    if self.TaskType_LimitTime == taskType and taskType == v2.type then  
                        v2.endTime = 0
                    end
                end
            end
        end

        --再获取下任务数据
        data,count = self:GetTaskData( player , taskType )
    end
    return data
end

--是否显示中的任务
function PassCheck:IsShowTask( player , taskType , taskId )
    local allTask = self:GetShowTaskData( player , taskType )
    for k, v in pairs(allTask) do
        if taskId == v.id then
            return true
        end
    end
    return false
end

--是否加入任务
function PassCheck:IsJoinTask( curCfgPassCheck , taskType , taskId )
    if self.TaskType_Normal == taskType then
        for k, v in pairs( curCfgPassCheck.normalTask ) do
            if taskId == v then
                return true
            end
        end
    elseif self.TaskType_LimitTime == taskType then
        for k, v in pairs( curCfgPassCheck.limitTask ) do
            if taskId == v then
                return true
            end
        end
    end
    return false
end

--检查是否有过期任务
function PassCheck:CheckOutOfTask( player )
    local passCheck = player.gameData.passCheck
    for k, v in pairs( passCheck.tasks ) do
        if skynet.server.task.TaskStatus_NoComplete == v.status and ( 5 == v.kind or 6 == v.kind ) then
            local clothesBuyCount = passCheck.clothesBuyCount               --我已经在逸家小店购买的衣服数量
            local cfgClothesCount = 0                                                           --配置中逸家小店衣服数量
            local cfgAllClothes = skynet.server.gameConfig:GetPlayerAllCfg( player , "Clothes")
            for k, v in pairs( cfgAllClothes ) do
                if 1 == v.shopType and ( v.type == dataType.ClothesType_HeadWear or v.type == dataType.ClothesType_Clothes
                        or  v.type == dataType.ClothesType_Trousers or v.type == dataType.ClothesType_Shoes )  then
                    cfgClothesCount = cfgClothesCount + 1
                end
            end

            local cfgAllPetClothes = skynet.server.gameConfig:GetPlayerAllCfg( player , "PetClothes")
            for k, v in pairs( cfgAllPetClothes ) do
                if 1 == v.shopType then
                    cfgClothesCount = cfgClothesCount + 1
                end
            end

            --我已经购买了所有衣服，该任务就完成
            if clothesBuyCount >= cfgClothesCount then
                v.status = skynet.server.task.TaskStatus_AlreadyGet
            end
        elseif skynet.server.task.TaskStatus_NoComplete == v.status and v.kind == 32 then
            --如果家园等级满了 则该任务就完成
            local groupId = skynet.server.group:GetGroupID( player )
            local groupInfo = skynet.server.group:GetGroup( groupId )
            if groupInfo and groupInfo.communityLevel == 5 then
                v.status = skynet.server.task.TaskStatus_AlreadyGet
            end
        end
    end   
end

--检查是否还有无限奖励
function PassCheck:CheckInfiniteReward( player )
    local passCheck = player.gameData.passCheck
    --玩家30级，检查一下是否有没有领取的通行证无限奖励
    local rewardLevel,rewardScore = self:GetRewardLevel( player )
    if rewardLevel > 30 then
        local curCfgPassCheck =  skynet.server.gameConfig:GetPlayerCurCfg( player , "PassCheck" , passCheck.curId )
        local needCount = ( rewardLevel - 30 ) - passCheck.infiniteRewardCount
        if needCount > 0 and passCheck.infiniteRewardCount < curCfgPassCheck.ultimateLimit then
            passCheck.infiniteScore = 1000
            self:CheckPayReward( player )
        end
    end
end

-- 定义一个回调函数
local function onEventFired(player , taskId , count)

    --原有处理逻辑
    PassCheck:Modify(player,taskId,count)
end

-- 注册事件处理函数
taskListEvent:Register(onEventFired,"通行证任务")

skynet.server.passCheck = PassCheck
return PassCheck