local UIWidgetBase = require_ex('Common/Core/UIWidgetBase')
local ControllerMode = MapConst.LEVEL_MAP_CONTROLLER_MODE















































































LevelMapController = HL.Class('LevelMapController', UIWidgetBase)

local EXTRA_VIEW_VALUE = 1
local LEVEL_UPDATE_THREAD_INTERVAL = 0.5
local LEVEL_SWITCH_LOADER_UPDATE_THREAD_INTERVAL = 0.015
local FOLLOW_CHARACTER_LOADER_UPDATE_THREAD_INTERVAL = 0.25
local INVOKE_LEVEL_SWITCH_FINISH_DELAY = 0.2

local NEED_UPDATE_LOADER_CHARACTER_SQR_MAGNITUDE = 0.002


LevelMapController.m_mode = HL.Field(HL.Number) << -1


LevelMapController.m_levelMapConfig = HL.Field(CS.Beyond.Gameplay.UILevelMapConfig)


LevelMapController.m_currentLevelId = HL.Field(HL.String) << ""


LevelMapController.m_currentIsSingleLevel = HL.Field(HL.Boolean) << false




LevelMapController.m_fixedMarkInstId = HL.Field(HL.String) << ""


LevelMapController.m_customRefreshMark = HL.Field(HL.Function)






LevelMapController.m_onLevelSwitch = HL.Field(HL.Function)


LevelMapController.m_onLevelSwitchStart = HL.Field(HL.Function)


LevelMapController.m_onLevelSwitchFinish = HL.Field(HL.Function)


LevelMapController.m_onTrackingMarkClicked = HL.Field(HL.Function)


LevelMapController.m_switchTweenList = HL.Field(HL.Table)


LevelMapController.m_delayInvokeTimer = HL.Field(HL.Number) << -1


LevelMapController.m_currentMaxScale = HL.Field(HL.Number) << -1


LevelMapController.m_currentMinScale = HL.Field(HL.Number) << -1


LevelMapController.m_visibleMarks = HL.Field(HL.Table)


LevelMapController.m_filteredMarks = HL.Field(HL.Table)


LevelMapController.m_layeredMarks = HL.Field(HL.Table)


LevelMapController.m_currentLayer = HL.Field(HL.Number) << -1


LevelMapController.m_currFollowModeTrackingMarkId = HL.Field(HL.String) << ""


LevelMapController.m_markVisibleRect = HL.Field(RectTransform)


LevelMapController.m_expectedMarks = HL.Field(HL.Table)


LevelMapController.m_topOrderMarks = HL.Field(HL.Table)


LevelMapController.m_noGeneralTracking = HL.Field(HL.Boolean) << true


LevelMapController.m_noMissionTracking = HL.Field(HL.Boolean) << true


LevelMapController.m_currTopOrderMarkLastOrder = HL.Field(HL.Number) << -1


LevelMapController.m_waitPlayUnlockedAnimMistList = HL.Field(HL.Table)






LevelMapController.m_waitPlayUnlockedAnimMistQueue = HL.Field(HL.Forward("Queue"))


LevelMapController.m_isPlayingUnlockedAnimation = HL.Field(HL.Boolean) << false


LevelMapController.m_lastPosChanged = HL.Field(HL.Boolean) << false






LevelMapController.m_currTrackingMarkData = HL.Field(HL.Table)


LevelMapController.m_lastTrackingMarkId = HL.Field(HL.String) << ""


LevelMapController.m_trackingMissionMarkIdList = HL.Field(HL.Table)






LevelMapController._OnFirstTimeInit = HL.Override() << function(self)
    if self.m_mode == ControllerMode.LEVEL_SWITCH then
        self:RegisterMessage(MessageConst.ON_MAP_FILTER_STATE_CHANGED, function(args)
            self:_RefreshLoaderMarksVisibleStateByFilter()
        end)
    elseif self.m_mode == ControllerMode.FOLLOW_CHARACTER then
        self:RegisterMessage(MessageConst.ON_MIST_MAP_UNLOCK, function(args)
            self:_OnMistStateChangeInFollowMode(args)
        end)
        self:RegisterMessage(MessageConst.ON_TELEPORT_FINISH, function(args)
            self:_OnTeleportFinish()
        end)
        
        self:RegisterMessage(MessageConst.ON_ENTER_TIER_REGION, function(args)
            local tierId = unpack(args)
            self:_OnCurrTierRegionStateChangeInFollowMode(tierId, true)
        end)
        self:RegisterMessage(MessageConst.ON_LEAVE_TIER_REGION, function(args)
            local tierId = unpack(args)
            self:_OnCurrTierRegionStateChangeInFollowMode(tierId, false)
        end)
        self:RegisterMessage(MessageConst.ON_ENTER_TIER_CONTAINER_REGION, function(args)
            self:SetLoaderTierStateWithNeedShowMarkTier(true)
        end)
        self:RegisterMessage(MessageConst.ON_LEAVE_TIER_CONTAINER_REGION, function(args)
            self:SetLoaderTierStateWithNeedShowMarkTier(false)
        end)
        
    end

    self:RegisterMessage(MessageConst.ON_TRACKING_MAP_MARK, function(args)
        self:_OnTrackingStateChanged()
    end)
    self:RegisterMessage(MessageConst.ON_TRACK_MARK_CHANGE, function(args)
        self:_OnTrackingStateChanged()
    end)
    self:RegisterMessage(MessageConst.ON_MAP_TRACKING_MISSION_DATA_CHANGED, function(args)
        self:_RefreshMissionTrackingMarks()
    end)
    self:RegisterMessage(MessageConst.ON_MAP_MARK_RUNTIME_DATA_MODIFY, function(args)
        local instId = unpack(args)
        self:_RefreshGeneralTrackingMarkOnMarkDataModify(instId)
    end)
