local XGoldenMinerComponentHook = require("XUi/XUiGoldenMiner/Game/Component/XGoldenMinerComponentHook")
local XGoldenMinerComponentStone = require("XUi/XUiGoldenMiner/Game/Component/XGoldenMinerComponentStone")
local XGoldenMinerComponentMove = require("XUi/XUiGoldenMiner/Game/Component/XGoldenMinerComponentMove")
local XGoldenMinerComponentMouse = require("XUi/XUiGoldenMiner/Game/Component/XGoldenMinerComponentMouse")
local XGoldenMinerComponentQTE = require("XUi/XUiGoldenMiner/Game/Component/XGoldenMinerComponentQTE")
local XGoldenMinerComponentMussel = require("XUi/XUiGoldenMiner/Game/Component/XGoldenMinerComponentMussel")
local XGoldenMinerComponentDirectionPoint = require("XUi/XUiGoldenMiner/Game/Component/XGoldenMinerComponentDirectionPoint")
local XGoldenMinerComponentTimeLineAnim = require("XUi/XUiGoldenMiner/Game/Component/XGoldenMinerComponentTimeLineAnim")
local XGoldenMinerEntityHook = require("XUi/XUiGoldenMiner/Game/Entity/XGoldenMinerEntityHook")
local XGoldenMinerEntityStone = require("XUi/XUiGoldenMiner/Game/Entity/XGoldenMinerEntityStone")
local XGoldenMinerEntityBuffContainer = require("XUi/XUiGoldenMiner/Game/Entity/XGoldenMinerEntityBuffContainer")
local XGoldenMinerSystemHook = require("XUi/XUiGoldenMiner/Game/System/XGoldenMinerSystemHook")
local XGoldenMinerSystemStone = require("XUi/XUiGoldenMiner/Game/System/XGoldenMinerSystemStone")
local XGoldenMinerSystemMove = require("XUi/XUiGoldenMiner/Game/System/XGoldenMinerSystemMove")
local XGoldenMinerSystemBuff = require("XUi/XUiGoldenMiner/Game/System/XGoldenMinerSystemBuff")
local XGoldenMinerSystemQTE = require("XUi/XUiGoldenMiner/Game/System/XGoldenMinerSystemQTE")
local XGoldenMinerSystemTimeLineAnim = require("XUi/XUiGoldenMiner/Game/System/XGoldenMinerSystemTimeLineAnim")
local XGoldenMinerMapStoneData = require("XEntity/XGoldenMiner/Game/XGoldenMinerMapStoneData")

local GAME_STATUS = {
    NONE = 0,
    INIT = 1,
    PLAY = 2,
    PAUSE = 3,
    END = 4,
    QTE = 5,
    TIME_STOP = 6,
}
local MIN_FRAME_TIME = 1 / 20
local MILLION_PERCENT = 1000000
local W_PERCENT = 10000

local CSXResourceManagerLoad = CS.XResourceManager.Load

---@class XGoldenMinerGame
local XGoldenMinerGame = XClass(nil, "XGoldenMinerGame")

function XGoldenMinerGame:Ctor()
    ---@type XGoldenMinerGameData
    self._Data = false

    ---一级状态：游戏状态
    self._Status = GAME_STATUS.NONE

    ---二级状态：暂停原因
    self._PauseReason = XGoldenMinerConfigs.GAME_PAUSE_TYPE.NONE

    ---暂停前状态缓存
    self._PauseStageCatchStatus = GAME_STATUS.NONE

    ---时间停止前状态缓存
    self._TimeStopCatchStatus = GAME_STATUS.NONE

    ---QTE前状态缓存
    self._QTECatchStatus = GAME_STATUS.NONE

    ---@type UnityEngine.Transform
    self._MapObjRoot = false

    ---@type UnityEngine.Vector2
    self._RectSize = false

    ---@type UnityEngine.Transform[]
    self._HookObjDir = {}

    ---@type UnityEngine.Transform
    self._HookRoot = false

    ---资源字典
    self._ResourcePool = {}

    self.BuffIdList = {}
    
    ---@type XGoldenMinerEntityBuffContainer
    self.BuffContainer = XGoldenMinerEntityBuffContainer.New()

    ---@type XGoldenMinerEntityHook[]
    self.HookEntityList = false
    
    self.HookEntityStatus = XGoldenMinerConfigs.GAME_HOOK_ENTITY_STATUS.NONE

    ---@type XGoldenMinerEntityStone[]
    self.StoneEntityList = {}

    ---QTE触发钩子
    ---@type XGoldenMinerEntityHook
    self.QTEHookEntity = false

    ---QTE触发抓取
    ---@type XGoldenMinerEntityStone
    self.QTEStoneEntity = false

    ---QTE触发钩子缓存
    ---@type XGoldenMinerEntityHook
    self.QTECatchHookEntityList = { }

    ---QTE触发抓取缓存
    ---@type XGoldenMinerEntityStone
    self.QTECatchStoneEntityList = { }
    
    ---@type XGoldenMinerSystemHook
    self.SystemHook = XGoldenMinerSystemHook.New()

    ---@type XGoldenMinerSystemStone
    self.SystemStone = XGoldenMinerSystemStone.New()
    
    ---@type XGoldenMinerSystemMove
    self.SystemMove = XGoldenMinerSystemMove.New()

    ---@type XGoldenMinerSystemBuff
    self.SystemBuff = XGoldenMinerSystemBuff.New()

    ---@type XGoldenMinerSystemQTE
    self.SystemQTE = XGoldenMinerSystemQTE.New()

    ---@type XGoldenMinerSystemTimeLineAnim
    self.SystemTimeLimeAnim = XGoldenMinerSystemTimeLineAnim.New()
end

--region GameControl
function XGoldenMinerGame:Init()
    if not self:_IsStatus(GAME_STATUS.NONE) then
        return
    end
    self._Status = GAME_STATUS.INIT
    self:InitHook()
    self:InitMap()
    self:InitBuff()
    self:InitTimeLineAnim()
    self._Status = GAME_STATUS.PLAY
end

function XGoldenMinerGame:Update(time)
    time = self:_CheckFrameTime(time)
    if self:IsQTE() then
        self:UpdateQTE(time)
    elseif self:IsPlay() then
        self:UpdateTime(time)
        self:UpdateBuff(time)
        self:UpdateHook(time)
        self:UpdateStone(time)
        self:UpdateStoneMove(time)
        self:UpdateTimeLineAnim(time)
    elseif self:IsTimeStop() then
        self:UpdateBuff(time)
        self:UpdateHook(time)
        self:UpdateStone(time)
        self:UpdateTimeLineAnim(time)
    end
end

function XGoldenMinerGame:Resume(reason)
    if self:IsEnd() then
        return
    end
    if reason then
        self._PauseReason = self._PauseReason & (~reason)
    end
    if self._PauseReason ~= XGoldenMinerConfigs.GAME_PAUSE_TYPE.NONE then
        return
    end
    self._Status = self._PauseStageCatchStatus
end

function XGoldenMinerGame:Pause(reason)
    if self:IsEnd() or self:IsPause(reason) then
        return
    end
    if not self:IsPause() then
        self._PauseStageCatchStatus = self._Status
    end
    if reason then
        self._PauseReason = self._PauseReason | reason
    end

    self._Status = GAME_STATUS.PAUSE
end

function XGoldenMinerGame:GameOver()
    self._Status = GAME_STATUS.END
end

function XGoldenMinerGame:TimeStop()
    if self:IsEnd() or self:IsPause() then
        return
    end
    if not self:IsTimeStop() then
        self._TimeStopCatchStatus = self._Status
    end
    self._Status = GAME_STATUS.TIME_STOP
end

function XGoldenMinerGame:TimeResume()
    if self:IsEnd() or self:IsPause() then
        return
    end
    if self._TimeStopCatchStatus == GAME_STATUS.NONE then
        return
    end
    self._Status = self._TimeStopCatchStatus
end

function XGoldenMinerGame:Destroy()
    for _, resource in pairs(self._ResourcePool) do
        resource:Release()
    end
    self._Data = nil
    self._Status = nil
    self._PauseReason = nil
    self._PauseStageCatchStatus = nil
    self._MapObjRoot = nil
    self._RectSize = nil
    self._MapObjRoot = nil
    self._HookObjDir = nil
    self._HookRoot = nil
    self.HookEntityList = nil
    self.StoneEntityList = nil
    self.QTEHookEntity = nil
    self.QTEStoneEntity = nil
    self.SystemHook = nil
    self.SystemStone = nil
    self.SystemMove = nil
    self.SystemBuff = nil
    self.SystemQTE = nil
    self.SystemTimeLimeAnim = nil
end
--endregion

