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 ActivityLabyrinth = oo.class()

ActivityLabyrinth.ActivityType = dataType.ActivityType_Labyrinth

ActivityLabyrinth.ChestType_award = 1           --奖励宝箱
ActivityLabyrinth.ChestType_punish = 2          --惩罚宝箱

--根据玩家的配置获取不同的数据
ActivityLabyrinth.ActivityInfo = {}

local configType = skynet.server.gameConfig:GetConfigType( "Main" , 1 )
ActivityLabyrinth.ActivityInfo[ configType ] = {}
ActivityLabyrinth.ActivityInfo[ configType ].ActivityId = 0              --该活动在配置中的id
ActivityLabyrinth.ActivityInfo[ configType ].VoluteCoinPrice = 0         --蜗壳币购买机会价格
ActivityLabyrinth.ActivityInfo[ configType ].VoluteCoinSkip = 0          --跳过惩罚的蜗壳币
ActivityLabyrinth.ActivityInfo[ configType ].StartTime = 0               --迷宫活动的开始时间
ActivityLabyrinth.ActivityInfo[ configType ].EndTime = 0                 --迷宫活动的结束时间

configType = skynet.server.gameConfig:GetConfigType( "A" , 1 )
ActivityLabyrinth.ActivityInfo[ configType ] = {}
ActivityLabyrinth.ActivityInfo[ configType ].ActivityId = 0                 --该活动在配置中的id
ActivityLabyrinth.ActivityInfo[ configType ].VoluteCoinPrice = 0            --蜗壳币购买机会价格
ActivityLabyrinth.ActivityInfo[ configType ].VoluteCoinSkip = 0             --跳过惩罚的蜗壳币
ActivityLabyrinth.ActivityInfo[ configType ].StartTime = 0                  --迷宫活动的开始时间
ActivityLabyrinth.ActivityInfo[ configType ].EndTime = 0                    --迷宫活动的结束时间

configType = skynet.server.gameConfig:GetConfigType( "B" , 1 )
ActivityLabyrinth.ActivityInfo[ configType ] = {}
ActivityLabyrinth.ActivityInfo[ configType ].ActivityId = 0                 --该活动在配置中的id
ActivityLabyrinth.ActivityInfo[ configType ].VoluteCoinPrice = 0            --蜗壳币购买机会价格
ActivityLabyrinth.ActivityInfo[ configType ].VoluteCoinSkip = 0             --跳过惩罚的蜗壳币
ActivityLabyrinth.ActivityInfo[ configType ].StartTime = 0                  --迷宫活动的开始时间
ActivityLabyrinth.ActivityInfo[ configType ].EndTime = 0                    --迷宫活动的结束时间

function ActivityLabyrinth:Init()

end

--设置活动信息
function ActivityLabyrinth:SetLabyrinthInfo( player , keyName , keyValue )
    local configType = player.basicInfo.configType
    self.ActivityInfo[ configType ][ keyName ] = tonumber(keyValue)
end

--获取活动信息
function ActivityLabyrinth:GetLabyrinthInfo( player , keyName )
    local configType = player.basicInfo.configType
    return self.ActivityInfo[ configType ][ keyName ]
end