end



LevelMapController._OnDestroy = HL.Override() << function(self)
    if self.m_mode == ControllerMode.FOLLOW_CHARACTER then
        GameInstance.player.mapManager.characterFollowerInstance = nil
    elseif self.m_mode == ControllerMode.LEVEL_SWITCH then
        if self.m_switchTweenList ~= nil then
            for _, tween in pairs(self.m_switchTweenList) do
                if tween ~= nil then
                    tween:Kill(false)
                end
            end
            self.m_switchTweenList = nil
        end
    end
end






























LevelMapController.InitLevelMapController = HL.Method(HL.Number, HL.Opt(HL.Table)) << function(self, mode, customInfo)
    self.m_levelMapConfig = DataManager.uiLevelMapConfig

    
    customInfo = customInfo or {}
    local initialLevelId = string.isEmpty(customInfo.initialLevelId) and
        GameWorld.worldInfo.curLevelId or
        customInfo.initialLevelId
    local loaderCustomInfo = {}
    if mode == ControllerMode.FIXED then
        if not string.isEmpty(customInfo.fixedMarkInstId) then
            initialLevelId = GameInstance.player.mapManager:GetMarkInstRuntimeDataLevelId(customInfo.fixedMarkInstId)
            self.m_fixedMarkInstId = customInfo.fixedMarkInstId
        end
        loaderCustomInfo = {
            needUpdate = false,
        }
    elseif mode == ControllerMode.LEVEL_SWITCH then
        loaderCustomInfo = {
            extraView = EXTRA_VIEW_VALUE,
            needOptimizePerformance = false,
            hideOtherLevels = true,
            needUpdate = false,
            needShowOtherLevelTracking = false,
            needInteractableMark = true,
            onMarkInstDataChangedCallback = function()
                self:_ResetLoaderMarksVisibleStateByFilter()
                self:_RefreshLoaderMarksVisibleStateByLayer(self.m_currentLayer)
            end,
            onMarkHover = function(markInstId, isHover)
                customInfo.onMarkHover(markInstId, isHover)
            end,
            onGridsLoadedStateChange = function()
                self:_RefreshAnimationMistsInSwitchMode()
            end
        }
    elseif mode == ControllerMode.FOLLOW_CHARACTER then
        loaderCustomInfo = {
            needOptimizePerformance = true,
            needShowOtherLevelTracking = true,
            needListenMarkStateChange = true,
        }
    end
    loaderCustomInfo.expectedStaticElements = customInfo.expectedStaticElements
    loaderCustomInfo.gridsMaskFollowTarget = customInfo.gridsMaskFollowTarget
    if not self.m_levelMapConfig.levelConfigInfos:ContainsKey(initialLevelId) then
        if BEYOND_DEBUG_COMMAND and mode == ControllerMode.DEBUG then
            self.view.levelMapLoader:InitLevelMapLoader(initialLevelId, { isDebugMode = true })
        end
        return
    end

    self.view.levelMapLoader:InitLevelMapLoader(initialLevelId, loaderCustomInfo)
    self:_SetCurrentLevelId(initialLevelId)

    self.m_customRefreshMark = customInfo.customRefreshMark or function()end

    self.m_onLevelSwitch = customInfo.onLevelSwitch or function()end
    self.m_onLevelSwitchStart = customInfo.onLevelSwitchStart or function()end
    self.m_onLevelSwitchFinish = customInfo.onLevelSwitchFinish or function()end
    self.m_onTrackingMarkClicked = customInfo.onTrackingMarkClicked or function()end
    self.m_markVisibleRect = customInfo.visibleRect
    self.m_expectedMarks = customInfo.expectedMarks or {}
    self.m_topOrderMarks = customInfo.topOrderMarks or {}
    self.m_noGeneralTracking = customInfo.noGeneralTracking == true
    self.m_noMissionTracking = customInfo.noMissionTracking == true
    self.m_visibleMarks = {}

    self.m_mode = mode

    if mode == ControllerMode.FIXED then
        self:_InitControllerFixedMode()
    elseif mode == ControllerMode.LEVEL_SWITCH then
        self:_InitControllerSwitchMode()
    elseif mode == ControllerMode.FOLLOW_CHARACTER then
        self:_InitControllerFollowMode()
    end

    self:_FirstTimeInit()