--region GameCheck
function XGoldenMinerGame:CheckIsStoneClear()
    for _, stoneEntity in ipairs(self.StoneEntityList) do
        if not stoneEntity.HookDirectionPoint and
                stoneEntity.Status ~= XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.GRABBED and
                stoneEntity.Status ~= XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.DESTROY
        then
            return false
        end
    end
    self._Status = GAME_STATUS.END
    XEventManager.DispatchEvent(XEventId.EVENT_GOLDEN_MINER_GAME_STONE_CLEAR)
    return true
end

---防止卡顿跳帧
function XGoldenMinerGame:_CheckFrameTime(time)
    if time > MIN_FRAME_TIME then
        time = MIN_FRAME_TIME
    end
    return time
end

---@param status number GAME_STATUS
function XGoldenMinerGame:_IsStatus(status)
    return self._Status == status
end

function XGoldenMinerGame:IsRunning()
    return self:_IsStatus(GAME_STATUS.INIT)
            or self:IsPlay()
            or self:IsQTE()
            or self:IsTimeStop()
end

function XGoldenMinerGame:IsPlay()
    return self:_IsStatus(GAME_STATUS.PLAY)
end

function XGoldenMinerGame:IsQTE()
    return self:_IsStatus(GAME_STATUS.QTE)
end

function XGoldenMinerGame:IsPause(reason)
    local isReason = true
    if reason then
        isReason = self._PauseReason & reason ~= XGoldenMinerConfigs.GAME_PAUSE_TYPE.NONE
    end
    return self:_IsStatus(GAME_STATUS.PAUSE) and isReason
end

function XGoldenMinerGame:IsTimeStop()
    return self:_IsStatus(GAME_STATUS.TIME_STOP)
end

function XGoldenMinerGame:IsEnd()
    return self:_IsStatus(GAME_STATUS.END)
end
--endregion

--region Data
---@param data XGoldenMinerGameData
function XGoldenMinerGame:SetData(data)
    self._Data = data
end

function XGoldenMinerGame:SetBuffIdList(buffIdList)
    self.BuffIdList = buffIdList
end

---@param mapObjRoot UnityEngine.Transform
function XGoldenMinerGame:SetMapObjRoot(mapObjRoot)
    self._MapObjRoot = mapObjRoot
end

---@param rectSize UnityEngine.Vector2
function XGoldenMinerGame:SetRectSize(rectSize)
    self._RectSize = rectSize
end

---@param hookObjDir UnityEngine.Transform[]
function XGoldenMinerGame:SetHookObjDir(hookObjDir)
    self._HookObjDir = hookObjDir
end

---@param hookColliderDir UnityEngine.Collider2D[]
function XGoldenMinerGame:SetHookColliderDir(hookRoot)
    self._HookRoot = hookRoot
end

function XGoldenMinerGame:GetData()
    return self._Data
end

function XGoldenMinerGame:GetCurScore()
    if not self._Data then
        return 0
    end
    return self._Data:GetCurScore()
end

function XGoldenMinerGame:GetChangeScore()
    if not self._Data then
        return 0
    end
    return self._Data:GetChangeScore()
end

function XGoldenMinerGame:GetOldScore()
    if not self._Data then
        return 0
    end
    return self._Data:GetOldScore()
end