--玩家礼包数据初始化
function ActivityLabyrinth:InitData( player , activityType )
    --迷宫数据
    local activityId,startTime,endTime = skynet.server.activity:GetActivityInfo( player , activityType )
    if activityId > 0 then
        self:SetLabyrinthInfo( player , "ActivityId" , activityId)    --获取满足开放时间的迷宫id
        self:SetLabyrinthInfo( player , "StartTime" , startTime)      --迷宫开始时间
        self:SetLabyrinthInfo( player , "EndTime" , endTime)          --迷宫结束时间
    end
    --判断一下是否需要初始化玩家数据
    if player.gameData.activity[ activityType ] == nil or activityId == 0 then
        --玩家迷宫活动相关数据
        player.gameData.activity[ activityType ] = {}
    end
    local cfgActivity = skynet.server.gameConfig:GetPlayerAllCfg( player , "Activity")
    local level = 0
    for k , v in pairs(cfgActivity) do
        if v.activityType == dataType.ActivityType_Labyrinth then                             --活动迷宫
            level = v.level
            break
        end
    end
    if activityId > 0 and player.gameData.level >= level and next(player.gameData.activity[ activityType ]) == nil 
        and (player.gameData.activity[ activityType ].activityId == nil or player.gameData.activity[ activityType ].activityId ~= activityId) then
        --玩家对应配置
        local cfgMazeTreasure = skynet.server.gameConfig:GetPlayerAllCfg( player , "MazeTreasure")
        local cfgMazeMap = skynet.server.gameConfig:GetPlayerAllCfg( player , "MazeMap")
        local MazeTreasure = cfgMazeTreasure[ activityId ]                                      --迷宫活动相关数据
        self:SetLabyrinthInfo( player , "VoluteCoinPrice" , MazeTreasure.voluteCoinPrice ) --蜗壳币购买机会价格
        for k , v in pairs(cfgMazeMap) do
            if v.actId == activityId then
                self:SetLabyrinthInfo( player , "VoluteCoinSkip" , v.voluteCoinSkip )  --跳过惩罚所需蜗壳币
                break
            end
        end
        player.gameData.activity[ activityType ].activityId = activityId
        player.gameData.activity[ activityType ].labyrinthInfos = {}                            --玩家迷宫的相关信息
        player.gameData.activity[ activityType ].compassCount = MazeTreasure.freeChance         --玩家拥有的指南针
        player.gameData.activity[ activityType ].nowLabyrinthData = {}                          --本次游玩迷宫的相关信息
        player.gameData.activity[ activityType ].rewardInfos = {}                               --玩家迷宫的累计奖励信息
        --玩家迷宫数据赋值
        for i=1,#MazeTreasure.mazeMapId,1 do
            player.gameData.activity[ activityType ].labyrinthInfos[ i ] = {}
            player.gameData.activity[ activityType ].labyrinthInfos[ i ].labyrinthLevel = i                     --当前迷宫等级
            player.gameData.activity[ activityType ].labyrinthInfos[ i ].status = 1                             --当前迷宫状态 1-未解锁 2-已解锁
            player.gameData.activity[ activityType ].labyrinthInfos[ i ].finishCount = 0                        --当前迷宫的完成次数
        end
        local count = 1
        for k ,v in pairs(MazeTreasure.accumulateReward) do
            local rewardInfo = skynet.server.common:Split( v ,"_" )
            rewardInfo[1],rewardInfo[2] = tonumber(rewardInfo[1]),tonumber(rewardInfo[2])
            player.gameData.activity[ activityType ].rewardInfos[count] = {}
            player.gameData.activity[ activityType ].rewardInfos[count].id = count
            player.gameData.activity[ activityType ].rewardInfos[count].status = 0   --0 不可领取 1 可以领取 2 已经领取
            player.gameData.activity[ activityType ].rewardInfos[count].needCount = rewardInfo[1]
            player.gameData.activity[ activityType ].rewardInfos[count].rewardId = rewardInfo[2]
            count = count + 1
        end
        --第一个难度默认解锁
        player.gameData.activity[ activityType ].labyrinthInfos[ 1 ].status = 2                 --当前迷宫状态 1-未解锁 2-已解锁
        --开始走迷宫的数据
        player.gameData.activity[ activityType ].nowLabyrinthData.level = 0             --本次游玩的迷宫等级
        player.gameData.activity[ activityType ].nowLabyrinthData.labyrinthBags = {}    --本次游玩奖励背包
        player.gameData.activity[ activityType ].nowLabyrinthData.havePunish = false    --本次游玩是否还有惩罚
        player.gameData.activity[ activityType ].nowLabyrinthData.rewardIds = {}        --本次游玩中宝箱的奖励id集合
    end
end

--每次登录需要进行修改的数据
function ActivityLabyrinth:LoginInitData( player )
    --重置迷宫红点
    skynet.server.msgTips:Reset(player , 76)
    skynet.server.msgTips:Reset(player , 77)
    --检查应该初始还是结束活动
    local cfgActivity = skynet.server.gameConfig:GetPlayerAllCfg( player , "Activity")
    local level = 0
    for k , v in pairs(cfgActivity) do
        if v.activityType == dataType.ActivityType_Labyrinth then                             --活动迷宫
            level = v.level
            break
        end
    end
    if self:GetLabyrinthInfo( player , "ActivityId" ) == 0 and player.gameData.level >= level then
        self:InitData(player , self.ActivityType)
    else
        --判断当前时间是否应该结束迷宫活动
        if skynet.GetTime() > self:GetLabyrinthInfo( player , "EndTime" ) then
            self:SetLabyrinthInfo( player , "ActivityId" , 0)     --获取满足开放时间的迷宫id
            self:SetLabyrinthInfo( player , "StartTime" , 0)      --迷宫开始时间
            self:SetLabyrinthInfo( player , "EndTime" , 0)        --迷宫结束时间
            --初始玩家数据
            player.gameData.activity[ self.ActivityType ] = {}
        end
    end
    --红点系统
    if player.gameData.activity[ self.ActivityType ] and next(player.gameData.activity[ self.ActivityType ]) ~= nil then
        --有指南针可以使用 添加对应红点
        if player.gameData.activity[ self.ActivityType ].compassCount > 0 then
            skynet.server.msgTips:AddNoNotice(player , 77)
        end
        --有累计奖励可以使用 添加对应红点
        for k , v in pairs(player.gameData.activity[ self.ActivityType ].rewardInfos) do
            if v.status == 1 then
                skynet.server.msgTips:AddNoNotice(player , 76)
            end
        end
    end