end




LevelMapController._SetCurrentLevelId = HL.Method(HL.String) << function(self, levelId)
    self.m_currentLevelId = levelId
    local configSuccess, levelConfig = DataManager.uiLevelMapConfig.levelConfigInfos:TryGetValue(levelId)
    if configSuccess then
        self.m_currentIsSingleLevel = levelConfig.isSingleLevel
    end
end






LevelMapController._InitControllerFixedMode = HL.Method() << function(self)
    if not string.isEmpty(self.m_fixedMarkInstId) then
        self.view.levelMapLoader:SetLoaderWithMarkPosition(self.m_fixedMarkInstId)
    end
    self.view.levelMapLoader:UpdateAndRefreshAll()
    self.view.levelMapLoader:RefreshCharacterPosition()
    self.view.levelMapLoader:SetLoaderPlayerVisibleState(false)
    self:_CustomRefreshFixedModeMarks()
end



LevelMapController._CustomRefreshFixedModeMarks = HL.Method() << function(self)
    local loadedMarkViewDataMap = self.view.levelMapLoader:GetLoadedMarkViewDataMap()
    if loadedMarkViewDataMap == nil or next(loadedMarkViewDataMap) == nil then
        return
    end

    for _, markViewData in pairs(loadedMarkViewDataMap) do
        if self.m_customRefreshMark ~= nil then
            self.m_customRefreshMark(markViewData)
        end
    end
end








LevelMapController._InitControllerSwitchMode = HL.Method() << function(self)
    self.view.markTopOrder:SetAsLastSibling()
    self.view.levelMapLoader:SetLoaderDataUpdateInterval(LEVEL_SWITCH_LOADER_UPDATE_THREAD_INTERVAL)
    self:_RefreshLoaderStateByLevel(self.m_currentLevelId, false)
    self:_RefreshMissionTrackingMarks()

    self.view.levelMapLoader:ToggleLoaderGeneralTrackingVisibleState(not self.m_noGeneralTracking)
    self.view.levelMapLoader:ToggleLoaderMissionTrackingVisibleState(not self.m_noMissionTracking)
    self.view.levelMapLoader:RefreshCharacterPosition()
    self.view.levelMapLoader:SetNeedOptimizePerformance(false)  
end





LevelMapController._RefreshLoaderStateByLevel = HL.Method(HL.String, HL.Boolean) << function(self, levelId, moveNeedTween)
    local success, configInfo = self.m_levelMapConfig.levelConfigInfos:TryGetValue(levelId)
    if not success then
        return
    end

    local gridRectLength = self.m_levelMapConfig.gridRectLength
    local tweenDuration = self.view.config.SWITCH_TWEEN_DURATION
    local tweenEase = self.view.config.SWITCH_TWEEN_CURVE
    local tweenData = moveNeedTween and {
        duration = tweenDuration,
        ease = tweenEase,
    } or nil
    self.m_switchTweenList = {}

    self.view.levelMapLoader:SetLoaderLevel(levelId)
    self.view.levelMapLoader:RefreshLevelSwitchMaskState(levelId)
    local inCurrentLevel = GameWorld.worldInfo.curLevelId == levelId

    if moveNeedTween then
        self.view.levelMapLoader:SetLoaderElementsShownState(false)
    end

    
    local minScale = configInfo.minScale
    local offset = Vector2(
        configInfo.horizontalInitOffsetGridsValue * gridRectLength * minScale,
        configInfo.verticalInitOffsetGridsValue * gridRectLength * minScale
    )
    local loaderPosTween = self.view.levelMapLoader:SetLoaderWithLevelCenterPosition(levelId, offset, tweenData)
    local loaderSizeTween = self.view.levelMapLoader:SetLoaderViewSizeByGridsCount(
        configInfo.horizontalViewGridsCount,
        configInfo.verticalViewGridsCount,
        tweenData
    )
    local loaderMoveSize = Vector2(
        configInfo.horizontalMoveGridsValue * gridRectLength,
        configInfo.verticalMoveGridsValue * gridRectLength
    )
    local initialOffset = Vector2(
        configInfo.horizontalAllInitOffsetGridsValue * gridRectLength,
        configInfo.verticalAllInitOffsetGridsValue * gridRectLength
    )
    local targetInfo = {
        size = loaderMoveSize,
        scale = minScale,
        initialOffset = initialOffset,
    }

    self:_SetCurrentLevelId(levelId)
    self.m_currentMaxScale = configInfo.maxScale
    self.m_currentMinScale = configInfo.minScale

    local onMoveFinish = function()
        self:_RefreshGeneralTrackingMarkInSwitchMode()
        self:_RefreshMissionTrackingMarks()
        self.view.levelMapLoader:SetLoaderPlayerVisibleState(inCurrentLevel)
    end

    
    if moveNeedTween then
        table.insert(self.m_switchTweenList, loaderPosTween)
        table.insert(self.m_switchTweenList, loaderSizeTween)
        self.m_onLevelSwitchStart(targetInfo)  

        local scaleTween = self.view.rectTransform:DOScale(configInfo.minScale, tweenDuration):SetEase(tweenEase)  
        local posTween = self.view.rectTransform:DOAnchorPos(initialOffset, tweenDuration):SetEase(tweenEase)
        table.insert(self.m_switchTweenList, scaleTween)
        table.insert(self.m_switchTweenList, posTween)

        
        
        for index, tween in ipairs(self.m_switchTweenList) do
            tween:OnComplete(function()
                self.m_switchTweenList[index] = nil
                if not next(self.m_switchTweenList) then
                    
                    self:_ResetLoaderMarksVisibleStateByFilter()

                    self.m_delayInvokeTimer = self:_StartTimer(INVOKE_LEVEL_SWITCH_FINISH_DELAY, function()
                        self.m_onLevelSwitchFinish()  
                        self:_ClearTimer(self.m_delayInvokeTimer)
                        self.view.levelMapLoader:RefreshElementsHiddenStateInOtherLevel()
                        self.view.levelMapLoader:SetLoaderElementsShownState(true)
                        onMoveFinish()
                    end)
                end
            end)
        end
    else
        self.view.levelMapLoader:UpdateAndRefreshAll()
        self.view.levelMapLoader:RefreshElementsHiddenStateInOtherLevel()
        self:_ResetLoaderMarksVisibleStateByFilter()
        self.m_onLevelSwitch(targetInfo)

        self.view.rectTransform.anchoredPosition = Vector2.zero
        onMoveFinish()
    end
