--秘宝支持多开，activityType和FunctionID不变，只按照activityId区分
local Monopoly_Model = {}
local private = {}
local EventSystem = require('Event/EventSystem')
local monopoly_opt_pb = require 'Proto/monopoly_opt_pb'
local operation_activity_info_pb = require 'Proto.operation_activity_info_pb'

local LuaBit = require 'bit'
local TREASURE_CHOOSE_POPUP_OPENED = "TREASURE_CHOOSE_POPUP_OPENED"
Monopoly_Model.RedPointType = 
{
    Task = operation_activity_info_pb.Task,
    Gift = operation_activity_info_pb.Gift,
}
----------------------------- 系统函数 --------------------------

function Monopoly_Model.OnStartup()
    NetManager.RegisterMsgCB(MessageEnums.MessageMonopolyOpen, private.MonopolyOpenResponse)
    NetManager.RegisterMsgCB(MessageEnums.MessageMonopolyDiceOpt, private.MonopolyDiceResponse)
    NetManager.RegisterMsgCB(MessageEnums.MessageMonopolyHistoryReward, private.MonopolyHistoryRewardResponse)
    NetManager.RegisterMsgCB(MessageEnums.MessageMonopolyGetTask, private.MonopolyGetTaskResponse)
    NetManager.RegisterMsgCB(MessageEnums.MessageMonopolyTaskReward, private.MonopolyTaskRewardResponse)
    NetManager.RegisterMsgCB(MessageEnums.MessageChooseRewardTreasure, private.ChooseRewardTreasureResp)

    EventSystem.Regist(EventID.BagItem_Update, private.RefreshRedPoint)

    private.ActivityType = MDL.OperationActivity.ActivityType.Monopoly

    private.activityIdList = {} -- 记录当前的金宝物\彩金宝物活动id。设计上两种品质最多各开一个，程序里不做限制    
    private.activityRpDict = {}
    private.curMapPointId = 0 -- 有些界面表现向的数据每次打开一个界面实例前会重新初始化一遍，就只留一份，不弄成字典了
    private.curMapRound = -1
    private.triggerProgressDict = {} --这个每次在任务界面打开时都会先重新初始化再使用，所以也不按照activityId区分了
    private.serverRp = {}
    
    private.isInActivityFuncTime = {} --是否在功能活动时间内
    private.activityEndTimerHandle = {}

    private.moneyId = {}
    private.itemId = {}
    private.treasureOptionalPopUp = {}  --自选宝物信息
end

function Monopoly_Model.OnShutdown()
    private.activityIdList = nil
    private.activityRpDict = nil
    private.taskInfo = nil
    private.triggerProgressDict = nil
end

----------------------------------------------------------------

----------------------------- 处理协议 --------------------------

function Monopoly_Model.SetActivityInfo(activityInfos)
    if activityInfos and #activityInfos > 0 then
        for i, v in ipairs(activityInfos) do
            local aid = v.activityId
            private.serverRp[aid] = false
            if aid > 0 and not table.containValue(private.activityIdList, aid) then
                table.insert(private.activityIdList, aid)
                CTL.Monopoly.InitMonoplyHotDatas(aid)                              
            end
            for _, pointType in pairs(Monopoly_Model.RedPointType) do
                if not private.activityRpDict[aid] then
                    private.activityRpDict[aid] = {}
                end
                private.activityRpDict[aid][pointType] = LuaBit.band(v.redPoint, pointType) == pointType
                if private.activityRpDict[aid][pointType] then
                    private.serverRp[aid] = true
                end
            end
        end

        private.RefreshRedPoint()
    end
end

function private.SetMonopolyInfo(monopolyInfo)
    private.curMapPointId = monopolyInfo.place
    private.curMapRound = monopolyInfo.round
end

function private.SetTreasureOptionalPopUpInfo(msgResp)
    if not private.treasureOptionalPopUp[msgResp.activityId] then
        private.treasureOptionalPopUp[msgResp.activityId] = {}
    end
    private.treasureOptionalPopUp[msgResp.activityId].canChoose = msgResp.canChoose
    private.treasureOptionalPopUp[msgResp.activityId].chooseId = msgResp.chooseId
end

function Monopoly_Model.MonopolyOpenRequest(activityId)
    if Monopoly_Model.IsOpenMonopolyActivity(activityId) then
        local msg = monopoly_opt_pb.MonopolyOpenReq()
        msg.activityId = activityId
        NetManager.SendMessage(MessageEnums.MessageMonopolyOpen, msg)
    end
end