end

--迷途寻宝 展示
function ActivityLabyrinth:Show( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityLabyrinthShow", c2sData.data ))
    local data = {}
    --判断一下是否需要初始化玩家数据
    if player.gameData.activity[ self.ActivityType] == nil or next(player.gameData.activity[ self.ActivityType]) == nil then
        self:InitData(player , self.ActivityType)
    end
    --重置一下游玩数据
    if next(player.gameData.activity[ self.ActivityType ]) ~= nil then
        player.gameData.activity[ self.ActivityType ].nowLabyrinthData = {}
        data.compassCount = player.gameData.activity[ self.ActivityType ].compassCount
        data.labyrinthInfo = player.gameData.activity[ self.ActivityType ].labyrinthInfos
        data.rewardInfos = player.gameData.activity[ self.ActivityType ].rewardInfos
    end
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityLabyrinthShow")
    s2cData.data = assert(pb.encode("S2CActivityLabyrinthShow", data))
end

--迷途寻宝 购买指南针
function ActivityLabyrinth:BuyCompass( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityLabyrinthBuyCompass", c2sData.data ))
    local data = {}
    --判断是否需要添加红点
    local canAddRedDot = false
    if player.gameData.activity[ self.ActivityType ].compassCount == 0 then
        canAddRedDot = true
    end
    --消耗玩家蜗壳币
    local eventId = pb.enum("EnumMoneyChangeEventID","EventID_87")
    local isSuc = player:MoneyChange(dataType.GoodsType_Volute , - self:GetLabyrinthInfo( player , "VoluteCoinPrice" ) , eventId)
    if false == isSuc then
        s2cData.code = errorInfo.ErrorCode.NoEnoughMoney
    else
        --购买成功 增加指南针
        player.gameData.activity[ self.ActivityType ].compassCount = player.gameData.activity[ self.ActivityType ].compassCount + 1
        --红点
        if canAddRedDot then
            skynet.server.msgTips:Add(player , 77)
        end
    end
    data.compassCount = player.gameData.activity[ self.ActivityType ].compassCount
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityLabyrinthBuyCompass")
    s2cData.data = assert(pb.encode("S2CActivityLabyrinthBuyCompass", data))
end

--迷途寻宝 开始走迷宫
function ActivityLabyrinth:Start( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityLabyrinthStart", c2sData.data ))
    local labyrinthLevel = c2sData.data.labyrinthLevel              --迷宫等级
    local data = {}
    local cfgMazeMap = skynet.server.gameConfig:GetPlayerAllCfg( player , "MazeMap")
    --判断该玩家迷宫等级是否解锁
    if 2 == player.gameData.activity[ self.ActivityType ].labyrinthInfos[ labyrinthLevel ].status then
        --给玩家当前游玩数据进行赋值
        local playerData = player.gameData.activity[ self.ActivityType ].nowLabyrinthData
        if player.gameData.activity[ self.ActivityType ].compassCount > 0 then
            --扣除玩家的指南针
            player.gameData.activity[ self.ActivityType ].compassCount = player.gameData.activity[ self.ActivityType ].compassCount - 1
            if player.gameData.activity[ self.ActivityType ].compassCount == 0 then
                skynet.server.msgTips:Reduce(player , 77)
            end
            playerData.level = labyrinthLevel                   --本次游玩的迷宫等级
            playerData.labyrinthBags = {}                       --本次游玩奖励背包
            playerData.rewardIds = {}                           --本次游玩奖励id
            for k ,v in pairs(cfgMazeMap) do
                if v.actId == self:GetLabyrinthInfo( player , "ActivityId" ) and v.difficultyOrder == labyrinthLevel then
                    for k1 ,v1 in pairs(v.treasureReward) do
                        table.insert(playerData.rewardIds , v1)                 --本次游玩奖励背包
                    end
                    break
                end
            end
        else
            s2cData.code = errorInfo.ErrorCode.NoCompassCount
        end
        --返回玩家数据
        data.labyrinthBags = playerData.labyrinthBags
        data.compassCount = player.gameData.activity[ self.ActivityType ].compassCount
    else
        s2cData.code = errorInfo.ErrorCode.NoMazeGameLevel
    end

    --设置购买步数
    player.gameData.activity[ self.ActivityType ].buyStepCount=0
    player.gameData.activity[ self.ActivityType ].isAdBuy=false
    local playerData =player.gameData.activity[ self.ActivityType ]
    data.conBuyStepCount=(playerData.buyStepCount and playerData.buyStepCount >= 4) and 0 or 4 - playerData.buyStepCount
    data.isAdBuy=playerData.isAdBuy and playerData.isAdBuy or false

    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityLabyrinthStart")
    s2cData.data = assert(pb.encode("S2CActivityLabyrinthStart", data))
end

--迷途寻宝 获取宝箱
function ActivityLabyrinth:GetChest( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityLabyrinthGetChest", c2sData.data ))
    local chestId = c2sData.data.chestId              --宝箱id
    local data = {}
    local playerData = player.gameData.activity[ self.ActivityType ].nowLabyrinthData
    --随机该宝箱是奖励还是惩罚
    local rand = math.random(1,5)
    data.chestType = self.ChestType_award
    local rewardId = 0

    --奖励从奖励池中随机
    if #playerData.rewardIds > 0 then
        local count = math.random(1,#playerData.rewardIds)
        rewardId = playerData.rewardIds[count]
        -- --将对应奖励移除奖励池
        -- table.remove(playerData.rewardIds , count)
    end
    if rewardId > 0 then
        --将对应奖励存入奖励背包中
        local award = skynet.server.playerLand:GetRewardInfo(player , rewardId)
        for k ,v in pairs(award) do
            table.insert(playerData.labyrinthBags , v)
        end
        data.rewardId = rewardId
    end
  
    data.labyrinthBags = playerData.labyrinthBags
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityLabyrinthGetChest")
    s2cData.data = assert(pb.encode("S2CActivityLabyrinthGetChest", data))
end

--迷途寻宝 完成迷宫
function ActivityLabyrinth:Finish( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityLabyrinthFinish", c2sData.data ))
    local isFinish = c2sData.data.isFinish              --是否完成迷宫
    local data = {}
    local cfgMazeMap = skynet.server.gameConfig:GetPlayerAllCfg( player , "MazeMap")
    local playerData = player.gameData.activity[ self.ActivityType ]
    local labyrinthLevel = playerData.nowLabyrinthData.level
    --判断玩家是否成功
    if isFinish then
        playerData.labyrinthInfos[ labyrinthLevel ].finishCount = playerData.labyrinthInfos[ labyrinthLevel ].finishCount + 1
        --代表是第一次完成
        if 1 == playerData.labyrinthInfos[ labyrinthLevel ].finishCount then
            --找到对应奖励id
            local rewardId = 0
            for k ,v in pairs(cfgMazeMap) do
                if v.actId == self:GetLabyrinthInfo( player , "ActivityId" ) and v.difficultyOrder == labyrinthLevel then
                    rewardId = v.finishReward
                    break
                end
            end
            if rewardId > 0 then
                --发放对应奖励
                local eventId = pb.enum("EnumMoneyChangeEventID","EventID_89")
                player:GiveReward(rewardId , eventId , 1)
                data.firstRewardId = rewardId
                --将下一个等级的迷宫状态修改为已解锁
                if labyrinthLevel < #playerData.labyrinthInfos then
                    playerData.labyrinthInfos[ labyrinthLevel + 1 ].status = 2
                end
            end
        end
        --发放背包中的奖励
        for k ,v in pairs(playerData.nowLabyrinthData.labyrinthBags) do
            if v.type < dataType.GoodsType_Furniture then
                local eventId = pb.enum("EnumMoneyChangeEventID","EventID_89")
                player:MoneyChange(v.type , v.count , eventId)
            else
                skynet.server.bag:AddGoods(player , v.type , v.id , v.count)
            end
        end
        --判断完成次数是否达到领取累积奖励的次数
        local allFinishCount = 0                   --存储玩家所有迷宫等级的总完成次数
        for k , v in pairs(playerData.labyrinthInfos) do
            allFinishCount = allFinishCount + v.finishCount
        end
        for k ,v in pairs(playerData.rewardInfos) do
            if v.needCount <= allFinishCount and 0 == v.status then
                v.status = 1
                --对应红点
                skynet.server.msgTips:Add(player , 76)
                break
            end
        end
    else
        --失败只发放迷宫背包中的奖励
        for k ,v in pairs(playerData.nowLabyrinthData.labyrinthBags) do
            if v.type < dataType.GoodsType_Furniture then
                local eventId = pb.enum("EnumMoneyChangeEventID","EventID_89")
                player:MoneyChange(v.type , v.count , eventId)
            else
                skynet.server.bag:AddGoods(player , v.type , v.id , v.count)
            end
        end
    end
    --返回玩家数据
    data.compassCount = playerData.compassCount
    data.labyrinthInfo = playerData.labyrinthInfos
    data.labyrinthBags = playerData.nowLabyrinthData.labyrinthBags
    data.rewardInfos = playerData.rewardInfos
    --将本次游玩信息初始化
    player.gameData.activity[ self.ActivityType ].nowLabyrinthData = {}
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityLabyrinthFinish")
    s2cData.data = assert(pb.encode("S2CActivityLabyrinthFinish", data))
end

--迷途寻宝 领取累计奖励
function ActivityLabyrinth:SumGet( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityLabyrinthSumGet", c2sData.data ))
    local id = c2sData.data.id                                      --累签id
    local data = {}
    for k ,v in pairs(player.gameData.activity[ self.ActivityType ].rewardInfos) do
        if v.id == id and v.status == 1 then
            --发放对应奖励
            local eventId = pb.enum("EnumMoneyChangeEventID","EventID_90")
            player:GiveReward(v.rewardId , eventId , 1)
            v.status = 2
            data.rewardId = v.rewardId
            skynet.server.msgTips:Reduce(player , 76)
            break
        end
    end
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityLabyrinthSumGet")
    s2cData.data = assert(pb.encode("S2CActivityLabyrinthSumGet", data))
end

--购买步数
function ActivityLabyrinth:BuyStep( player , c2sData , s2cData )
    c2sData.data = assert(pb.decode("C2SActivityLabyrinthBuyStep", c2sData.data ))
    s2cData.cmd = pb.enum("MsgType","CMD_S2C_ActivityLabyrinthBuyStep")
    local type = c2sData.data.type                                --购买类型 1:广告 2:金币
    local data = {}
    local playerData = player.gameData.activity[ self.ActivityType ]    
    local labyrinthLevel = playerData.nowLabyrinthData.level

    --是否可以购买-购买次数 4次
    if playerData.buyStepCount and playerData.buyStepCount>=4 then
        log.info("迷宫活动 购买步数不足:",playerData.buyStepCount)
        s2cData.code = errorInfo.ErrorCode.ErrRequestParam 
        return
    end

    local cfgMazeMapList = skynet.server.gameConfig:GetPlayerAllCfg( player , "MazeMap")
    local cfgMazeMap={}

    for k ,v in pairs(cfgMazeMapList) do
        if v.actId == self:GetLabyrinthInfo( player , "ActivityId" ) and v.difficultyOrder == labyrinthLevel then
            cfgMazeMap = v
            break
        end
    end

    --处理消耗资源
    if type == 1  then--广告
        --广告，不消耗资源
        if  playerData.isAdBuy then
            log.info("迷宫活动 购买步数 广告不足",player.buyStepCount)
            s2cData.code = errorInfo.ErrorCode.ErrRequestParam
            return
        end

        playerData.isAdBuy = true

    elseif type == 2 then
   
        --奖励索引
        local rewardIndex= not playerData.buyStepCount and 1 or playerData.buyStepCount+1
        if playerData.isAdBuy then
            rewardIndex=rewardIndex-1
        end

        --是否存在奖励,不存在奖励 次数已用完
        if not cfgMazeMap.buyStepCoin[rewardIndex] then
            log.info("迷宫活动 购买步数 广告不足",player.buyStepCount)
            s2cData.code = errorInfo.ErrorCode.ErrRequestParam
            return
        end

        local eventId = pb.enum("EnumMoneyChangeEventID","EventID_142")  
        
        --消耗金币
        if not player:MoneyChange(dataType.MoneyType_Coin , -cfgMazeMap.buyStepCoin[rewardIndex] , eventId) then
            log.info("迷宫活动 购买步数 金币不足")
            s2cData.code = errorInfo.ErrorCode.NoEnoughMoney
            return
        end
    else
        log.info("迷宫活动 购买步数类型错误:",type)
        s2cData.code = errorInfo.ErrorCode.ErrRequestParam
        return
    end

    playerData.buyStepCount= not playerData.buyStepCount and 1 or playerData.buyStepCount+1
    data.conBuyStepCount=playerData.buyStepCount >= 4 and 0 or 4 - playerData.buyStepCount
    data.isAdBuy = playerData.isAdBuy and true or false

    s2cData.data = assert(pb.encode("S2CActivityLabyrinthBuyStep", data))
end

skynet.server.activityLabyrinth = ActivityLabyrinth
return ActivityLabyrinth