end



LevelMapController._ResetLoaderMarksVisibleStateByFilter = HL.Method() << function(self)
    self:_UpdateLoaderMarksVisibleData()
    self:_RefreshLoaderMarksVisibleStateByFilter()
end



LevelMapController._UpdateLoaderMarksVisibleData = HL.Method() << function(self)
    local loadedMarkViewDataMap = self.view.levelMapLoader:GetLoadedMarkViewDataMap()
    if loadedMarkViewDataMap == nil or next(loadedMarkViewDataMap) == nil then
        return
    end

    self.m_visibleMarks = {}
    for _, markViewData in pairs(loadedMarkViewDataMap) do
        self.m_visibleMarks[markViewData.instId] = markViewData
    end

    self:_SetMarksToTopOrder()
end



LevelMapController._RefreshLoaderMarksVisibleStateByFilter = HL.Method() << function(self)
    self.m_filteredMarks = {}
    for instId, markViewData in pairs(self.m_visibleMarks) do
        local filterType = markViewData.filterType
        self.m_filteredMarks[instId] = not GameInstance.player.mapManager:HasFilterFlag(filterType)
        self:_RefreshLoaderMarkVisibleState(instId)
    end

    self:_RefreshLoaderLineVisibleState()
end




LevelMapController._RefreshLoaderMarksVisibleStateByLayer = HL.Method(HL.Number) << function(self, layer)
    self.m_layeredMarks = {}
    for instId, markViewData in pairs(self.m_visibleMarks) do
        local visible = markViewData.visibleLayer <= layer
        self.m_layeredMarks[instId] = visible
        self:_RefreshLoaderMarkVisibleState(instId)
    end
    self.m_currentLayer = layer

    self:_RefreshLoaderLineVisibleState()
end




LevelMapController._RefreshLoaderMarkVisibleState = HL.Method(HL.String) << function(self, markInstId)
    local markViewData = self.m_visibleMarks[markInstId]
    if markViewData == nil then
        return
    end
    local isVisible = true
    if not self.m_currentIsSingleLevel then
        isVisible = self:_GetIsMarkRealVisible(markInstId)
    end

    markViewData.markObj:ToggleMarkHiddenState("PanelControl", not isVisible)
end