function private.MonopolyOpenResponse(msgResp)
    local aid = msgResp.activityId
    private.SetMonopolyInfo(msgResp.info)
    private.moneyId[aid] = msgResp.MoneyId --货币展示id，用于该兑换商城
    private.itemId[aid] = msgResp.ItemId   --抽奖消耗道具id(骰子)
    private.SetTreasureOptionalPopUpInfo(msgResp)
    EventSystem.Dispatch(EventID.UI_Monopoly_RefreshMain, aid)
end

function Monopoly_Model.MonopolyDiceRequest(num, activityId)
    if Monopoly_Model.IsOpenMonopolyActivity(activityId) then
        local msg = monopoly_opt_pb.MonopolyDiceOptReq()
        msg.activityId = activityId
        msg.num = num
        NetManager.SendMessage(MessageEnums.MessageMonopolyDiceOpt, msg)
    end
end

function private.MonopolyDiceResponse(msgResp)
    private.SetMonopolyInfo(msgResp.info.info)
    EventSystem.Dispatch(EventID.UI_Monopoly_ShowSwingDiceResult, msgResp.info)
    
    private.treasureOptionalPopUp[msgResp.activityId].canChoose = msgResp.canChoose
    private.treasureOptionalPopUp[msgResp.activityId].chooseId = msgResp.chooseId
    EventSystem.Dispatch(EventID.UI_Monopoly_ChooseTreasure)
end

function Monopoly_Model.MonopolyHistoryRewardRequest(activityId)
    if Monopoly_Model.IsOpenMonopolyActivity(activityId) then
        local msg = monopoly_opt_pb.MonopolyHistoryRewardReq()
        msg.activityId = activityId
        NetManager.SendMessage(MessageEnums.MessageMonopolyHistoryReward, msg)
    end
end

function private.MonopolyHistoryRewardResponse(msgResp)
    EventSystem.Dispatch(EventID.UI_Monopoly_RefreshRecord, msgResp.info)
end

function Monopoly_Model.MonopolyGetTaskRequest(activityId)
    if Monopoly_Model.IsOpenMonopolyActivity(activityId) then
        local msg = monopoly_opt_pb.MonopolyGetTaskReq()
        msg.activityId = activityId
        NetManager.SendMessage(MessageEnums.MessageMonopolyGetTask, msg)
    end
end

function private.MonopolyGetTaskResponse(msgResp)
    if msgResp.taskInfo and #msgResp.taskInfo > 0 then
        table.clear(private.triggerProgressDict)
        if msgResp.triggerInfo and #msgResp.triggerInfo > 0 then
            for _ ,v in ipairs (msgResp.triggerInfo) do
                private.triggerProgressDict[v.triggerId] = v.triggerNum
            end
        end
        CTL.Monopoly.UpdateTaskInfos(msgResp.activityId, msgResp.taskInfo)
        EventSystem.Dispatch(EventID.UI_Monopoly_RefreshTasks,msgResp.activityId)
    end
end

function Monopoly_Model.MonopolyTaskRewardRequest(taskId, activityId)
    if Monopoly_Model.IsOpenMonopolyActivity(activityId) then
        local msg = monopoly_opt_pb.MonopolyTaskRewardReq()
        msg.activityId = activityId
        msg.taskId = taskId
        NetManager.SendMessage(MessageEnums.MessageMonopolyTaskReward, msg)
    end
end

function private.MonopolyTaskRewardResponse(msgResp)
    CTL.Monopoly.UpdateTaskInfos(msgResp.activityId, msgResp.taskId)
    EventSystem.Dispatch(EventID.UI_Monopoly_RefreshTasks,msgResp.activityId)
end

function Monopoly_Model.ChooseRewardTreasureReq(activityId, treasureId)
    local msg = monopoly_opt_pb.ChooseRewardTreasureReq()
    msg.activityId = activityId
    msg.treasureId = treasureId
    NetManager.SendMessage(MessageEnums.MessageChooseRewardTreasure, msg)
end

function private.ChooseRewardTreasureResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.SetTreasureOptionalPopUpInfo(msgResp)
        EventSystem.Dispatch(EventID.UI_Monopoly_ChooseTreasure)
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_OptionalHorseAndTreasure_Hint13"])
    end
end

----------------------------------------------------------------

--------------------------------------- 对外参数接口 ---------------------------------------

function Monopoly_Model.GetActivityIdList()  
    return private.activityIdList
end

--找到第一个符合品质需求的活动即可，设计上同品质活动只会设计一个
function Monopoly_Model.GetActivityIdByQuality(needSuperGold)
    for _, aid in ipairs(private.activityIdList) do
        local isSuperGold = CTL.Monopoly.IsSuperGold(aid)
        if (needSuperGold and isSuperGold) or (not needSuperGold and not isSuperGold) then
            return aid
        end
    end