---@return XGoldenMinerEntityStone[]
function XGoldenMinerGame:GetGrabbedStoneEntityList()
    local result = {}
    for _, hookEntity in ipairs(self.HookEntityList) do
        if not XTool.IsTableEmpty(hookEntity.HookGrabbedStoneList) then
            for _, stoneEntity in ipairs(hookEntity.HookGrabbedStoneList) do
                result[#result + 1] = stoneEntity
            end
        end
    end
    return result
end

---@return XGoldenMinerEntityStone[]
function XGoldenMinerGame:GetGrabbedScoreDir()
    local result = {}
    local AddScore = function(type, score)
        if not XTool.IsNumberValid(result[type]) then
            result[type] = 0
        end
        result[type] = result[type] + score
    end
    for _, hookEntity in ipairs(self.HookEntityList) do
        if not XTool.IsTableEmpty(hookEntity.HookGrabbedStoneList) then
            for _, stoneEntity in ipairs(hookEntity.HookGrabbedStoneList) do
                local type = stoneEntity.Data:GetType()
                if type == XGoldenMinerConfigs.StoneType.Mussel and stoneEntity.CarryStone then
                    type = stoneEntity.CarryStone.Data:GetType()
                end
                AddScore(type, stoneEntity.Stone.CurScore)
                if stoneEntity.CarryStone then
                    AddScore(type, stoneEntity.CarryStone.Stone.CurScore)
                end
                if stoneEntity.QTE then
                    AddScore(type, stoneEntity.QTE.AddScore)
                end
            end
        end
    end
    return result
end

function XGoldenMinerGame:GetStopTime()
    if not self.SystemBuff then
        return 0
    end
    local time = 0
    ---@type XGoldenMinerComponentBuff
    local buff
    buff = self.SystemBuff:GetAliveBuffByType(self.BuffContainer, XGoldenMinerConfigs.BuffType.GoldenMinerUseItemStopTime)
    if buff then
        time = time + buff.Time
    end
    buff = self.SystemBuff:GetAliveBuffByType(self.BuffContainer, XGoldenMinerConfigs.BuffType.GoldenMinerItemStopTime)
    if buff then
        time = time + buff.Time
    end
    return math.ceil(time)
end

function XGoldenMinerGame:AddMapScore(score)
    self._Data:SetMapScore(self._Data:GetMapScore() + score)
    XEventManager.DispatchEvent(XEventId.EVENT_GOLDEN_MINER_GAME_ADD_SCORE)
end

function XGoldenMinerGame:AddTime(time)
    self._Data:SetTime(self._Data:GetTime() + time)
    XEventManager.DispatchEvent(XEventId.EVENT_GOLDEN_MINER_GAME_ADD_TIME, time)
end

function XGoldenMinerGame:AddItem(itemId)
    if not XTool.IsNumberValid(itemId) then
        return
    end
    XEventManager.DispatchEvent(XEventId.EVENT_GOLDEN_MINER_GAME_ADD_ITEM, itemId)
end
--endregion

--region Data - Time
---@param usedTime number 经过的时间
function XGoldenMinerGame:UpdateTime(usedTime)
    if self:IsEnd() then
        return
    end
    local curUsedTime = self._Data:GetUsedTime()
    self._Data:SetUsedTime(curUsedTime + usedTime)
    self:ChangeTime(usedTime)
end

---改变时间
function XGoldenMinerGame:ChangeTime(usedTime)
    local curTime = self._Data:GetTime()
    self._Data:SetTime(curTime - usedTime)
    if self._Data:IsTimeOut() then
        self._Status = GAME_STATUS.END
        XEventManager.DispatchEvent(XEventId.EVENT_GOLDEN_MINER_GAME_TIMEOUT)
    end
end
--endregion

--region Data - HideTask
---隐藏任务
---@param hookEntity XGoldenMinerEntityHook
function XGoldenMinerGame:CheckHideTask(hookEntity)
    if XTool.IsTableEmpty(hookEntity.HookGrabbingStoneList) then
        return
    end
    local hideTaskList = self._Data:GetHideTaskInfoList()
    if XTool.IsTableEmpty(hideTaskList) then
        return
    end
    for _, hideTaskInfo in ipairs(hideTaskList) do
        if not hideTaskInfo:IsFinish() then
            local type = hideTaskInfo:GetType()
            if type == XGoldenMinerConfigs.HideTaskType.GrabStone then
                for _, stoneEntity in ipairs(hookEntity.HookGrabbingStoneList) do
                    if stoneEntity.Data:GetId() == hideTaskInfo:GetParams()[1] then
                        hideTaskInfo:AddCurProgress()
                    end
                end
            elseif type == XGoldenMinerConfigs.HideTaskType.GrabStoneByOnce then
                local isFinish = false
                for _, stoneEntity in ipairs(hookEntity.HookGrabbingStoneList) do
                    if stoneEntity.Data:GetId() == hideTaskInfo:GetParams()[1] then
                        hideTaskInfo:SetCatchValue(hideTaskInfo:GetCatchValue() + 1)
                        isFinish = hideTaskInfo:GetCatchValue() >= hideTaskInfo:GetParams()[2]
                    end
                end
                if isFinish then
                    hideTaskInfo:AddCurProgress()
                end
            elseif type == XGoldenMinerConfigs.HideTaskType.GrabStoneInBuff then
                -- 在某Buff加持下抓取物品
                if self:CheckHasBuffByBuffId(hideTaskInfo:GetParams()[2]) then
                    for _, stoneEntity in ipairs(hookEntity.HookGrabbingStoneList) do
                        if stoneEntity.Data:GetId() == hideTaskInfo:GetParams()[1] then
                            hideTaskInfo:AddCurProgress()
                        end
                    end
                end
            elseif type == XGoldenMinerConfigs.HideTaskType.GrabStoneByReflection then
                local isGrab = false
                local isHitCount = 0
                for _, stoneEntity in ipairs(hookEntity.HookGrabbingStoneList) do
                    if stoneEntity.Data:GetId() == hideTaskInfo:GetParams()[1] then
                        isGrab = true
                    end
                end

                if not XTool.IsTableEmpty(hookEntity.HookHitStoneList) then
                    for i = 2, #hideTaskInfo:GetParams() do
                        for _, stoneEntity in ipairs(hookEntity.HookHitStoneList) do
                            if stoneEntity.Data:GetId() == hideTaskInfo:GetParams()[i] then
                                isHitCount = isHitCount + 1
                            end
                        end
                    end
                end
                if isGrab and isHitCount >= #hideTaskInfo:GetParams() - 1 then
                    hideTaskInfo:AddCurProgress()
                end
            elseif type == XGoldenMinerConfigs.HideTaskType.GrabDrawMap then
                local mapDrawGroup = XGoldenMinerConfigs.GetHideTaskMapDrawGroup(hideTaskInfo:GetParams()[1])
                local isFinish = true
                for _, drawId in ipairs(mapDrawGroup) do
                    local index = XGoldenMinerConfigs.GetHideTaskMapDrawGroupStoneIdIndex(drawId)
                    local isStay = XGoldenMinerConfigs.GetHideTaskMapDrawGroupIsStay(drawId)
                    local stoneEntity = self.StoneEntityList[index]
                    if isStay then
                        if stoneEntity.Status ~= XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.ALIVE then
                            isFinish = false
                        end
                    else
                        if stoneEntity.Status ~= XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.GRABBED
                                and stoneEntity.Status ~= XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.BE_DESTROY
                                and stoneEntity.Status ~= XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.DESTROY
                        then
                            isFinish = false
                        end
                    end
                end
                if isFinish then
                    hideTaskInfo:AddCurProgress()
                end
            end
            if hideTaskInfo:IsFinish() then
                --XGoldenMinerConfigs.DebugLog("隐藏任务完成:HideTaskId="..hideTaskInfo:GetId())
            end
        end
    end
end

---隐藏任务缓存值清除
function XGoldenMinerGame:ClearHideTaskCatch()
    local hideTaskList = self._Data:GetHideTaskInfoList()
    if XTool.IsTableEmpty(hideTaskList) then
        return
    end
    for _, hideTaskInfo in ipairs(hideTaskList) do
        if not hideTaskInfo:IsFinish() then
            hideTaskInfo:SetCatchValue(0)
        end
    end
end
--endregion

--region System - HookEntity
function XGoldenMinerGame:InitHook()
    self.HookEntityList = {}
    for _, type in ipairs(self._Data:GetHookTypeList()) do
        ---@type XGoldenMinerEntityHook
        local hookEntity = XGoldenMinerEntityHook.New()
        hookEntity.Hook = self:_CreateHookComponent(type, self._HookObjDir[type], self._HookRoot)
        hookEntity.HookGrabbingStoneList = {}
        hookEntity.HookGrabbedStoneList = {}
        hookEntity.HookHitStoneList = {}

        for _, aim in pairs(hookEntity.Hook.AimTranList) do
            local length = math.ceil(math.sqrt(self._RectSize.x ^ 2 + self._RectSize.y ^ 2))
            local rectTran = aim.gameObject:GetComponent("RectTransform")
            local sizeDelta = rectTran.sizeDelta
            rectTran.sizeDelta = Vector2(sizeDelta.x, length)
            aim.gameObject:SetActiveEx(false)
        end
        self:RegisterHookHitCallBack(hookEntity)
        self.HookEntityList[#self.HookEntityList + 1] = hookEntity
    end

    if self.SystemHook then
        self.SystemHook:Init(self)
    end
end

function XGoldenMinerGame:UpdateHook(time)
    if self:IsEnd() then
        return
    end
    if not self.SystemHook then
        return
    end
    self.SystemHook:Update(self, time)
end

---@return XGoldenMinerComponentHook
function XGoldenMinerGame:_CreateHookComponent(type, hookObj, hookRoot)
    if XTool.UObjIsNil(hookObj) then
        return false
    end
    ---@type XGoldenMinerComponentHook
    local hook = XGoldenMinerComponentHook.New()
    hook.Type = type
    hook.Transform = hookObj

    hook.HookObj = XUiHelper.TryGetComponent(hook.Transform, "Hook")
    hook.HookObjStartLocalPosition = hook.HookObj.localPosition
    hook.RopeObjList = { XUiHelper.TryGetComponent(hook.Transform, "RopeRoot/Rope") }
    hook.RopeObjStartLocalPosition = hook.RopeObjList[1].localPosition

    local Collider2DList = hook.HookObj.gameObject:GetComponentsInChildren(typeof(CS.UnityEngine.Collider2D))
    for i = 0, Collider2DList.Length - 1 do
        hook.ColliderList[i + 1] = Collider2DList[i]
        hook.GoInputHandlerList[i + 1] = hook.ColliderList[i + 1].transform:GetComponent(typeof(CS.XGoInputHandler))
        if XTool.UObjIsNil(hook.GoInputHandlerList[i + 1]) then
            hook.GoInputHandlerList[i + 1] = hook.ColliderList[i + 1].transform.gameObject:AddComponent(typeof(CS.XGoInputHandler))
        end
    end
    -- 绳子碰撞点，用于碰撞转向点
    local ropeColliderObj = XUiHelper.TryGetComponent(hook.Transform, "RopeCollider")
    if ropeColliderObj then
        hook.RopeCollider = ropeColliderObj.transform:GetComponent(typeof(CS.UnityEngine.Collider2D))
        hook.RopeInputHandler = hook.RopeCollider.transform:GetComponent(typeof(CS.XGoInputHandler))
        if XTool.UObjIsNil(hook.RopeInputHandler) then
            hook.RopeInputHandler = hook.RopeCollider.gameObject:AddComponent(typeof(CS.XGoInputHandler))
        end
    end

    hook.GrabPoint = XUiHelper.TryGetComponent(hook.Transform, "Hook/RopeCord/TriggerObjs")
    hook.AimTranList = {
        XUiHelper.TryGetComponent(hook.Transform, "Hook/RopeCord/Aim"),
        XUiHelper.TryGetComponent(hook.Transform, "Hook/RopeCord/Aim2"),
        XUiHelper.TryGetComponent(hook.Transform, "Hook/RopeCord/Aim3")
    }

    hook.RopeMaxLength = math.ceil(math.sqrt(self._RectSize.x ^ 2 + self._RectSize.y ^ 2) + XGoldenMinerConfigs.GetHookRopeExLength())
    hook.RopeMinLength = hook.RopeObjList[1].sizeDelta.y
    hook.RopeLength = hook.RopeMinLength
    hook.IdleSpeed = XGoldenMinerConfigs.GetRopeRockSpeed()
    hook.ShootSpeed = XGoldenMinerConfigs.GetRopeStretchSpeed()
    hook.CurShootSpeed = hook.ShootSpeed
    hook.IdleRotateDirection = false
    hook.CurIdleRotateAngle = hook.Transform.localRotation.eulerAngles
    return hook
end

---@param hookEntity XGoldenMinerEntityHook
function XGoldenMinerGame:RegisterHookHitCallBack(hookEntity)
    if not hookEntity.Hook or XTool.IsTableEmpty(hookEntity.Hook.GoInputHandlerList) then
        return
    end
    for _, goInputHandler in ipairs(hookEntity.Hook.GoInputHandlerList) do
        goInputHandler:AddTriggerEnter2DCallback(function(collider)
            self:HookHit(hookEntity, collider)
        end)
    end
    if hookEntity.Hook.RopeInputHandler then
        hookEntity.Hook.RopeInputHandler:AddTriggerEnter2DCallback(function(collider)
            self:RopeHit(hookEntity, collider)
        end)
    end
end

function XGoldenMinerGame:HookShoot()
    self:ClearHideTaskCatch()
    if self.SystemHook then
        self.SystemHook:HookShoot(self)
    end
end

---@param hookEntity XGoldenMinerEntityHook
---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:HookGrab(hookEntity, stoneEntity)
    if not self.SystemHook then
        return
    end

    self:SetStoneGrab(hookEntity, stoneEntity)
    if self.SystemTimeLimeAnim then
        self.SystemTimeLimeAnim:PlayAnim(hookEntity, XGoldenMinerConfigs.GAME_ANIM.HOOK_CLOSE, function()
            self:HookRevoke(hookEntity)
        end)
    else
        self.SystemHook:HookRevoke(self, hookEntity.Hook)
    end
end

---@param hookEntity XGoldenMinerEntityHook
function XGoldenMinerGame:HookRevoke(hookEntity)
    if self.SystemHook then
        self.SystemHook:HookRevoke(self, hookEntity.Hook)
    end
end

---@param hookEntity XGoldenMinerEntityHook
---@param collider UnityEngine.Collider2D
function XGoldenMinerGame:HookHit(hookEntity, collider)
    local stoneEntity = self:FindStoneEntityByCollider(collider)
    local hitHookEntity = self:FindHookEntityByCollider(collider)
    if hitHookEntity then
        return
    end
    if self.SystemHook then
        self.SystemHook:OnHookHit(self, hookEntity, stoneEntity)
    end
end

---@param hookEntity XGoldenMinerEntityHook
---@param collider UnityEngine.Collider2D
function XGoldenMinerGame:RopeHit(hookEntity, collider)
    local stoneEntity = self:FindStoneEntityByCollider(collider)
    local hitHookEntity = self:FindHookEntityByCollider(collider)
    if hitHookEntity then
        return
    end
    if self.SystemHook then
        self.SystemHook:OnRopeHit(self, hookEntity, stoneEntity)
    end
end

---@param hookEntity XGoldenMinerEntityHook
function XGoldenMinerGame:OnHookRevokeToIdle(hookEntity)
    local score = 0
    -- 收回
    for _, stoneEntity in ipairs(hookEntity.HookGrabbingStoneList) do
        if stoneEntity.Status == XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.GRABBED then
            -- Buff
            self:TriggerStoneGrabBuff(stoneEntity)
            -- 加分
            score = score + stoneEntity.Stone.CurScore
            -- 特殊抓取物触发
            self:CheckHookRevokeToIdle(stoneEntity)

            if stoneEntity.CarryStone then
                score = score + stoneEntity.CarryStone.Stone.CurScore
                self:CheckHookRevokeToIdle(stoneEntity.CarryStone)
            end

            if stoneEntity.QTE then
                score = score + stoneEntity.QTE.AddScore
                if XTool.IsNumberValid(stoneEntity.QTE.AddBuff) then
                    self:AddBuff(stoneEntity.QTE.AddBuff)
                end
                if XTool.IsNumberValid(stoneEntity.QTE.AddItemId) then
                    self:AddItem(stoneEntity.QTE.AddItemId)
                end
            end
        end
    end
    if self.SystemTimeLimeAnim and not XTool.IsTableEmpty(hookEntity.HookGrabbingStoneList) then
        self.SystemTimeLimeAnim:PlayAnim(hookEntity, XGoldenMinerConfigs.GAME_ANIM.HOOK_OPEN)
    end
    self:AddMapScore(score)
    -- 隐藏任务
    self:CheckHideTask(hookEntity)
    -- 表情
    XEventManager.DispatchEvent(XEventId.EVENT_GOLDEN_MINER_GAME_PLAY_FACE,
            XGoldenMinerConfigs.GAME_FACE_PLAY_TYPE.GRABBED,
            XGoldenMinerConfigs.GAME_FACE_PLAY_ID.GRABBED)
    -- 清理
    hookEntity.HookGrabbingStoneList = {}
    hookEntity.HookHitStoneList = {}
    self:TriggerCountRevokeEndCountBuff()
    self:CheckIsStoneClear()
end

---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:CheckHookRevokeToIdle(stoneEntity)
    -- 特殊抓取物触发
    if stoneEntity.Data:GetType() == XGoldenMinerConfigs.StoneType.RedEnvelope then
        local redEnvelopeId = stoneEntity.AdditionValue[XGoldenMinerConfigs.StoneType.RedEnvelope]
        if not redEnvelopeId then
            local redEnvelopeGroup = stoneEntity.Data:GetRedEnvelopeGroup()
            redEnvelopeId = XGoldenMinerConfigs.GetRedEnvelopeRandId(redEnvelopeGroup)
            stoneEntity.AdditionValue[XGoldenMinerConfigs.StoneType.RedEnvelope] = redEnvelopeId
        end
        local itemId = XGoldenMinerConfigs.GetRedEnvelopeItemId(redEnvelopeId)
        stoneEntity.Stone.Score = itemId
        self:AddItem(itemId)
    elseif stoneEntity.Data:GetType() == XGoldenMinerConfigs.StoneType.AddTimeStone then
        self:AddTime(stoneEntity.Data:GetAddTimeStoneAddTime())
    elseif stoneEntity.Data:GetType() == XGoldenMinerConfigs.StoneType.ItemStone then
        self:UseItemToAddBuff(stoneEntity.Data:GetItemStoneItemId())
    end
end

function XGoldenMinerGame:HookAimRight()
    for _, hookEntity in ipairs(self.HookEntityList) do
        hookEntity.Hook.IdleRotateDirection = Vector3.forward
    end
end

function XGoldenMinerGame:HookAimLeft()
    for _, hookEntity in ipairs(self.HookEntityList) do
        hookEntity.Hook.IdleRotateDirection = Vector3.back
    end
end

function XGoldenMinerGame:HookAimIdle()
    for _, hookEntity in ipairs(self.HookEntityList) do
        hookEntity.Hook.IdleRotateDirection = false
    end
end

---@param hook XGoldenMinerComponentHook
---@return XGoldenMinerEntityHook
function XGoldenMinerGame:GetHookEntityByHook(hook)
    for _, hookEntity in ipairs(self.HookEntityList) do
        if hookEntity.Hook == hook then
            return hookEntity
        end
    end
    return false
end

---@param anim XGoldenMinerComponentTimeLineAnim
---@return XGoldenMinerEntityHook
function XGoldenMinerGame:GetHookEntityByAnim(anim)
    for _, hookEntity in ipairs(self.HookEntityList) do
        if hookEntity.Anim == anim then
            return hookEntity
        end
    end
    return false
end

---@param hookStatus number XGoldenMinerConfigs.GAME_HOOK_STATUS
---@return XGoldenMinerEntityStone[]
function XGoldenMinerGame:GetHookGrabEntity(hookStatus, stoneStatus)
    local stoneEntityList = {}
    for _, hookEntity in ipairs(self.HookEntityList) do
        if (not hookStatus or hookEntity.Hook.Status == hookStatus)
                and not XTool.IsTableEmpty(hookEntity.HookGrabbingStoneList) then
            for _, stoneEntity in ipairs(hookEntity.HookGrabbingStoneList) do
                if not stoneStatus or stoneEntity.Status == stoneStatus then
                    stoneEntityList[#stoneEntityList + 1] = stoneEntity
                end
            end
        end
    end
    return stoneEntityList
end

function XGoldenMinerGame:GetHookGrabWeight(stoneStatus)
    local stoneEntityList = self:GetHookGrabEntity(nil, stoneStatus)
    local weight = 0
    for _, stoneEntity in pairs(stoneEntityList) do
        weight = weight + stoneEntity.Stone.CurWeight
        if stoneEntity.CarryStone then
            weight = weight + stoneEntity.CarryStone.Stone.CurWeight
        end
    end
    return weight
end

function XGoldenMinerGame:GetHookGrabScore(stoneStatus)
    local stoneEntityList = self:GetHookGrabEntity(nil, stoneStatus)
    local score = 0
    for _, stoneEntity in pairs(stoneEntityList) do
        score = score + stoneEntity.Stone.CurScore
        if stoneEntity.CarryStone then
            score = score + stoneEntity.CarryStone.Stone.CurScore
        end
        if stoneEntity.QTE then
            score = score + stoneEntity.QTE.AddScore
        end
    end
    return score
end

---@param collider UnityEngine.Collider2D
---@return XGoldenMinerEntityHook
function XGoldenMinerGame:FindHookEntityByCollider(collider)
    if XTool.IsTableEmpty(self.HookEntityList) then
        return false
    end
    for _, entity in ipairs(self.HookEntityList) do
        if not XTool.IsTableEmpty(entity.Hook.ColliderList) then
            for _, hookCollider in ipairs(entity.Hook.ColliderList) do
                if hookCollider == collider then
                    return entity
                end
            end
        end
        if entity.Hook.RopeCollider and entity.Hook.RopeCollider == collider then
            return entity
        end
    end
    return false
end
--endregion

--region System - StoneEntity
function XGoldenMinerGame:InitMap()
    self.StoneEntityList = {}
    local mapStoneList = self._Data:GetMapStoneDataList()
    if XTool.IsTableEmpty(mapStoneList) then
        return
    end
    for _, stoneData in ipairs(mapStoneList) do
        local stoneEntity = self:CreateStoneEntity(stoneData)
        self.StoneEntityList[#self.StoneEntityList + 1] = stoneEntity
    end
    if self.SystemStone then
        self.SystemStone:Init(self)
    end
end

function XGoldenMinerGame:UpdateStone(time)
    if self:IsEnd() then
        return
    end
    if self.SystemStone then
        self.SystemStone:Update(self, time)
    end
    self:CheckIsStoneClear()
end

function XGoldenMinerGame:UpdateStoneMove(time)
    if self:IsEnd() then
        return
    end
    if self.SystemMove then
        self.SystemMove:Update(self, time)
    end
end

---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:ChangeToGold(stoneEntity)
    if stoneEntity.Mouse or stoneEntity.Mussel then
        self:_CarryStoneChangeToGold(stoneEntity)
    else
        self:_StoneChangeToGold(stoneEntity)
    end
end

---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:_StoneChangeToGold(stoneEntity)
    local goldId = XGoldenMinerConfigs.GetGoldIdByWeight(stoneEntity.Stone.Weight, stoneEntity.Data:GetId())
    if not goldId then
        return
    end

    local parent = stoneEntity.Stone.Transform.parent
    local stoneData = XGoldenMinerMapStoneData.New(goldId)

    XUiHelper.Destroy(stoneEntity.Stone.Transform.gameObject)

    stoneEntity.Data = stoneData
    stoneEntity.Stone = self:_CreateStoneComponent(stoneData)
    stoneEntity.Move = self:_CreateMoveComponent(stoneData, stoneEntity.Stone.Transform)
    stoneEntity.CarryStone = self:_CreateCarryStone(stoneEntity, stoneEntity.Data:GetCarryStoneId())
    stoneEntity.Anim = false

    stoneEntity.Stone.Transform:SetParent(parent, false)
    local rectTransform = stoneEntity.Stone.Transform:GetComponent("RectTransform")
    rectTransform.anchorMin = Vector2(0.5, 1)
    rectTransform.anchorMax = Vector2(0.5, 1)
    rectTransform.pivot = Vector2(0.5, 1)
    stoneEntity.Stone.Transform.localPosition = Vector3.zero
    stoneEntity.Stone.Transform.localRotation = CS.UnityEngine.Quaternion.identity
    stoneEntity.Stone.Score = stoneEntity.Data:GetScore()
    stoneEntity.Stone.CurScore = stoneEntity.Stone.Score
    stoneEntity.Mussel = false
    stoneEntity.QTE = false
end

---猫猫点石成金只改携带物
---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:_CarryStoneChangeToGold(stoneEntity)
    -- 没有携带物则道具白用
    if not stoneEntity.CarryStone then
        return
    end
    local goldId = XGoldenMinerConfigs.GetGoldIdByWeight(stoneEntity.CarryStone.Data:GetWeight(), stoneEntity.Data:GetCarryStoneId())
    if not goldId then
        return
    end

    XUiHelper.Destroy(stoneEntity.CarryStone.Stone.Transform.gameObject)
    stoneEntity.CarryStone = nil
    stoneEntity.CarryStone = self:_CreateCarryStone(stoneEntity, goldId)
    
    stoneEntity.Stone.Score = stoneEntity.Data:GetScore()
    stoneEntity.Stone.CurScore = stoneEntity.Stone.Score
    stoneEntity.CarryStone.Stone.Score = stoneEntity.CarryStone.Data:GetScore()
    stoneEntity.CarryStone.Stone.CurScore = stoneEntity.CarryStone.Data:GetScore()
end

---@param stoneData XGoldenMinerMapStoneData
---@return XGoldenMinerEntityStone
function XGoldenMinerGame:CreateStoneEntity(stoneData)
    ---@type XGoldenMinerEntityStone
    local stoneEntity = XGoldenMinerEntityStone.New()
    stoneEntity.Data = stoneData
    stoneEntity.Stone = self:_CreateStoneComponent(stoneData)
    stoneEntity.Move = self:_CreateMoveComponent(stoneData, stoneEntity.Stone.Transform)
    stoneEntity.Mouse = self:_CreateMouseComponent(stoneData, stoneEntity.Stone.Transform)
    stoneEntity.QTE = self:_CreateQTEComponent(stoneData, stoneEntity.Stone.Transform)
    stoneEntity.Mussel = self:_CreateMusselComponent(stoneData, stoneEntity.Stone.Transform)
    stoneEntity.HookDirectionPoint = self:_CreateDirectionPointComponent(stoneData, stoneEntity.Stone.Transform)
    stoneEntity.CarryStone = self:_CreateCarryStone(stoneEntity, stoneEntity.Data:GetCarryStoneId())
    -- 注册抓取物间碰撞
    self:RegisterStoneHitCallBack(stoneEntity)
    self:_RegisterMusselHitCallBack(stoneEntity)
    return stoneEntity
end

---@param stoneEntity XGoldenMinerEntityStone
---@return XGoldenMinerEntityStone
function XGoldenMinerGame:_CreateCarryStone(stoneEntity, carryStoneId)
    if not stoneEntity.Stone or not stoneEntity.Data:IsHaveCarryStone() then
        return false
    end
    if stoneEntity.Mouse then
        stoneEntity.Stone.CarryItemParent = stoneEntity.Mouse.CarryPoint[XGoldenMinerConfigs.GAME_MOUSE_STATE.ALIVE]
    elseif stoneEntity.Mussel and stoneEntity.Mussel.GrabCarry then
        stoneEntity.Stone.CarryItemParent = stoneEntity.Mussel.GrabCarry
    else
        stoneEntity.Stone.CarryItemParent = stoneEntity.Stone.Transform
    end
    if not stoneEntity.Stone.CarryItemParent then
        return false
    end

    ---@type XGoldenMinerEntityStone
    local carryStone = XGoldenMinerEntityStone.New()
    local carryStoneData = XGoldenMinerMapStoneData.New(carryStoneId)
    carryStone.Data = carryStoneData
    carryStone.Stone = XGoldenMinerComponentStone.New()
    carryStone.Stone.Transform = self:_LoadStone(carryStoneData, stoneEntity.Stone.CarryItemParent)
    carryStone.Stone.Collider = XUiHelper.TryGetComponent(carryStone.Stone.Transform, "", "Collider2D")
    -- 携带物不需要碰撞体
    if carryStone.Stone.Collider then
        carryStone.Stone.Collider.enabled = false
    end
    -- 不移动不处理移动方向
    if stoneEntity.Move and stoneEntity.Move.MoveType == XGoldenMinerConfigs.StoneMoveType.None
            or not stoneEntity.Move then
        return carryStone
    end
    -- 携带物要处理方向
    carryStone.Stone.Transform.localScale = Vector3(
            carryStone.Stone.Transform.localScale.x * stoneEntity.Data:GetStartMoveDirection(),
            carryStone.Stone.Transform.localScale.y,
            carryStone.Stone.Transform.localScale.z)

    if carryStoneData:GetType() == XGoldenMinerConfigs.StoneType.Boom then  -- 爆炸物默认碰撞体关闭
        carryStone.Stone.BoomCollider = XUiHelper.TryGetComponent(carryStone.Stone.Transform, "", "CircleCollider2D")
        if carryStone.Stone.BoomCollider then
            carryStone.Stone.BoomCollider.enabled = false
        end
    end
    return carryStone
end

---@param stoneData XGoldenMinerMapStoneData
---@return XGoldenMinerComponentStone
function XGoldenMinerGame:_CreateStoneComponent(stoneData)
    ---@type XGoldenMinerComponentStone
    local stone = XGoldenMinerComponentStone.New()
    stone.Transform = self:_LoadStone(stoneData, self._MapObjRoot)
    if not stone.Transform then
        XLog.Error("抓取物创建失败!请检查Prefab字段!id="..stoneData:GetId())
    end
    stone.Collider = XUiHelper.TryGetComponent(stone.Transform, "", "Collider2D")
    stone.BornDelayTime = stoneData:GetBornDelay()
    stone.AutoDestroyTime = stoneData:GetDestroyTime() > 0 and (stoneData:GetBornDelay() + stoneData:GetDestroyTime()) or 0
    stone.BeDestroyTime = 0
    stone.HideTime = 0
    stone.GoInputHandler = stone.Transform:GetComponent(typeof(CS.XGoInputHandler))
    if XTool.UObjIsNil(stone.GoInputHandler) then
        stone.GoInputHandler = stone.Transform.gameObject:AddComponent(typeof(CS.XGoInputHandler))
    end

    if stoneData:GetType() == XGoldenMinerConfigs.StoneType.Boom then  -- 爆炸物默认碰撞体关闭
        stone.BoomCollider = XUiHelper.TryGetComponent(stone.Transform, "", "CircleCollider2D")
        if stone.BoomCollider then
            stone.BoomCollider.enabled = false
        end
    end
    return stone
end

---@param stoneData XGoldenMinerMapStoneData
---@param transform UnityEngine.Transform
---@return XGoldenMinerComponentQTE
function XGoldenMinerGame:_CreateQTEComponent(stoneData, transform)
    if not stoneData:IsHaveQTE() then
        return false
    end
    ---@type XGoldenMinerComponentQTE
    local qte = XGoldenMinerComponentQTE.New()
    qte.QTEGroupId = stoneData:GetQTEGroupId()
    qte.Time = stoneData:GetQTETime()
    if self.SystemQTE then
        self.SystemQTE:InitQTE(qte, transform)
    end
    return qte
end

---@param stoneData XGoldenMinerMapStoneData
---@param transform UnityEngine.Transform
---@return XGoldenMinerComponentMussel
function XGoldenMinerGame:_CreateMusselComponent(stoneData, transform)
    if not stoneData:IsHaveMussel() then
        return false
    end
    ---@type XGoldenMinerComponentMussel
    local mussel = XGoldenMinerComponentMussel.New()
    mussel.CanHide = true
    mussel.IsGrabbed = stoneData:GetMusselIsGrabbed()
    mussel.InitIsOpen = stoneData:GetMusselInitIsOpen()
    mussel.OpenTime = stoneData:GetMusselOpenTime()
    mussel.HideTime = stoneData:GetMusselHideTime()
    mussel.AnimOpen = XUiHelper.TryGetComponent(transform, "AnimOpen/Open")
    mussel.AnimClose = XUiHelper.TryGetComponent(transform, "AnimClose/Close")
    mussel.OpenCollider = XUiHelper.TryGetComponent(transform, "AnimOpen", "Collider2D")
    mussel.CloseCollider = XUiHelper.TryGetComponent(transform, "AnimClose", "Collider2D")
    mussel.GrabCarry = XUiHelper.TryGetComponent(transform, "UiGoldenMinerBx04/ContentPos")
    if not mussel.GrabCarry then
        mussel.GrabCarry = XUiHelper.TryGetComponent(transform, "ContentPos")
    end
    if mussel.InitIsOpen then
        mussel.Status = XGoldenMinerConfigs.GAME_MUSSEL_STATUS.OPEN
        mussel.CurTime = mussel.OpenTime
    else
        mussel.Status = XGoldenMinerConfigs.GAME_MUSSEL_STATUS.CLOSE
        mussel.CurTime = mussel.HideTime
    end
    if mussel.AnimOpen then
        mussel.AnimOpen.gameObject:SetActiveEx(mussel.Status == XGoldenMinerConfigs.GAME_MUSSEL_STATUS.OPEN)
        mussel.AnimClose.gameObject:SetActiveEx(mussel.Status == XGoldenMinerConfigs.GAME_MUSSEL_STATUS.CLOSE)
    end
    if mussel.OpenCollider then
        mussel.OpenCollider.gameObject:SetActiveEx(mussel.Status == XGoldenMinerConfigs.GAME_MUSSEL_STATUS.OPEN)
        mussel.OpenGoInputHandler = mussel.OpenCollider.transform:GetComponent(typeof(CS.XGoInputHandler))
        if XTool.UObjIsNil(mussel.OpenGoInputHandler) then
            mussel.OpenGoInputHandler = mussel.OpenCollider.gameObject:AddComponent(typeof(CS.XGoInputHandler))
        end
    end
    if mussel.CloseCollider then
        mussel.CloseCollider.gameObject:SetActiveEx(mussel.Status == XGoldenMinerConfigs.GAME_MUSSEL_STATUS.CLOSE)
        mussel.CloseGoInputHandler = mussel.CloseCollider.transform:GetComponent(typeof(CS.XGoInputHandler))
        if XTool.UObjIsNil(mussel.CloseGoInputHandler) then
            mussel.CloseGoInputHandler = mussel.CloseCollider.gameObject:AddComponent(typeof(CS.XGoInputHandler))
        end
    end
    return mussel
end

---@param stoneData XGoldenMinerMapStoneData
---@param transform UnityEngine.Transform
---@return XGoldenMinerComponentMussel
function XGoldenMinerGame:_CreateMouseComponent(stoneData, transform)
    if not (stoneData:GetType() == XGoldenMinerConfigs.StoneType.Mouse) then
        return false
    end

    ---@type XGoldenMinerComponentMouse
    local component = XGoldenMinerComponentMouse.New()
    component.IsBoom = false
    component.StateTrans[XGoldenMinerConfigs.GAME_MOUSE_STATE.ALIVE] = XUiHelper.TryGetComponent(transform, "Run")
    component.StateTrans[XGoldenMinerConfigs.GAME_MOUSE_STATE.GRABBING] = XUiHelper.TryGetComponent(transform, "Grab")
    component.StateTrans[XGoldenMinerConfigs.GAME_MOUSE_STATE.BOOM] = XUiHelper.TryGetComponent(transform, "Bomb")

    component.CarryPoint[XGoldenMinerConfigs.GAME_MOUSE_STATE.ALIVE] = XUiHelper.TryGetComponent(transform, "Run/RunCarryItemParent")
    component.CarryPoint[XGoldenMinerConfigs.GAME_MOUSE_STATE.GRABBING] = XUiHelper.TryGetComponent(transform, "Grab/GrabCarryItemParent")
    return component
end

---@param stoneData XGoldenMinerMapStoneData
---@param transform UnityEngine.Transform
---@return XGoldenMinerComponentDirectionPoint
function XGoldenMinerGame:_CreateDirectionPointComponent(stoneData, transform)
    if not stoneData:IsHaveDirectionPoint() then
        return false
    end
    ---@type XGoldenMinerComponentDirectionPoint
    local directionPoint = XGoldenMinerComponentDirectionPoint.New()
    directionPoint.AngleList = stoneData:GetHookDirectionPointAngleList()
    directionPoint.AngleTimeList = stoneData:GetHookDirectionPointTimeList()
    directionPoint.CurAngleIndex = 1
    directionPoint.CurTime = directionPoint.AngleTimeList[directionPoint.CurAngleIndex]
    directionPoint.AngleTransform = transform
    directionPoint.FillImage = XUiHelper.TryGetComponent(transform, "RImgBg03", "Image")
    return directionPoint
end

---@param stoneData XGoldenMinerMapStoneData
---@param transform UnityEngine.Transform
---@return XGoldenMinerComponentMove
function XGoldenMinerGame:_CreateMoveComponent(stoneData, transform)
    if not transform or XTool.UObjIsNil(transform) then
        return false
    end
    ---@type XGoldenMinerComponentMove
    local move = XGoldenMinerComponentMove.New()
    move.MoveType = stoneData:GetMoveType()
    -- 静止的物体不需要其他参数
    if move.MoveType == XGoldenMinerConfigs.StoneMoveType.None then
        return move
    end
    move.StartDirection = stoneData:GetStartMoveDirection()
    move.CurDirection = stoneData:GetStartMoveDirection()
    move.Speed = stoneData:GetMoveSpeed()
    if move.MoveType == XGoldenMinerConfigs.StoneMoveType.Circle then
        local x =  transform.localPosition.x + stoneData:GetMoveRange() * math.cos(move.StartDirection / 180 * math.pi)
        local y =  transform.localPosition.y + stoneData:GetMoveRange() * math.sin(move.StartDirection / 180 * math.pi)
        move.CircleMovePoint = transform.position
        move.StartPoint = Vector3(x, y, 0)
        transform:Rotate(0, 0, move.CurDirection - 90)
        transform.localPosition = move.StartPoint
    else
        move.StartPoint = transform.localPosition
        local aLimit, bLimit
        if move.MoveType == XGoldenMinerConfigs.StoneMoveType.Horizontal then
            aLimit = transform.localPosition.x
        elseif move.MoveType == XGoldenMinerConfigs.StoneMoveType.Vertical then
            aLimit = transform.localPosition.y
        end
        bLimit = aLimit + move.StartDirection * stoneData:GetMoveRange()
        move.MoveMinLimit = math.min(aLimit, bLimit)
        move.MoveMaxLimit = math.max(aLimit, bLimit)
    end

    -- 定春需要处理方向
    if stoneData:GetType() == XGoldenMinerConfigs.StoneType.Mouse
            and move.MoveType ~= XGoldenMinerConfigs.StoneMoveType.None
            and move.MoveType ~= XGoldenMinerConfigs.StoneMoveType.Circle then
        transform.localScale = Vector3(
                transform.localScale.x * stoneData:GetStartMoveDirection(),
                transform.localScale.y,
                transform.localScale.z)
    end
    return move
end

---@param stoneData XGoldenMinerMapStoneData
---@param objRoot UnityEngine.Transform
---@return UnityEngine.Transform
function XGoldenMinerGame:_LoadStone(stoneData, objRoot)
    local path = stoneData:GetPrefab()
    
    if string.IsNilOrEmpty(path) or not objRoot or not self._RectSize then
        return
    end
    local resource = self._ResourcePool[path]
    if not resource then
        resource = CSXResourceManagerLoad(path)
        self._ResourcePool[path] = resource
    end

    if resource == nil or not resource.Asset then
        XLog.Error(string.format("XGoldenMinerGame:LoadStone加载资源，路径：%s", path))
        return
    end

    local obj = XUiHelper.Instantiate(resource.Asset, objRoot)
    -- 抓取物的携带物不存在index,直接返回
    if not XTool.IsNumberValid(stoneData:GetMapIndex()) then
        obj.transform.localPosition = Vector3.zero
        return obj.transform
    end

    local width = self._RectSize.x
    local height = self._RectSize.y
    local xPosPercent = stoneData:GetXPosPercent() / MILLION_PERCENT
    local yPosPercent = stoneData:GetYPosPercent() / MILLION_PERCENT
    local scale = stoneData:GetScale() / MILLION_PERCENT
    local rotationZ = stoneData:GetRotationZ() / W_PERCENT
    obj.transform.localPosition = Vector3(xPosPercent * width, yPosPercent * height, 0)
    obj.transform.localScale = Vector3(scale, scale, scale)
    obj.transform.localEulerAngles = Vector3(0, 0, rotationZ)
    return obj.transform
end

---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:RegisterStoneHitCallBack(stoneEntity)
    if not stoneEntity or not stoneEntity.Stone.GoInputHandler or XTool.UObjIsNil(stoneEntity.Stone.GoInputHandler) then
        return
    end
    stoneEntity.Stone.GoInputHandler:AddTriggerEnter2DCallback(function(collider)
        self:StoneHit(stoneEntity, collider)
    end)
end

---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:_RegisterMusselHitCallBack(stoneEntity)
    if not stoneEntity or not stoneEntity.Mussel or not stoneEntity.Mussel.OpenGoInputHandler then
        return
    end
    stoneEntity.Mussel.OpenGoInputHandler:AddTriggerEnter2DCallback(function(collider)
        self:StoneHit(stoneEntity, collider)
    end)
    stoneEntity.Mussel.CloseGoInputHandler:AddTriggerEnter2DCallback(function(collider)
        self:StoneHit(stoneEntity, collider)
    end)
end

---@param stoneEntity XGoldenMinerEntityStone
---@param collider UnityEngine.Collider2D
function XGoldenMinerGame:StoneHit(stoneEntity, collider)
    local beHitStoneEntity = self:FindStoneEntityByCollider(collider)
    if self.SystemStone then
        self.SystemStone:OnStoneHit(stoneEntity, beHitStoneEntity)
    end
end

---@param collider UnityEngine.Collider2D
function XGoldenMinerGame:FindStoneEntityByCollider(collider)
    if XTool.IsTableEmpty(self.StoneEntityList) then
        return false
    end
    for _, entity in ipairs(self.StoneEntityList) do
        if entity.Stone.Transform and entity.Stone.Transform == collider.transform then
            return entity
        end
        if entity.Mussel then
            if entity.Mussel.OpenCollider and entity.Mussel.OpenCollider == collider then
                return entity
            end
            if entity.Mussel.CloseCollider and entity.Mussel.CloseCollider == collider then
                return entity
            end
        end
        if entity.CarryStone
                and entity.CarryStone.Stone.Transform
                and entity.CarryStone.Stone.Transform == collider.transform then
            return entity
        end
    end
    return false
end

---@param stoneEntity XGoldenMinerEntityStone
---@param status number XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS
function XGoldenMinerGame:SetStoneEntityStatus(stoneEntity, status)
    self.SystemStone:SetStoneEntityStatus(stoneEntity, status)
end

---@param hookEntity XGoldenMinerEntityHook
---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:SetStoneGrab(hookEntity, stoneEntity)
    hookEntity.HookGrabbingStoneList[#hookEntity.HookGrabbingStoneList + 1] = stoneEntity
    self.SystemHook:HookGrab(self, hookEntity.Hook, stoneEntity)
    self:SetStoneEntityStatus(stoneEntity, XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.GRABBING)
end

---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:SetCarryStoneBoom(stoneEntity)
    if not stoneEntity.CarryStone then
        return
    end
    if stoneEntity.CarryStone.Stone.BoomCollider then
        stoneEntity.CarryStone.Stone.BoomCollider.enabled = true
        XEventManager.DispatchEvent(XEventId.EVENT_GOLDEN_MINER_GAME_PLAY_EFFECT,
                XGoldenMinerConfigs.GAME_EFFECT_TYPE.STONE_BOOM,
                stoneEntity.CarryStone.Stone.Transform,
                stoneEntity.CarryStone.Data:GetCatchEffect())
    end
end

---@param stoneType number XGoldenMinerConfigs.StoneType
---@param stoneStatusType number XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS
---@return XGoldenMinerEntityStone[]
function XGoldenMinerGame:GetStoneEntityList(stoneType, stoneStatusType)
    local result = {}
    for _, stoneEntity in ipairs(self.StoneEntityList) do
        if (not stoneStatusType or stoneEntity.Status == stoneStatusType) and
                (not stoneType or stoneEntity.Data:GetType() == stoneType) then
            result[#result + 1] = stoneEntity
        end
    end
    return result
end
--endregion

--region System - QTE
---@param hookEntity XGoldenMinerEntityHook
---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:QTEStart(hookEntity, stoneEntity)
    if self:IsEnd() or self:IsPause() then
        return
    end
    if self:IsQTE() then
        if self.QTEHookEntity and self.QTEHookEntity ~= hookEntity
                and self.QTEStoneEntity and self.QTEStoneEntity ~= stoneEntity
                and not table.indexof(self.QTECatchHookEntityList, hookEntity)
                and not table.indexof(self.QTECatchStoneEntityList, stoneEntity)
        then
            self.QTECatchHookEntityList[#self.QTECatchHookEntityList + 1] = hookEntity
            self.QTECatchStoneEntityList[#self.QTECatchStoneEntityList + 1] = stoneEntity
        end
        return
    end
    if not self:IsQTE() then
        self._QTECatchStatus = self._Status
    end
    self.QTEHookEntity = hookEntity
    self.QTEStoneEntity = stoneEntity
    self._Status = GAME_STATUS.QTE
end

function XGoldenMinerGame:QTEResume()
    if self:IsEnd() or self:IsPause() then
        return
    end
    if self._QTECatchStatus == GAME_STATUS.NONE then
        return
    end
    self._Status = self._QTECatchStatus
end

function XGoldenMinerGame:UpdateQTE(time)
    if self:IsEnd() then
        return
    end
    if self.SystemQTE then
        self.SystemQTE:Update(self, time)
    end
end

function XGoldenMinerGame:QTEClick()
    if not self:IsQTE() then
        return
    end
    if self.SystemQTE then
        self.SystemQTE:ClickQTE(self)
    end
end

function XGoldenMinerGame:QTECrab()
    if not self:IsQTE() then
        return
    end
    
    local QTE = self.QTEStoneEntity.QTE
    local qteId = XGoldenMinerConfigs.GetQTELevelGroupByCount(QTE.QTEGroupId, QTE.CurClickCount)
    local params = XGoldenMinerConfigs.GetQTELevelGroupParams(qteId)
    local type = XGoldenMinerConfigs.GetQTELevelGroupType(qteId)
    if type == XGoldenMinerConfigs.QTEGroupType.Score then
        QTE.AddScore = params[1]
    elseif type == XGoldenMinerConfigs.QTEGroupType.Item then
        QTE.AddItemId = params[1]
    elseif type == XGoldenMinerConfigs.QTEGroupType.Buff then
        QTE.AddBuff = params[1]
    elseif type == XGoldenMinerConfigs.QTEGroupType.ScoreAndBuff then
        QTE.AddScore = params[1]
        QTE.AddBuff = params[2]
    elseif type == XGoldenMinerConfigs.QTEGroupType.ScoreAndItem then
        QTE.AddScore = params[1]
        QTE.AddItemId = params[2]
    elseif type == XGoldenMinerConfigs.QTEGroupType.BuffAndItem then
        QTE.AddBuff = params[1]
        QTE.AddItemId = params[2]
    elseif type == XGoldenMinerConfigs.QTEGroupType.All then
        QTE.AddScore = params[1]
        QTE.AddBuff = params[2]
        QTE.AddItemId = params[3]
    end
    
    if self.QTEHookEntity then
        -- 状态不对过滤
        if self.QTEHookEntity.Hook.Type == XGoldenMinerConfigs.FalculaType.Magnetic
                or self.QTEHookEntity.Hook.Type == XGoldenMinerConfigs.FalculaType.StorePressMagnetic then
            self:SetStoneGrab(self.QTEHookEntity, self.QTEStoneEntity)
        else
            self:HookGrab(self.QTEHookEntity, self.QTEStoneEntity)
        end
    end
    self.QTEHookEntity = false
    self.QTEStoneEntity = false
    self:QTEResume()
    self:QTECheck()
end

function XGoldenMinerGame:QTECheck()
    if XTool.IsTableEmpty(self.QTECatchHookEntityList) then
        return
    end
    local hookEntity = self.QTECatchHookEntityList[1]
    local stoneEntity = self.QTECatchStoneEntityList[1]
    local newHookList = {}
    local newStoneList = {}
    for i = 2, #self.QTECatchHookEntityList do
        newHookList[#newHookList + 1] = self.QTECatchHookEntityList[i]
        newStoneList[#newStoneList + 1] = self.QTECatchStoneEntityList[i]
    end
    self.QTECatchHookEntityList = newHookList
    self.QTECatchStoneEntityList = newStoneList
    self:QTEStart(hookEntity, stoneEntity)
end
--endregion

--region System - TimeLineAnim
function XGoldenMinerGame:InitTimeLineAnim()
    for _, entity in ipairs(self.HookEntityList) do
        entity.Anim = self:_CreateAnimComponent(entity.Hook.Transform)
    end
    for _, entity in ipairs(self.StoneEntityList) do
        if entity.Data:GetType() == XGoldenMinerConfigs.StoneType.Mouse then
            entity.Anim = self:_CreateAnimComponent(entity.Stone.Transform)
        end
    end
end

function XGoldenMinerGame:UpdateTimeLineAnim(time)
    if self:IsEnd() then
        return
    end
    if self.SystemTimeLimeAnim then
        self.SystemTimeLimeAnim:Update(self, time)
    end
end

---@param transform UnityEngine.Transform
---@return XGoldenMinerComponentTimeLineAnim
function XGoldenMinerGame:_CreateAnimComponent(transform)
    if not transform or XTool.UObjIsNil(transform) then
        return false
    end
    ---@type XGoldenMinerComponentTimeLineAnim
    local anim = XGoldenMinerComponentTimeLineAnim.New()
    anim.AnimRoot = XUiHelper.TryGetComponent(transform, "Animation")
    anim.CurAnim = XGoldenMinerConfigs.GAME_ANIM.NONE
    anim.FinishCallBack = false
    anim.BePlayAnim = XGoldenMinerConfigs.GAME_ANIM.NONE
    anim.BeFinishCallBack = false
    return anim
end
--endregion

--region System - Buff&Item
function XGoldenMinerGame:InitBuff()
    if self.SystemBuff then
        self.SystemBuff:Init(self)
    end
end

function XGoldenMinerGame:UpdateBuff(time)
    if self:IsEnd() then
        return
    end
    if self.SystemBuff then
        self.SystemBuff:Update(self, time)
    end
end

---@return table<number, XGoldenMinerComponentBuff[]>
function XGoldenMinerGame:GetBuffDir()
    return self.BuffContainer.BuffTypeDir
end

function XGoldenMinerGame:CheckHasBuff(buffType)
    if self.SystemBuff then
        return self.SystemBuff:CheckHasBuff(self.BuffContainer, buffType)
    end
    return false
end

function XGoldenMinerGame:CheckHasBuffByBuffId(buffId)
    if self.SystemBuff then
        return self.SystemBuff:CheckHasBuffByBuffId(self.BuffContainer, XGoldenMinerConfigs.GetBuffType(buffId), buffId)
    end
    return false
end

function XGoldenMinerGame:CheckItemCanUse(itemId)
    if not self:IsPlay() and not self:IsTimeStop() then
        return
    end
    local buffId = XGoldenMinerConfigs.GetItemBuffId(itemId)
    local type = XGoldenMinerConfigs.GetBuffType(buffId)
    if type == XGoldenMinerConfigs.BuffType.GoldenMinerBoom
            or type == XGoldenMinerConfigs.BuffType.GoldenMinerStoneChangeGold
    then
        local result = false
        for _, hookEntity in ipairs(self.HookEntityList) do
            if not XTool.IsTableEmpty(hookEntity.HookGrabbingStoneList) then
                for _, stoneEntity in ipairs(hookEntity.HookGrabbingStoneList) do
                    if stoneEntity.Status == XGoldenMinerConfigs.GAME_GRAB_OBJ_STATUS.GRABBING then
                        result = true
                    end
                end
            end
        end
        return result
    elseif type == XGoldenMinerConfigs.BuffType.GoldenMinerTypeBoom then
        for _, stoneEntity in ipairs(self.StoneEntityList) do
            if stoneEntity.Data:GetType() == XGoldenMinerConfigs.GetBuffParams(buffId)[1] then
                return true
            end
        end
        return false
    end
    return true
end

function XGoldenMinerGame:UseItemToAddBuff(itemId)
    local characterBuffList = XGoldenMinerConfigs.GetCharacterBuffIds(self._Data:GetCurCharacterId())
    local itemBuffId = XGoldenMinerConfigs.GetItemBuffId(itemId)
    for _, buffId in pairs(characterBuffList) do
        -- 使用道具时停
        if XGoldenMinerConfigs.GetBuffType(buffId) == XGoldenMinerConfigs.BuffType.GoldenMinerUseItemStopTime then
            self:AddBuff(buffId)
        end
        -- 使用道具加时
        if XGoldenMinerConfigs.GetBuffType(buffId) == XGoldenMinerConfigs.BuffType.GoldenMinerUseItemAddTime then
            self:AddBuff(buffId)
        end
    end
    -- 使用炸弹道具加分
    if XGoldenMinerConfigs.GetBuffType(itemBuffId) == XGoldenMinerConfigs.BuffType.GoldenMinerBoom then
        self:CheckAndTriggerBuff(XGoldenMinerConfigs.BuffType.GoldenMinerBoomGetScore)
    end
    self:AddBuff(XGoldenMinerConfigs.GetItemBuffId(itemId))
end

function XGoldenMinerGame:AddBuff(buffId)
    if self.SystemBuff then
        self.SystemBuff:AddBuffById(self.BuffContainer, buffId)
    end
end

function XGoldenMinerGame:CheckAndTriggerBuff(buffType)
    if not self.SystemBuff then
        return false
    end
    if not self:CheckHasBuff(buffType) then
        return false
    end
    local result = false
    for _, buff in ipairs(self.BuffContainer.BuffTypeDir[buffType]) do
        if self.SystemBuff:CheckBuffIsAlive(buff) then
            if buff.TimeType == XGoldenMinerConfigs.BuffTimeType.Count then
                local isTrigger = self.SystemBuff:TriggerCountBuff(buff)
                result = result or isTrigger
            elseif buff.TimeType == XGoldenMinerConfigs.BuffTimeType.Global then
                self.SystemBuff:TriggerGlobalRoleSkillBuff(self, buff)
            end
        end
    end
    return result
end

---触发回收时次数型Buff
function XGoldenMinerGame:TriggerCountRevokeEndCountBuff()
    -- 按次数生效的回收速度buff
    self:CheckAndTriggerBuff(XGoldenMinerConfigs.BuffType.GoldenMinerShortenSpeed)
    -- 防爆次数触发
    self:CheckAndTriggerBuff(XGoldenMinerConfigs.BuffType.GoldenMinerNotActiveBoom)
end

---触发抓到炸弹时Buff
function XGoldenMinerGame:TriggerCountGrabBoomCountBuff()
    return self:CheckAndTriggerBuff(XGoldenMinerConfigs.BuffType.GoldenMinerNotActiveBoom)
end

---@param stoneType number
function XGoldenMinerGame:TriggerStoneHitBuff(stoneType)
    if stoneType == XGoldenMinerConfigs.StoneType.Boom then
        self:CheckAndTriggerBuff(XGoldenMinerConfigs.BuffType.GoldenMinerBoomGetScore)
    end
end

---@param stoneEntity XGoldenMinerEntityStone
function XGoldenMinerGame:TriggerStoneGrabBuff(stoneEntity)
    if stoneEntity.Data:GetType() == XGoldenMinerConfigs.StoneType.Mouse then
        self:CheckAndTriggerBuff(XGoldenMinerConfigs.BuffType.GoldenMinerMouseGetItem)
    elseif stoneEntity.Data:GetType() == XGoldenMinerConfigs.StoneType.QTE then
        self:CheckAndTriggerBuff(XGoldenMinerConfigs.BuffType.GoldenMinerQTEGetScore)
    end
end
--endregion

--region EventListener
function XGoldenMinerGame:AddEventListener()
    XEventManager.AddEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_PAUSE, self.Pause, self)
    XEventManager.AddEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_RESUME, self.Resume, self)
    XEventManager.AddEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_QTE_START, self.QTEStart, self)
    XEventManager.AddEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_QTE_END, self.QTECrab, self)
    XEventManager.AddEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_HOOK_HIT, self.TriggerStoneHitBuff, self)
end

function XGoldenMinerGame:RemoveEventListener()
    XEventManager.RemoveEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_PAUSE, self.Pause, self)
    XEventManager.RemoveEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_RESUME, self.Resume, self)
    XEventManager.RemoveEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_QTE_START, self.QTEStart, self)
    XEventManager.RemoveEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_QTE_END, self.QTECrab, self)
    XEventManager.RemoveEventListener(XEventId.EVENT_GOLDEN_MINER_GAME_HOOK_HIT, self.TriggerStoneHitBuff, self)
end
--endregion

return XGoldenMinerGame