LevelMapController._RefreshLoaderLineVisibleState = HL.Method() << function(self)
    

    self.view.levelMapLoader:SetLoaderLineVisibleState(true)
    local invisibleLineList = {}

    if next(self.m_expectedMarks) then
        for combinedTemplateId, lineType in pairs(MapConst.COMBINED_TEMPLATE_ID_TO_LINE_TYPE) do
            local isVisible = self.m_expectedMarks[combinedTemplateId]
            if not isVisible then
                invisibleLineList[lineType] = true
            end
        end
    end

    for lineType, fieldName in pairs(MapConst.LINE_TYPE_TO_VISIBLE_LAYER_FIELD_NAME) do
        local isVisible = self.m_currentLayer >= self.m_levelMapConfig[fieldName]
        if not isVisible then
            invisibleLineList[lineType] = true
        end
    end

    for filterType, lineType in pairs(MapConst.FILTER_TYPE_TO_LINE_TYPE) do
        if GameInstance.player.mapManager:HasFilterFlag(filterType) then
            invisibleLineList[lineType] = true
        end
    end

    for lineType, _ in pairs(invisibleLineList) do
        self.view.levelMapLoader:SetLoaderLineVisibleStateByType(lineType, false)
    end
end



LevelMapController._SetTrackingMissionMarksOnClickedCallbackInSwitchMode = HL.Method() << function(self)
    local trackingMissionMarks = self.view.levelMapLoader:GetMissionTrackingMarks()
    if trackingMissionMarks == nil then
        return
    end

    for instId, trackingMark in pairs(trackingMissionMarks) do
        trackingMark:OverrideMarkOnClickCallback(function()
            local relatedMark = self.view.levelMapLoader:GetLoadedMarkByInstId(instId)
            self.m_onTrackingMarkClicked(instId, trackingMark, relatedMark)
        end)
    end
end




LevelMapController._GetIsMarkRealVisible = HL.Method(HL.String).Return(HL.Boolean) << function(self, markInstId)
    local markViewData = self.m_visibleMarks[markInstId]
    if markViewData == nil then
        return false
    end
    if next(self.m_expectedMarks) and not self.m_expectedMarks[markViewData.runtimeData.templateId] then
        if markViewData.runtimeData.isPowerRelated then
            if not self.m_expectedMarks[MapConst.POWER_RELATED_COMBINED_TEMPLATE_ID] then
                return false
            end
        elseif markViewData.runtimeData.isTravelRelated then
            if not self.m_expectedMarks[MapConst.TRAVEL_RELATED_COMBINED_TEMPLATE_ID] then
                return false
            end
        else
            return false
        end
    end
    if self.m_filteredMarks ~= nil and not self.m_filteredMarks[markInstId] then
        return false
    end
    if self.m_layeredMarks ~= nil and not self.m_layeredMarks[markInstId] then
        return false
    end
    return true
end



LevelMapController._SetMarksToTopOrder = HL.Method() << function(self)
    if not next(self.m_topOrderMarks) then
        return
    end

    local loadedMarkViewDataMap = self.view.levelMapLoader:GetLoadedMarkViewDataMap()
    if loadedMarkViewDataMap == nil or next(loadedMarkViewDataMap) == nil then
        return
    end

    for _, markViewData in pairs(loadedMarkViewDataMap) do
        if self.m_topOrderMarks[markViewData.runtimeData.templateId] then
            markViewData.mark.rectTransform:SetParent(self.view.markTopOrder)
        end
    end
end



LevelMapController._RefreshAnimationMistsInSwitchMode = HL.Method() << function(self)
    local showList = {}
    self.m_waitPlayUnlockedAnimMistList = {}

    local mistMapSystem = GameInstance.player.mistMapSystem
    for loaderData in cs_pairs(self.view.levelMapLoader.view.loader.hitGrids) do
        if loaderData.needLoadMists then
            for mistId, _ in pairs(loaderData.mists) do
                if not showList[mistId] and mistMapSystem:IsMistWaitingPlayUnlockedAnimation(mistId) then
                    if showList[mistId] == nil then
                        showList[mistId] = true
                        table.insert(self.m_waitPlayUnlockedAnimMistList, mistId)
                    end
                end
            end
        end
    end

    self.view.levelMapLoader:RefreshAnimationMistState(showList)

    if next(showList) then
        self.view.levelMapLoader:ToggleAnimationMistNodeVisibleState(true)
    end
end




LevelMapController.SetSingleMarkToTopOrder = HL.Method(HL.String) << function(self, markInstId)
    local markViewData = self.view.levelMapLoader:GetLoadedMarkViewDataByInstId(markInstId)
    if markViewData == nil then
        return
    end
    local markRectTransform = markViewData.mark.rectTransform
    self.m_currTopOrderMarkLastOrder = markRectTransform:GetSiblingIndex()
    markRectTransform:SetParent(self.view.markTopOrder)
end




LevelMapController.ResetSingleMarkToOriginalOrder = HL.Method(HL.String) << function(self, markInstId)
    local markViewData = self.view.levelMapLoader:GetLoadedMarkViewDataByInstId(markInstId)
    if markViewData == nil then
        return
    end
    local markRectTransform = markViewData.mark.rectTransform
    markRectTransform:SetParent(self.view.levelMapLoader:GetMarkOrderRoot(markViewData.sortOrder))
    markRectTransform:SetSiblingIndex(self.m_currTopOrderMarkLastOrder)