end

function Monopoly_Model.GetActivityInfo(activityId)
    return MDL.OperationActivity.GetOperationActivityInfo(private.ActivityType, activityId)
end 

function Monopoly_Model.IsOpenMonopolyActivity(activityId)
    return MDL.Unlock.IsUnlock(MDL.Unlock.FunctionType.Monopoly) and Monopoly_Model.GetActivityInfo(activityId) and CTL.OperationActivity.IsOperationActivityOpen(Monopoly_Model.GetActivityInfo(activityId))
end

function Monopoly_Model.GetCurMapPointId()
    return private.curMapPointId
end

function Monopoly_Model.GetCurMapRound()
    return private.curMapRound
end

function Monopoly_Model.IsShowRpByType(activityId, type)
    return private.activityRpDict[activityId][type]
end

function Monopoly_Model.GetTriggerNum(triggerId)
    return private.triggerProgressDict[triggerId] or 0
end

--获取货币和消耗道具展示
function Monopoly_Model.GetMoneyAndItemShow(activityId)
    return private.moneyId[activityId], private.itemId[activityId]
end

function Monopoly_Model.GetTreasureIsCanChoose(activityId)
    if private.treasureOptionalPopUp[activityId] then
        if private.treasureOptionalPopUp[activityId].canChoose then
            local chooseId = Monopoly_Model.GetTreasureChooseId(activityId)
            local cardPoolList = CTL.Monopoly.GetActivitySameQualityTreasure(activityId, chooseId)
            return #cardPoolList > 0
        end
        return false
    end

    return false
end

function Monopoly_Model.GetTreasureChooseId(activityId)
    if private.treasureOptionalPopUp[activityId] then
        if private.treasureOptionalPopUp[activityId].chooseId == 0 then
            local basicData = MDL.OperationActivity.ActivityBaseData[private.ActivityType]:GetDataByActivityID(activityId)
            return basicData.TreasureID
        end
        return private.treasureOptionalPopUp[activityId].chooseId
    end

    return 0
end

function Monopoly_Model.IsTreasureChoosePopUpAutoOpened(activityId)
    local str = TREASURE_CHOOSE_POPUP_OPENED..activityId
    return PersistentData.PlayerData:Get(str, false)
end

function Monopoly_Model.SetTreasureChoosePopUpAutoOpened(activityId)
    local str = TREASURE_CHOOSE_POPUP_OPENED..activityId
    PersistentData.PlayerData:Set(str, true, true)
end

-------------------------------------------------------------------------------------------

function Monopoly_Model.IsActivityInFuncTime(activityId)
    if private.isInActivityFuncTime[activityId] == nil then
        private.SetEndTimerByActivityId(activityId)
    end
    return private.isInActivityFuncTime[activityId]
end

function private.SetEndTimerByActivityId(activityId)
    if private.activityEndTimerHandle[activityId] then
        TimerUtil.Remove(private.activityEndTimerHandle[activityId])
        private.activityEndTimerHandle[activityId] = nil
    end
    local activityInfo = MDL.OperationActivity.GetOperationActivityInfo(private.ActivityType, activityId)
    local nowTime = UTL.Time.GetServerTimestamp()
    local endTime = activityInfo.endTime
    if endTime > nowTime then
        private.isInActivityFuncTime[activityId] = true
        local deltaTime = endTime - nowTime
        if deltaTime <= UTL.Time.TotalSecondsOneDay then
            private.activityEndTimerHandle[activityId] = TimerUtil.Interval(private.EndAndCloseActivity(activityId), deltaTime - 1, 1) --时间减1s是为了防止有误差导致玩家点击出现报错
        end
    else
        private.EndAndCloseActivity(activityId)
    end
end

function private.EndAndCloseActivity(activityId)
    logging.log(LTAG.LOG, "Monopoly ActivityEnd, activityId: ", activityId)
    if private.activityEndTimerHandle[activityId] then
        TimerUtil.Remove(private.activityEndTimerHandle[activityId])
        private.activityEndTimerHandle[activityId] = nil
    end
    private.isInActivityFuncTime[activityId] = false
    EventSystem.Dispatch(EventID.UI_Monopoly_ActivityEnd, activityId)
end

function private.RefreshRedPoint()
    EventSystem.Dispatch(EventID.UI_Monopoly_RefreshRp)
end

function Monopoly_Model.HasMonopolyRp(activityId)
    local hasServerRp = private.serverRp[activityId]
    local hasDice = UTL.Item.GetItemStockCount(CTL.Monopoly.GetDiceItemID(activityId)) > 0
    return hasServerRp or hasDice
end

return Monopoly_Model