local OACommon_Model = {}
local private = {}
local EventSystem = require('Event/EventSystem')
local activity_pb = require("Proto/activity_pb")
local activity_opt_pb = require("Proto/activity_opt_pb")
local activity_cross_rank_opt_pb = require('Proto.activity_cross_rank_opt_pb')

OACommon_Model.ActivityTaskState =
{
    UnDone = activity_pb.UnDone,    -- 未完成
    Done = activity_pb.Done,        -- 完成可领取
    Commit = activity_pb.Commit,    -- 已领取/提交
}

OACommon_Model.ActivityTaskStateSort =
{
    OACommon_Model.ActivityTaskState.Done,
    OACommon_Model.ActivityTaskState.UnDone,
    OACommon_Model.ActivityTaskState.Commit,
}

function OACommon_Model.OnStartup()
    NetManager.RegisterMsgCB(MessageEnums.MessageAtyTaskInfo, private.OATaskInfoResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageAtyTaskRwd, private.OATaskRewardResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageClaimAtyTaskAllRwd, private.ClaimAtyTaskAllRwdResp)            -- 领取指定运营活动的所有任务奖励
    NetManager.RegisterMsgCB(MessageEnums.MessageActivityCrossRankGetRecord, private.ActivityCrossRankGetRecordResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageActivityCrossRankGetHistoryRecord, private.ActivityCrossRankGetHistoryRecordResp)

    EventSystem.Regist(EventID.UI_OperationActivity_DataChanged, private.DealWithTaskData)

    private.OARedPointDict = {}
    private.taskStatus = {}
    private.triggerInfo = {}
    private.taskData = {}

    private.OARankList = {}
    private.OAMyRank = {}
    private.OAHistoryRank = {}

    private.OptActivityID = 0
end

function OACommon_Model.GetOARedPointByActivityId(activityId)
    return private.OARedPointDict[activityId] or false
end

function OACommon_Model.SetOARedPoint(activityTaskRedPoints)
    if private.OptActivityID > 0 then
        if activityTaskRedPoints[1] then
            private.OARedPointDict[activityTaskRedPoints[1]] = true
        else
            private.OARedPointDict[private.OptActivityID] = false
        end
    else
        for i, v in ipairs(activityTaskRedPoints) do
            private.OARedPointDict[v] = true
        end
    end

    EventSystem.Dispatch(EventID.UI_OACommon_RedPointChanged)
end

function OACommon_Model.ClearOARedPoint()
    private.OARedPointDict = {}
    EventSystem.Dispatch(EventID.UI_OACommon_RedPointChanged)
end

--region ********************* 运营活动Task *************************
function OACommon_Model.GetTaskStatus(activityId, taskId)
    return private.taskStatus[activityId][taskId]
end

function OACommon_Model.GetTriggerCount(activityId, triggerId, triggerKey)
    local triggerInfo = private.GetTriggerInfo(activityId, triggerId, triggerKey)
    if type(triggerInfo) == "table" then
        if tonumber(triggerKey) then
            return triggerInfo[triggerKey]
        else
            local keyTable = string.split(triggerKey, ";")
            local count = 0
            for i, v in ipairs(keyTable) do
                count = count + (triggerInfo[v] or 0)
            end
            return count
        end
    else
        return triggerInfo or 0
    end
end

function private.GetTriggerInfo(activityId, triggerId, triggerKey)
    if string.isNilOrEmpty(triggerKey) then
        if private.triggerInfo[activityId] then
            return private.triggerInfo[activityId][triggerId] or 0
        end
    else
        if private.triggerInfo[activityId] then
            return private.triggerInfo[activityId][triggerId]
        end
    end
end

function OACommon_Model.GetTaskData(activityId, tabId)
    if tabId then
        return private.taskData[activityId][tabId]
    else
        return private.taskData[activityId]
    end
end

function private.DealWithTaskData()
    private.taskData = {}
    if MDL.OperationActivity.TaskRewardData then
        for activityType, typeData in pairs(MDL.OperationActivity.TaskRewardData) do
            for activityId, data in pairs(MDL.OperationActivity.TaskRewardData[activityType]:GetDataByActivityID_ID()) do
                if not private.taskData[activityId] then
                    private.taskData[activityId] = {}
                end
                local taskData = private.taskData[activityId]
                for i, v in pairs(data) do
                    if not taskData[v.TaskType] then
                        taskData[v.TaskType] = {}
                    end
                    table.insert(taskData[v.TaskType], v)
                end
                for i, v in pairs(taskData) do
                    table.sort(v, private.SortTask)
                end
            end
        end
    end
    EventSystem.Dispatch(EventID.UI_OACommon_TaskDataRefresh)