end








LevelMapController._InitControllerFollowMode = HL.Method() << function(self)
    self.view.levelMapLoader:SetLoaderDataUpdateInterval(FOLLOW_CHARACTER_LOADER_UPDATE_THREAD_INTERVAL)
    self:_RefreshMissionTrackingMarks()

    self:_InitTierStateInFollowMode()
    self.view.levelMapLoader:SetNeedOptimizePerformance(false)  
    GameInstance.player.mapManager.characterFollowerInstance = self.view.characterFollower
    self.view.levelMapLoader:SetNeedOptimizePerformance(true)

    self:_RefreshGeneralTrackingMarkInFollowMode()
end



LevelMapController._OnTeleportFinish = HL.Method() << function(self)
    self.view.levelMapLoader:SetNeedOptimizePerformance(false)  
    GameInstance.player.mapManager:ForceUpdateAndRefreshCharacterFollowerState(false)
    self.view.levelMapLoader:SetNeedOptimizePerformance(true)
end



LevelMapController._InitTierStateInFollowMode = HL.Method() << function(self)
    local needShowTier = GameWorld.mapRegionManager:GetCurrentCharInTierContainerId() > 0
    self:SetLoaderTierStateWithNeedShowMarkTier(needShowTier)
    self:SetLoaderTierStateWithTierId(GameWorld.mapRegionManager:GetCurrentCharInTierId())
end




LevelMapController._OnMistStateChangeInFollowMode = HL.Method(HL.Table) << function(self, args)
    if self.m_waitPlayUnlockedAnimMistQueue == nil then
        self.m_waitPlayUnlockedAnimMistQueue = require_ex("Common/Utils/DataStructure/Queue")()
    end
    self.m_waitPlayUnlockedAnimMistQueue:Push(unpack(args))
    self:_PlayMistUnlockedAnimationWithQueueInFollowMode()
end



LevelMapController._PlayMistUnlockedAnimationWithQueueInFollowMode = HL.Method() << function(self)
    if self.m_waitPlayUnlockedAnimMistQueue:Empty() or self.m_isPlayingUnlockedAnimation then
        return
    end

    self.m_isPlayingUnlockedAnimation = true
    local unlockMistId = self.m_waitPlayUnlockedAnimMistQueue:Pop()
    local levelMapLoader = self.view.levelMapLoader
    levelMapLoader:ToggleAnimationMistNodeVisibleState(false)
    levelMapLoader:ToggleForbidMistRefreshAfterGridChange(true)
    levelMapLoader:RefreshAnimationMistState({ [unlockMistId] = true }, function()
        levelMapLoader:RefreshMistState(function()
            levelMapLoader:ToggleAnimationMistNodeVisibleState(true)
            levelMapLoader:PlayMistsUnlockedAnimation(function()
                levelMapLoader:ToggleForbidMistRefreshAfterGridChange(false)
                levelMapLoader:ToggleAnimationMistNodeVisibleState(false)

                self.m_isPlayingUnlockedAnimation = false
                self:_PlayMistUnlockedAnimationWithQueueInFollowMode()  
            end)
            levelMapLoader:RefreshMarkStateAfterMistUnlocked()
            AudioAdapter.PostEvent("Au_UI_Toast_SmallMapMistDissipate")
        end)
    end)
end





LevelMapController._OnCurrTierRegionStateChangeInFollowMode = HL.Method(HL.Number, HL.Boolean) << function(self, tierId, isIn)
    local tierIndex = GameWorld.mapRegionManager:GetTierIndex(tierId)
    if tierIndex == MapConst.BASE_TIER_INDEX then
        return  
    end
    self:SetLoaderTierStateWithTierId(isIn and tierId or MapConst.BASE_TIER_ID)
end








LevelMapController._OnTrackingStateChanged = HL.Method() << function(self)
    if self.m_mode == ControllerMode.LEVEL_SWITCH then
        self:_RefreshGeneralTrackingMarkInSwitchMode()
    elseif self.m_mode == ControllerMode.FOLLOW_CHARACTER then
        self:_RefreshGeneralTrackingMarkInFollowMode()
    end
end




LevelMapController._RefreshGeneralTrackingMarkOnMarkDataModify = HL.Method(HL.String) << function(self, markInstId)
    if markInstId ~= GameInstance.player.mapManager.trackingMarkInstId then
        return
    end
    self:_OnTrackingStateChanged()
end



LevelMapController._RefreshGeneralTrackingMarkInSwitchMode = HL.Method() << function(self)
    local mapManager = GameInstance.player.mapManager
    local trackingMarkInstId

    if not string.isEmpty(mapManager.trackingMarkInstId) and
        mapManager:GetMarkInstRuntimeDataLevelId(mapManager.trackingMarkInstId) ~= self.m_currentLevelId then
        trackingMarkInstId = ""
    else
        trackingMarkInstId = mapManager.trackingMarkInstId
    end

    self:_RefreshGeneralRelatedMarkVisibleState(self.m_lastTrackingMarkId, trackingMarkInstId)
    self.view.levelMapLoader:SetGeneralTrackingMarkState(trackingMarkInstId)

    local trackingMark = self.view.levelMapLoader:GetGeneralTrackingMark()
    if not string.isEmpty(trackingMarkInstId) then
        trackingMark:OverrideMarkOnClickCallback(function()
            local relatedMark = self.view.levelMapLoader:GetLoadedMarkByInstId(trackingMarkInstId)
            self.m_onTrackingMarkClicked(trackingMarkInstId, trackingMark, relatedMark)
        end)
    end

    self.m_lastTrackingMarkId = trackingMarkInstId
end





LevelMapController._RefreshGeneralRelatedMarkVisibleState = HL.Method(HL.String, HL.String) << function(self, lastId, currId)
    local lastMark = self.view.levelMapLoader:GetLoadedMarkByInstId(lastId)
    local currMark = self.view.levelMapLoader:GetLoadedMarkByInstId(currId)
    if lastMark ~= nil then
        lastMark:ToggleMarkHiddenState("TrackingRelated", lastId == currId)
    end
    if currMark ~= nil then
        currMark:ToggleMarkHiddenState("TrackingRelated", true)
    end
end



LevelMapController._RefreshGeneralTrackingMarkInFollowMode = HL.Method() << function(self)
    local trackingMarkInstId = GameInstance.player.mapManager.trackingMarkInstId
    self:_RefreshGeneralRelatedMarkVisibleState(self.m_lastTrackingMarkId, trackingMarkInstId)
    self.view.levelMapLoader:SetGeneralTrackingMarkState(trackingMarkInstId)
    self.m_lastTrackingMarkId = trackingMarkInstId
    self.m_currFollowModeTrackingMarkId = trackingMarkInstId
end



LevelMapController._RefreshMissionTrackingMarks = HL.Method() << function(self)
    self.m_trackingMissionMarkIdList = {}
    for _,markId in cs_pairs(GameInstance.player.mapManager.trackingMissionMarkList) do
        table.insert(self.m_trackingMissionMarkIdList, markId)
    end
    self.view.levelMapLoader:SetMissionTrackingMarkState(self.m_trackingMissionMarkIdList)
    self:_RefreshMissionRelatedMarksVisibleState()

    if self.m_mode == ControllerMode.LEVEL_SWITCH then
        self:_SetTrackingMissionMarksOnClickedCallbackInSwitchMode()
    end
end



LevelMapController._RefreshMissionRelatedMarksVisibleState = HL.Method() << function(self)
    if self.m_trackingMissionMarkIdList == nil then
        return
    end
    for _, id in pairs(self.m_trackingMissionMarkIdList) do
        local mark = self.view.levelMapLoader:GetLoadedMarkByInstId(id)
        if mark ~= nil then
            mark:ToggleMarkHiddenState("MissionTrackingRelated", true)
        end
    end
end








LevelMapController.GetControllerCurrentMaxScale = HL.Method().Return(HL.Number) << function(self)
    return self.m_currentMaxScale
end



LevelMapController.GetControllerCurrentMinScale = HL.Method().Return(HL.Number) << function(self)
    return self.m_currentMinScale
end



LevelMapController.GetControllerCurrentLevelId = HL.Method().Return(HL.String) << function(self)
    return self.m_currentLevelId
end




LevelMapController.GetControllerMarkRectTransform = HL.Method(HL.String).Return(Unity.RectTransform) << function(self, markInstId)
    local mapManager = GameInstance.player.mapManager
    local trackingMarkInstId = mapManager.trackingMarkInstId
    if markInstId == trackingMarkInstId then
        local mark = self.view.levelMapLoader:GetGeneralTrackingMark()
        return mark.rectTransform
    end

    local trackingMissionMarks = self.view.levelMapLoader:GetMissionTrackingMarks()
    for instId, trackingMissionMark in pairs(trackingMissionMarks) do
        if instId == markInstId then
            return trackingMissionMark.rectTransform
        end
    end

    return self.view.levelMapLoader:GetMarkRectTransformByInstId(markInstId)
end