end

function private.SortTask(taskDataA, taskDataB)
    return taskDataA.ID < taskDataB.ID
end

function private.SetActivityTaskInfo(taskInfo)
    local activityId = taskInfo.activityId
    if activityId and activityId > 0 then
        private.taskStatus[activityId] = {}
        local statusList = private.taskStatus[activityId]
        for i, v in ipairs(taskInfo.taskStatus) do
            statusList[v.taskId] = v.status
        end
        private.triggerInfo[activityId] = {}
        local triggerList = private.triggerInfo[activityId]
        for i, v in ipairs(taskInfo.triggerCountList) do
            for _, data in ipairs(v.triggerKv) do
                if string.isNilOrEmpty(data.key) then
                    triggerList[v.triggerId] = data.value
                else
                    if not triggerList[v.triggerId] then
                        triggerList[v.triggerId] = {}
                    end
                    triggerList[v.triggerId][data.key] = data.value
                end
            end
        end
        EventSystem.Dispatch(EventID.UI_OACommon_TaskInfoRefresh, activityId)
    else
        logging.error(LTAG.ERROR, "运营活动任务相关信息中activityId：", activityId, " ，该值非法！请检查！！！")
    end
end

function OACommon_Model.GetStateSortedTaskList(activityId, tabId)
    local originList = OACommon_Model.GetTaskData(activityId, tabId)
    local tempList = {}
    for i, v in ipairs(originList) do
        table.insert(tempList, v)
    end
    table.sort(tempList, private.SortByStatus)
    return tempList
end

function private.SortByStatus(taskA, taskB)
    local statusA = OACommon_Model.GetTaskStatus(taskA.ActivityID, taskA.ID)
    local statusB = OACommon_Model.GetTaskStatus(taskB.ActivityID, taskB.ID)
    if statusA ~= statusB then
        if statusA == OACommon_Model.ActivityTaskState.Done then
            return true
        elseif statusA == OACommon_Model.ActivityTaskState.Commit then
            return false
        else
            if statusB == OACommon_Model.ActivityTaskState.Done then
                return false
            else
                return true
            end
        end
    else
        return taskA.ID < taskB.ID
    end
end

-- 获取运营活动 任务数据
function OACommon_Model.OATaskInfoReq(activityId)
    local msg = activity_opt_pb.AtyTaskInfoReq()
    msg.activityId = activityId
    NetManager.SendMessage(MessageEnums.MessageAtyTaskInfo, msg)
end

function private.OATaskInfoResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.SetActivityTaskInfo(msgResp)
    end
end

-- 领取运营活动指定任务奖励
function OACommon_Model.OATaskRewardReq(activityId, taskId)
    local msg = activity_opt_pb.AtyTaskRwdReq()
    msg.activityId = activityId
    private.OptActivityID = activityId
    msg.id = taskId
    NetManager.SendMessage(MessageEnums.MessageAtyTaskRwd, msg)
end

function private.OATaskRewardResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.taskStatus[msgResp.activityId][msgResp.id] = OACommon_Model.ActivityTaskState.Commit
        EventSystem.Dispatch(EventID.UI_OACommon_TaskRewardClaim, msgResp.activityId)
    end
end

-- param 为增加的参数，可以为nil，目前用于号令天下， 因为有多个tab页签，其他活动暂时只有一个
-- 一键领取运营活动任务奖励
function OACommon_Model.ClaimAtyTaskAllRwdRequest(activityId)
    local msg = activity_opt_pb.ClaimAtyTaskAllRwdReq()
    msg.activityId = activityId
    private.OptActivityID = activityId
    NetManager.SendMessage(MessageEnums.MessageClaimAtyTaskAllRwd, msg)
end

function private.ClaimAtyTaskAllRwdResp(msgResp)
    private.SetActivityTaskInfo(msgResp)
end
--endregion ********************* 运营活动Task *************************