LevelMapController.GetControllerNearbyMarkList = HL.Method(HL.String, HL.Number, HL.Number, HL.Opt(GEnums.MarkType)).Return(HL.Table) << function(self, targetInstId, length, scale, markTypeFilter)
    length = length / scale / 2.0
    local targetViewData = self.m_visibleMarks[targetInstId]
    if targetViewData == nil then
        return {}
    end
    local targetMark = targetViewData.mark
    local targetPos = targetMark.rectTransform.anchoredPosition

    local tempResult = {}
    for instId, markViewData in pairs(self.m_visibleMarks) do
        if instId ~= targetInstId and self:_GetIsMarkRealVisible(instId) then
            local isValidMark = self.view.levelMapLoader:GetLoadedMarkByInstId(instId) ~= nil
            if isValidMark then
                local mark = markViewData.mark
                local pos = mark.rectTransform.anchoredPosition
                if math.abs(pos.x - targetPos.x) <= length and math.abs(pos.y - targetPos.y) <= length then
                    local validNearby = true

                    local markSuccess, runtimeData = GameInstance.player.mapManager:GetMarkInstRuntimeData(markViewData.instId)
                    if markSuccess then
                        local templateSuccess, templateData = Tables.mapMarkTempTable:TryGetValue(runtimeData.templateId)
                        if templateSuccess then
                            if markTypeFilter and templateData.markType ~= markTypeFilter then
                                validNearby = false
                            end

                            if markViewData.instId == GameInstance.player.mapManager:GetNowSelectCustomMarkInsId() then
                                validNearby = false
                            end

                            if instId == GameInstance.player.mapManager.trackingMarkInstId then
                                local trackingMark = self.view.levelMapLoader:GetGeneralTrackingMark()
                                if trackingMark.view.levelMapLimitInRect ~= nil and trackingMark.view.levelMapLimitInRect.isLimitedInRect then
                                    validNearby = false
                                end
                            end

                            if self.m_trackingMissionMarkIdList ~= nil then
                                for _, missionInstId in ipairs(self.m_trackingMissionMarkIdList) do
                                    if instId == missionInstId then
                                        local trackingMarks = self.view.levelMapLoader:GetMissionTrackingMarks()
                                        local trackingMark = trackingMarks[instId]
                                        if trackingMark ~= nil and trackingMark.view.levelMapLimitInRect ~= nil and trackingMark.view.levelMapLimitInRect.isLimitedInRect then
                                            validNearby = false
                                        end
                                    end
                                end
                            end

                            if validNearby then
                                table.insert(tempResult, markViewData)
                            end
                        end
                    end
                end
            end
        end
    end
    table.sort(tempResult, Utils.genSortFunction({ "sortId" }, false))

    local result = {}
    if targetInstId ~= GameInstance.player.mapManager:GetNowSelectCustomMarkInsId() then
        table.insert(result, targetInstId)
    end
    for _, markViewData in ipairs(tempResult) do
        table.insert(result, markViewData.instId)
    end

    return result
end




LevelMapController.GetControllerMarkByInstId = HL.Method(HL.String).Return(HL.Any) << function(self, instId)
    return self.view.levelMapLoader:GetLoadedMarkByInstId(instId)
end



LevelMapController.NeedPlayMistsUnlockedAnimation = HL.Method().Return(HL.Boolean) << function(self)
    return next(self.m_waitPlayUnlockedAnimMistList) ~= nil
end




LevelMapController.TryPlayMistUnlockedAnimation = HL.Method(HL.Function) << function(self, onComplete)
    self.view.levelMapLoader:PlayMistsUnlockedAnimation(onComplete)
    GameInstance.player.mistMapSystem:AddMistUnlockedAnimationPlayed(self.m_waitPlayUnlockedAnimMistList)
    self.m_waitPlayUnlockedAnimMistList = {}
end




LevelMapController.RefreshLoaderMarksVisibleStateByLayer = HL.Method(HL.Number) << function(self, layer)
    self:_RefreshLoaderMarksVisibleStateByLayer(layer)
end




LevelMapController.ResetSwitchModeToTargetLevelState = HL.Method(HL.String) << function(self, levelId)
    local targetSuccess, targetLevelConfig = DataManager.levelConfigTable:TryGetData(levelId)
    if not targetSuccess then
        return
    end

    local currSuccess, currLevelConfig = DataManager.levelConfigTable:TryGetData(self.m_currentLevelId)
    if not currSuccess then
        return
    end

    if targetLevelConfig.mapIdStr ~= currLevelConfig.mapIdStr then
        self.view.levelMapLoader:ResetToTargetMapAndLevel(levelId)
    end
    self:_RefreshLoaderStateByLevel(levelId, false)
end




LevelMapController.SetLoaderTierStateWithTierId = HL.Method(HL.Number) << function(self, tierId)
    self.view.levelMapLoader:SetLoaderTierId(tierId)
end




LevelMapController.SetLoaderTierStateWithNeedShowMarkTier = HL.Method(HL.Boolean) << function(self, needShow)
    self.view.levelMapLoader:ToggleLoaderNeedShowMarkTier(needShow)
end




LevelMapController.SwitchToTargetLevel = HL.Method(HL.String) << function(self, levelId)
    self:_RefreshLoaderStateByLevel(levelId, true)
end





HL.Commit(LevelMapController)
return LevelMapController