--region ********************* 运营活动商店 *********************
-- param 为增加的参数，可以为nil，目前用于号令天下， 因为有多个tab页签，其他活动暂时只有一个
function OACommon_Model.GetStoreGoodsEnumerator(activityType, activityId, param)
    private.goods = {}
    --号令天下多个页签，走单独逻辑
    if activityType == MDL.OperationActivity.ActivityType.BattlefieldMuster and param then
        local tabID = MDL.CommandTheWorld.GetStoreTabId(param)
        for _, v in MDL.OperationActivity.StoreGoodsData:GetEnumerator() do
            if v.TabID == tabID then
                table.insert(private.goods, v)
            end
        end
        return ipairs(private.goods)
    end

    if MDL.OperationActivity.ActivityBaseData[activityType] then
        local backgroundCfg = MDL.OperationActivity.ActivityBaseData[activityType]:GetDataByActivityID(activityId)
        if backgroundCfg then
            local tabID = backgroundCfg.StoreID
            for _, v in MDL.OperationActivity.StoreGoodsData:GetEnumerator() do
                if v.TabID == tabID then
                    --可以处理解锁等额外条件，目前活动（大富翁、养马）没有这个需求，先不处理解锁
                    table.insert(private.goods, v)
                end
            end
            table.sort(private.goods, private.SortOAGoods)
        else
            logging.error(LTAG.ERROR, "找不到ActivityType：", activityType, " ActivityId：", activityId, "在BackGround运营活动静态数据表的数据！请检查！！！")
        end
    else
        logging.error(LTAG.ERROR, "找不到ActivityType：", activityType, " 的BackGround运营活动静态数据表！请检查！！！")
    end
    return ipairs(private.goods)
end

function private.SortOAGoods(itemDataA, itemDataB)
    if itemDataA.IsRareItem == itemDataB.IsRareItem then
        if itemDataA.SortID == itemDataB.SortID then
            return itemDataA.ID < itemDataB.ID
        end
        return itemDataA.SortID > itemDataB.SortID
    end
    return itemDataA.IsRareItem == true and itemDataB.IsRareItem == false
end
--endregion

--region ********************* 运营活动排行榜 *********************
--在ActivityCrossRankGetRecordReq请求后再调用
function OACommon_Model.GetRankRecordsByActivityId(activityId, rankName)
    if private.OARankList[activityId] then
        return private.OARankList[activityId][rankName]
    end
end

function OACommon_Model.GetMyRankByActivityId(activityId, rankName)
    if private.OAMyRank[activityId] then
        return private.OAMyRank[activityId][rankName]
    end
end

--历史榜单不用实时刷，如果之前请求过有数据就直接用缓存好的数据
---@return {records = list, myRank = number}
function OACommon_Model.GetHistoryRankRecords(activityId, rankName, count)
    if private.OAHistoryRank[activityId] then
        if private.OAHistoryRank[activityId][rankName] then
            if private.OAHistoryRank[activityId][rankName][count] then
                return private.OAHistoryRank[activityId][rankName][count]
            end
        end
    end
    OACommon_Model.ActivityCrossRankGetHistoryRecordReq(activityId, rankName, count)
end

function OACommon_Model.ActivityCrossRankGetRecordReq(activityId, rankName)
    local msg = activity_cross_rank_opt_pb.ActivityCrossRankGetRecordReq()
    msg.activityId = activityId
    msg.rankName = rankName
    NetManager.SendMessage(MessageEnums.MessageActivityCrossRankGetRecord, msg)
end

function private.ActivityCrossRankGetRecordResp(msgResp)
    if msgResp.Resp.Code == 0 then
        local activityId = msgResp.activityId
        if not private.OARankList[activityId] then
            private.OARankList[activityId] = {}
        end
        private.OARankList[activityId][msgResp.rankName] = msgResp.rankRecords.records
        if not private.OAMyRank[activityId] then
            private.OAMyRank[activityId] = {}
        end
        private.OAMyRank[activityId][msgResp.rankName] = msgResp.rankRecords.myRank
        EventSystem.Dispatch(EventID.UI_OACommon_RankRefresh, msgResp.activityId, msgResp.rankName)
    end
end

---@param count 表示第几次结算 例：按天结算的排行榜，则为第几天的排行榜
function OACommon_Model.ActivityCrossRankGetHistoryRecordReq(activityId, rankName, count)
    local msg = activity_cross_rank_opt_pb.ActivityCrossRankGetHistoryRecordReq()
    msg.activityId = activityId
    msg.rankName = rankName
    msg.count = count
    NetManager.SendMessage(MessageEnums.MessageActivityCrossRankGetHistoryRecord, msg)
end

function private.ActivityCrossRankGetHistoryRecordResp(msgResp)
    if msgResp.Resp.Code == 0 then
        local activityId = msgResp.activityId
        if not private.OAHistoryRank[activityId] then
            private.OAHistoryRank[activityId] = {}
        end
        if not private.OAHistoryRank[activityId][msgResp.rankName] then
            private.OAHistoryRank[activityId][msgResp.rankName] = {}
        end
        private.OAHistoryRank[activityId][msgResp.rankName][msgResp.count] = {records = msgResp.rankRecords.records, myRank = msgResp.rankRecords.myRank}
        EventSystem.Dispatch(EventID.UI_OACommon_HistoryRankRefresh, msgResp.activityId, msgResp.rankName, msgResp.count)
    end
end
--endregion ********************* 运营活动排行榜 *********************

return OACommon_Model