---@class UGCGameState_C:BP_UGCGameState_C
--Edit Below--
---@type UGCGameState_C
UGCGameSystem.UGCRequire('Script.Global.Global')
UGCGameSystem.UGCRequire('Script.Common.ue_enum_custom')
local UGCGameState = {
    WaitPlayerJoinTime = 0;
    GameStateType = CustomEnum.EGameState.Waiting;
    GameTime = 0;                                   --  游戏倒计时时间

    PlayerPersonalInfos = {};                       --  玩家信息{PlayerKey = {UID, PlayerKey, TeamID, IsOffline, PlayerName, Gender, IconURL, AchievementScore, IsSelectTeam}, ...}
    PlayerScoreDatas = {};                          --  玩家得分信息{[PlayerKey] = {Kill = int32, Dead = int32, Score = float, TechnicalScore = float}...}
    PlayerRankDatas = {};                           --  玩家排行信息{[TeamID] = {{PlayerKey = uint}, ... }

    PlayerJoinNum = 0;                              --  玩家加入的数量作为个人TeamID
    PlayerSaveWeaponSelect = {};                    --  玩家存档中的武器选择 {[PlayerKey] = {WeaponID = int32, PropID = int32}} 
    PlayerArchiveInfos = {};                         --  玩家存档{[PlayerKey] = ArchiveData}

    ControllerInitializationEndedPlayer = {};       --  控制器初始化完成的玩家{PlayerKey}      
    PlayerIsFirstTimePlayingCache = {};             --  客户端需执行首次登录函数的玩家{PlayerKey}

    PlayerWeaponGradient = {};                      --  玩家的武器梯度 {PlayerKey = {WeaponID = uint, ..}}
    PlayerGradientGrade = {};                       --  玩家的武器梯度等级 {PlayerKey = Grade}
    PlayerDefaultMeleeWeapon = {};                  --  玩家选择的默认近战武器{PlayerKey = WeaponID}


    MapSelectionResult = nil;                       --  地图选择结果
    MapSelectionFinalResult = nil;                  --  地图选择最终结果（包括随机之后的结果）
    PlayerSelectMapList = {};                       --  玩家选择的地图{PlayerKey = Enum.SelectMap}
    SelectMapInfo = {};                             --  选择地图的数量{Enum.SelectMap = uint}

    TeamScore = {};                                 --  队伍得分信息 { TeamID = Score, ... }
    PlayerIsAlive = {};                             --  玩家是否存活

    ---test
    DoOnceAddJoinPlayer = false;
}; 

function UGCGameState:GetReplicatedProperties()
    return
    "GameTime",
    "PlayerPersonalInfos",
    "WaitPlayerJoinTime",
    "GameStateType",
    "PlayerSaveWeaponSelect",
    "PlayerScoreDatas",

    "PlayerWeaponGradient",
    "PlayerGradientGrade",
    "PlayerDefaultMeleeWeapon",
    "DoOnceAddJoinPlayer",
    "PlayerRankDatas",
    "TeamScore",

    "MapSelectionResult",
    "SelectMapInfo",
    "MapSelectionFinalResult",
    "PlayerIsAlive"

end


function UGCGameState:ReceiveBeginPlay()
    --屏蔽死亡盒子
    self.IsShowDeadBox = false;
    self:AddBind()
    GlobalInit.Init()
    -- 开启滑铲State部分
    self.bIsOpenShovelingAbility = true
    UGCSendRPCSystem.InitUGCSendRPCSystem(self, "UGCSendRPCSystemFunc")
    if UGCGameSystem.IsServer() then
    else
        UGCLogSystem.Log("[UGCGameState_ReceiveBeginPlay]")
        UGCLogSystem.SetEnableLog(false)
    end
end

function UGCGameState:ReceiveTick(DeltaTime)
    --UGCLogSystem.Log("[UGCGameState_ReceiveTick] ModeID:%s", tostring(UGCMultiMode.GetModeID()))
end


function UGCGameState:ReceiveEndPlay()
    self:RemoveBind()
end


function UGCGameState:AddBind()
    if self:HasAuthority() then
        UGCEventSystem.AddListener(EventEnum.PlayerLogin, self.PlayerLogin, self)
        UGCEventSystem.AddListener(EventEnum.PlayerExit, self.PlayerExit, self)
        self.ClearPickUpHandle = UGCEventSystem.SetTimerLoop(self, self.ClearPickUpItem, 1)
    else
    end
end

function UGCGameState:RemoveBind()
    if self:HasAuthority() then
        UGCEventSystem.RemoveListener(EventEnum.PlayerLogin, self.PlayerLogin, self)
        UGCEventSystem.RemoveListener(EventEnum.PlayerExit, self.PlayerExit, self)
        if self.ClearPickUpHandle then
            UGCEventSystem.StopTimer(self.ClearPickUpHandle)
            self.ClearPickUpHandle = nil
        end
    else
    end
end

function UGCGameState:ClearPickUpItem()
    UGCSystemLibrary.ClearPickUpActor({108001, 108002, 108003, 108004})
end

function UGCGameState:PlayerLogin(PlayerPawn, PlayerKey)
    self:UpdatePlayerTeam(PlayerKey)
    self:GetUserInfo(PlayerKey)
    self:UpdatePlayerJoin()
    self:UpdateAllPlayerScoreDatas()
    self:GetPlayerArchiveInfos(PlayerKey)
    self:CheckFirstTimePlaying(PlayerKey)
    self:InitPlayerGradient(PlayerKey)
    self:UpdatePlayerRankDatas(PlayerKey, self:GetPlayerTeamIDByPlayerKey(PlayerKey))
end

function UGCGameState:PlayerExit(PlayerPawn, PlayerKey)
    self:UpdatePlayerJoin()
    self:UpdateAllPlayerScoreDatas()
    if GlobalConfigs.GameSetting.EnablePlayerJoin then
        self:InspectPlayerRankDatas()
    end
end

--- 根据游戏队伍模式更新玩家队伍
---@param PlayerKey uint
function UGCGameState:UpdatePlayerTeam(PlayerKey)
    if GlobalConfigs.GameModeSetting.TeamModeType == CustomEnum.ETeamMode.PersonalWarfare then
        local NewTeamID = self:GetNewTeamID()
        UGCTeamSystem.ChangePlayerTeamID(PlayerKey, NewTeamID)
        UGCLogSystem.Log("[UGCGameState_UpdatePlayerTeam] NewTeamID:%s", tostring(NewTeamID))
    end
end

--- 玩家登录获取玩家数据
---@param PlayerKey uint
function UGCGameState:GetUserInfo(PlayerKey)
    if self.PlayerPersonalInfos[PlayerKey] then return self.PlayerPersonalInfos[PlayerKey] end

    local UserInfo = UGCPlayerStateSystem.GetPlayerAccountInfo(PlayerKey)
    if UserInfo then
        --- UID，PlayerName，TeamID，Gender，PlatformGender，PlayerLevel，SegmentLevel，IconURL
        local UserInfoCpy = UserInfo:Copy()
        UGCLogSystem.Log("[UGCGameState_GetUserInfo] PlayerName:%s", UserInfoCpy.PlayerName)

        local CustomUserInfo = {
            UID             =   UserInfoCpy.UID,
            PlayerKey       =   PlayerKey,
            TeamID          =   UserInfoCpy.TeamID,
            IsOffline       =   false,
            PlayerName      =   UserInfoCpy.PlayerName,
            Gender          =   UserInfoCpy.PlatformGender,
            IconURL         =   UserInfoCpy.IconURL,
            IsSelectTeam    =   false,
        }
        self.PlayerPersonalInfos[PlayerKey] = CustomUserInfo

        
        UGCLogSystem.LogTree("[UGCGameState_GetUserInfo] CustomUserInfo:", CustomUserInfo)
        return CustomUserInfo
    else
        UGCLogSystem.LogError("[UGCGameState_GetUserInfo] UserInfo Error PlayerKey:%s", tostring(PlayerKey))
    end

end

--- 对玩家在队伍中进行排序
--function UGCGameState:SortPlayerRankDatas()
--    if #self.PlayerRankDatas < 1 then return end
--    for i, v in pairs(self.PlayerRankDatas) do
--        table.sort(self.PlayerRankDatas[i], function(a, b)
--            local aScore = self.PlayerScoreDatas[a].Score + self.PlayerScoreDatas[a].TechnicalScore * GlobalConfigs.GameSetting.TechnicalScoreProportion
--            local bScore = self.PlayerScoreDatas[b].Score + self.PlayerScoreDatas[b].TechnicalScore * GlobalConfigs.GameSetting.TechnicalScoreProportion
--            return aScore > bScore
--        end)
--    end
--end


--- 对玩家在队伍中进行排序
function UGCGameState:SortPlayerRankDatas()
    if #self.PlayerRankDatas < 1 then return end
    for i, v in pairs(self.PlayerRankDatas) do
        for Index = #v, 1, -1 do
            if self.PlayerScoreDatas[v[Index]] == nil then
                self.PlayerRankDatas[i][Index] = nil
            end
        end
    end
    local LocalGetScore = function(PlayerKey)
        if self.PlayerScoreDatas[PlayerKey] == nil or self.PlayerScoreDatas[PlayerKey].Score == nil then
            return 0
        else
            return self.PlayerScoreDatas[PlayerKey].Score
        end
    end
    local LocalGetTechnicalScore = function(PlayerKey)
        if self.PlayerScoreDatas[PlayerKey] == nil or self.PlayerScoreDatas[PlayerKey].TechnicalScore == nil then
            return 0
        else
            return self.PlayerScoreDatas[PlayerKey].TechnicalScore
        end
    end
    for i, v in pairs(self.PlayerRankDatas) do
        table.sort(self.PlayerRankDatas[i], function(a, b)
            local aScore = LocalGetScore(a) + LocalGetTechnicalScore(a) * GlobalConfigs.GameSetting.TechnicalScoreProportion
            local bScore = LocalGetScore(b) + LocalGetTechnicalScore(b) * GlobalConfigs.GameSetting.TechnicalScoreProportion
            return aScore > bScore
        end)
    end
end




--- 更新玩家排序信息
function UGCGameState:UpdatePlayerRankDatas(PlayerKey, TeamID)
    if self.PlayerRankDatas[TeamID] == nil then
        self.PlayerRankDatas[TeamID] = {}
    end
    if not table.hasValue(self.PlayerRankDatas[TeamID], PlayerKey) then
        self.PlayerRankDatas[TeamID][#self.PlayerRankDatas[TeamID] + 1] = PlayerKey
    end
    if GlobalConfigs.GameSetting.EnablePlayerJoin then
        self:InspectPlayerRankDatas()
    end
    --self:SortPlayerRankDatas()
end

--- 检验RankDatas
function UGCGameState:InspectPlayerRankDatas()
    for TempTeamID, PlayerKeys in pairs(self.PlayerRankDatas) do
        for i = #PlayerKeys, 1, -1 do
            if UGCGameSystem.GetPlayerControllerByPlayerKey(PlayerKeys[i]) == nil then
                self.PlayerRankDatas[TempTeamID][i] = nil
            end
        end
        --for i, TempPlayerKey in pairs(PlayerKeys) do
        --    if UGCGameSystem.GetPlayerControllerByPlayerKey(TempPlayerKey) == nil then
        --        self.PlayerRankDatas[TempTeamID][TempPlayerKey] = nil
        --    end
        --end
    end
end

function UGCGameState:GetPlayerRankByPlayerKey(PlayerKey)
    local TeamID = self:GetPlayerTeamIDByPlayerKey(PlayerKey)
    if self.PlayerRankDatas[TeamID] == nil  then return 0 end
    return table.FindKey(self.PlayerRankDatas[TeamID], PlayerKey)
end

function UGCGameState:OnRep_PlayerRankDatas()
    UGCEventSystem.SendEvent(EventEnum.UpdatePlayerRank)
end

function UGCGameState:GetPlayerRank()
    return self.PlayerRankDatas
end

--- 获取存档
function UGCGameState:GetPlayerArchiveInfos(PlayerKey)
    self.PlayerArchiveInfos[PlayerKey] = UGCPlayerStateSystem.GetPlayerArchiveData(self.PlayerPersonalInfos[PlayerKey].UID)
    if self.PlayerArchiveInfos[PlayerKey] then
        self.PlayerSaveWeaponSelect[PlayerKey] = self.PlayerArchiveInfos[PlayerKey].PlayerSaveWeaponSelect
    end
end


--- 获取存档信息
---@param PlayerKey
function UGCGameState:GetPlayerArchiveInfosFromArchiveType(PlayerKey, ArchiveType)
    if self.PlayerArchiveInfos[PlayerKey] == nil then
        if self.PlayerPersonalInfos[PlayerKey] then
            self.PlayerArchiveInfos[PlayerKey] = UGCPlayerStateSystem.GetPlayerArchiveData(self.PlayerPersonalInfos[PlayerKey].UID)
        else
            UGCLogSystem.LogError("[UGCGameState_GetPlayerArchiveInfosFromArchiveType] PlayerPersonalInfos[%s] is nil", tostring(PlayerKey))
        end
    end

    if ArchiveType == nil then
        return self.PlayerArchiveInfos[PlayerKey]
    elseif type(ArchiveType) == "table" then
        local Res = nil
        for i, v in pairs(ArchiveType) do
            if Res == nil then
                Res = self.PlayerArchiveInfos[PlayerKey][v]
            else
                Res = Res[v]
            end
            if Res == nil then
                return nil
            end
        end
        return Res
    else
        return self.PlayerArchiveInfos[PlayerKey][ArchiveType]
    end
end

--- 保存武器选择存档
function UGCGameState:SavePlayerWeaponSelectArchiveData(PlayerKey)    
    if self.PlayerArchiveInfos[PlayerKey] == nil then
        self.PlayerArchiveInfos[PlayerKey] = {}
    end
    self.PlayerArchiveInfos[PlayerKey].PlayerSaveWeaponSelect = self.PlayerSaveWeaponSelect[PlayerKey]
    UGCPlayerStateSystem.SavePlayerArchiveData(self.PlayerPersonalInfos[PlayerKey].UID, self.PlayerArchiveInfos[PlayerKey])
end

function UGCGameState:OnRep_PlayerSaveWeaponSelect()
    UGCEventSystem.SendEvent(EventEnum.PlayerSaveWeaponChange)
end

--- 判断玩家是否为第一次进入游戏
function UGCGameState:CheckFirstTimePlaying(PlayerKey)
    if self.PlayerArchiveInfos[PlayerKey] == nil then
        self.PlayerArchiveInfos[PlayerKey] = {}
    end
    if self.PlayerArchiveInfos[PlayerKey].PlayedTimes == nil then
        self.PlayerArchiveInfos[PlayerKey].PlayedTimes = 1
        self:PlayerIsFirstTimePlaying(PlayerKey)
    else
        self.PlayerArchiveInfos[PlayerKey].PlayedTimes = 1 + self.PlayerArchiveInfos[PlayerKey].PlayedTimes
    end
    UGCPlayerStateSystem.SavePlayerArchiveData(self.PlayerPersonalInfos[PlayerKey].UID, self.PlayerArchiveInfos[PlayerKey])
end

function UGCGameState:PlayerIsFirstTimePlaying(PlayerKey)
    UGCEventSystem.SendEvent(EventEnum.PlayerFirstTimePlaying, PlayerKey)
    if table.hasValue(self.ControllerInitializationEndedPlayer, PlayerKey) then
        local TargetController = UGCGameSystem.GetPlayerControllerByPlayerKey(PlayerKey)
        if UE.IsValid(TargetController) then
            UnrealNetwork.CallUnrealRPC(TargetController, TargetController, "Client_PlayerIsFirstTimePlaying")
        else
            UGCLogSystem.LogError("[UGCGameState_PlayerIsFirstTimePlaying] TargetController is nil")
        end
    else
        self.PlayerIsFirstTimePlayingCache[#self.PlayerIsFirstTimePlayingCache + 1] = PlayerKey
    end
    UGCLogSystem.Log("[UGCGameState_PlayerIsFirstTimePlaying]")
end


-- 玩家已选择队伍
function UGCGameState:PlayerHasSelectedTeam(PlayerKey)
    if self.PlayerPersonalInfos[PlayerKey] == nil or self.PlayerPersonalInfos[PlayerKey].IsSelectTeam == false then
        return false
    end
    return true
end



---@param PlayerKey int32
---@param AddScore float
---@return Succeed bool
function UGCGameState:AddScore(PlayerKey, AddScore)
    local TargetPlayerState = UGCGameSystem.GetPlayerStateByPlayerKey(PlayerKey)
    if UE.IsValid(TargetPlayerState) then
        TargetPlayerState:SetScore(TargetPlayerState:GetScore() + AddScore) 
        self.PlayerScoreDatas[PlayerKey].Score = TargetPlayerState:GetScore()
        --DOREPONCE(self, "PlayerScoreDatas")
        self:SortPlayerRankDatas()
        self:AddTeamScore(self:GetPlayerTeamIDByPlayerKey(PlayerKey), AddScore)
        return true
    end
    return false
end

function UGCGameState:GetPlayerScore(PlayerKey)
    if self.PlayerScoreDatas[PlayerKey].Score then
        return self.PlayerScoreDatas[PlayerKey].Score
    else
        return 0
    end
end

function UGCGameState:GetTeamScore(TeamID)
    if UGCGameSystem.GameState:GetSpecialModeType() == MapConfig.ESpecialModeType.ArmsRace then
        local PlayerKey = self.PlayerRankDatas[TeamID][1]
        if PlayerKey then
            return self:GetPlayerScore(PlayerKey)
        else
            return 0
        end
    end
    return (self.TeamScore[TeamID] and self.TeamScore[TeamID] or 0)
end

function UGCGameState:ResetTeamScore()
    self.TeamScore = {}
end

function UGCGameState:AddTeamScore(TeamID, Score)
    self.TeamScore[TeamID] = self:GetTeamScore(TeamID) + Score
end

---@param PlayerKey int32
---@param AddTechnicalScore float
---@return Succeed bool
function UGCGameState:AddTechnicalScore(PlayerKey, AddTechnicalScore)
    local TargetPlayerState = UGCGameSystem.GetPlayerStateByPlayerKey(PlayerKey)
    if UE.IsValid(TargetPlayerState) then
        TargetPlayerState:SetTechnicalScore(TargetPlayerState:GetTechnicalScore() + AddTechnicalScore)
        self.PlayerScoreDatas[PlayerKey].TechnicalScore = TargetPlayerState:GetTechnicalScore()
        self:SortPlayerRankDatas()
        return true
    end
    return false
end



-- 更新返回所有玩家得分
function UGCGameState:UpdateAllPlayerScoreDatas()
    local AllPlayerState = UGCGameSystem.GetAllPlayerState(false)
    local ResScoreDatas = {}
    if AllPlayerState then
        for _, PlayerState in pairs(AllPlayerState) do
            if UE.IsValid(PlayerState) and self.PlayerPersonalInfos[PlayerState.PlayerKey] and self.PlayerPersonalInfos[PlayerState.PlayerKey].IsOffline == false  then
                if GlobalConfigs.GameSetting.EnablePlayerJoin then
                    ResScoreDatas[PlayerState.PlayerKey] = table.DeepCopy(PlayerState.ScoreData)
                else
                    self.PlayerScoreDatas[PlayerState.PlayerKey] = table.DeepCopy(PlayerState.ScoreData)
                end
            end
        end
    end
    if GlobalConfigs.GameSetting.EnablePlayerJoin then
        self.PlayerScoreDatas = ResScoreDatas
    end
    self:SortPlayerRankDatas()

    return self.PlayerScoreDatas
end

--- 获取在线人数
function UGCGameState:GetNumberOfOnlineUsers()
    return table.getCount(self.PlayerScoreDatas)
end

function UGCGameState:OnRep_PlayerScoreDatas()
    if self:HasAuthority() then return end
    UGCEventSystem.SendEvent(EventEnum.UpdatePlayerScoreData)
end

function UGCGameState:OnRep_PlayerPersonalInfos()
    if self:HasAuthority() then return end
    UGCEventSystem.SendEvent(EventEnum.UpdatePlayerScoreData)
    UGCLogSystem.LogTree("[UGCGameState_OnRep_PlayerPersonalInfos]", self.PlayerPersonalInfos)
end

function UGCGameState:GetPlayerScoreData()
    return self.PlayerScoreDatas
end

function UGCGameState:GetGameStateType()
    return self.GameStateType
end

function UGCGameState:SetGameStateType(NewGameStateType)
    if not self:HasAuthority() then return end
    if self.GameStateType ~= NewGameStateType then
        self.GameStateType = NewGameStateType
        UGCEventSystem.SendEvent(EventEnum.GameStateChange, self.GameStateType)
    end
end

function UGCGameState:OnRep_GameStateType()
    if self:HasAuthority() then return end
    UGCEventSystem.SendEvent(EventEnum.GameStateChange, self.GameStateType)
end

function UGCGameState:GameWillBeginNotify()
    UnrealNetwork.CallUnrealRPC_Multicast(self, "MulticastRPC_GameWillBeginNotify")
end

function UGCGameState:MulticastRPC_GameWillBeginNotify()
    UGCEventSystem.SendEvent(EventEnum.GameWillBegin)
end

function UGCGameState:GameFinish() self:SetGameStateType(CustomEnum.EGameState.End) end

-- 更新申请玩家加入
function UGCGameState:UpdatePlayerJoin()
    if not GlobalConfigs.GameSetting.EnablePlayerJoin then
        return
    end
    if self.GameStateType == CustomEnum.EGameState.End or self.GameStateType == CustomEnum.EGameState.InsufficientNumberOfPeople then
        return
    end
    local NeedPlayerNum = GlobalConfigs.GameModeSetting.TeamNeedPlayerNum - #UGCGameSystem.GetAllPlayerState()
    UGCGameSystem.StopPlayerJoin()
    if NeedPlayerNum > 0 then
        UGCGameSystem.OpenPlayerJoin()
        UGCGameSystem.ApplyPlayerJoin(1, 1)
        UGCLogSystem.Log("[UGCGameState_UpdatePlayerJoin] NeedPlayerNum: %d", NeedPlayerNum)
    end
end


function UGCGameState:GetNewTeamID()
    -- body
    self.PlayerJoinNum = self.PlayerJoinNum + 1
    return self.PlayerJoinNum
end



function UGCGameState:Client_SaveSelectWeaponCallBack(SelectSucceed)
    if self:HasAuthority() then return end
    UGCEventSystem.SendEvent(EventEnum.SaveSelectWeaponCallBack, SelectSucceed)
end


function UGCGameState:GetPlayerNameByPlayerKey(PlayerKey)
    if self.PlayerPersonalInfos[PlayerKey] then
        return self.PlayerPersonalInfos[PlayerKey].PlayerName
    else
        return ""
    end
end

function UGCGameState:GetPlayerTeamIDByPlayerKey(PlayerKey)
    if self.PlayerPersonalInfos[PlayerKey] then
        return self.PlayerPersonalInfos[PlayerKey].TeamID
    else
        return -1
    end
end

function UGCGameState:GetHeadIconByPlayerKey(PlayerKey)
    if self.PlayerPersonalInfos[PlayerKey] then
        return self.PlayerPersonalInfos[PlayerKey].IconURL
    else
        return ""
    end
end

function UGCGameState:GetScoreDataByPlayerKey(PlayerKey)
    return self.PlayerScoreDatas[PlayerKey]
end



-- 控制器初始化完成
function UGCGameState:Server_ControllerInitFinish(PlayerKey)
    self.ControllerInitializationEndedPlayer[#self.ControllerInitializationEndedPlayer + 1] = PlayerKey
    UGCLogSystem.Log("[UGCGameState_Server_ControllerInitFinish]")
    -- 首次登录
    if table.hasValue(self.PlayerIsFirstTimePlayingCache, PlayerKey) then
        -- self.PlayerIsFirstTimePlayingCache[PlayerKey] = nil
        table.removeValue(self.PlayerIsFirstTimePlayingCache, PlayerKey, true)
        local TargetController = UGCGameSystem.GetPlayerControllerByPlayerKey(PlayerKey)
        if UE.IsValid(TargetController) then
            UnrealNetwork.CallUnrealRPC(TargetController, TargetController, "Client_PlayerIsFirstTimePlaying")
        else
            UGCLogSystem.LogError("[UGCGameState_Server_ControllerInitFinish] TargetController is nil")
        end
    end
end


------------------------------------------------ GameState WeaponGradient ------------------------------------------------



--- 初始化玩家武器梯度
function UGCGameState:InitPlayerGradient(PlayerKey)
    self.PlayerWeaponGradient[PlayerKey] = WeaponGradientManager.GetPlayerGradient(PlayerKey)
    UGCLogSystem.LogTree("[UGCGameState_InitPlayerGradient] " .. PlayerKey .. " PlayerWeaponGradient:", self.PlayerWeaponGradient[PlayerKey] )
    DOREPONCE(self, "PlayerWeaponGradient")
    self:SetPlayerWeaponGrade(PlayerKey, 1, false)
end

function UGCGameState:OnRep_PlayerWeaponGradient()
    UGCEventSystem.SendEvent(EventEnum.PlayerGradientGradeChange)
end

function UGCGameState:GetPlayerWeaponGradientByPlayerKey(PlayerKey)
    return self.PlayerWeaponGradient[PlayerKey]
end

--- 获取玩家梯度等级
function UGCGameState:GetPlayerWeaponGrade(PlayerKey)
    return (self.PlayerGradientGrade[PlayerKey] and self.PlayerGradientGrade[PlayerKey] or 1)
end

--- 设置玩家梯度等级
---@param PlayerKey uint
---@param NewGrade uint 新的玩家等级
---@param bUpdateWeapon bool 是否刷新玩家武器
function UGCGameState:SetPlayerWeaponGrade(PlayerKey, NewGrade, bUpdateWeapon)
    self.PlayerGradientGrade[PlayerKey] = NewGrade
    DOREPONCE(self, "PlayerGradientGrade")
    if bUpdateWeapon then
        local PlayerPawn = UGCGameSystem.GetPlayerPawnByPlayerKey(PlayerKey)
        local DefaultWeaponID = self:GetPlayerDefaultMeleeWeaponByPlayerKey(PlayerKey)
        WeaponGradientManager.UpdatePlayerGradientWeaponMatching(PlayerKey, NewGrade, DefaultWeaponID)
        if self.PlayerWeaponGradient[PlayerKey][NewGrade] < 0 then
            if UGCBackPackSystem.GetItemCount(PlayerPawn, DefaultWeaponID) <= 0 then
                UGCBackPackSystem.AddItem(PlayerPawn, DefaultWeaponID, 1)
            end
            UGCWeaponManagerSystem.SwitchWeaponBySlot(PlayerPawn, ESurviveWeaponPropSlot.SWPS_MeleeWeapon, false)
            UGCSendRPCSystem.RPCEvent(PlayerKey, EventEnum.AddTip, TipConfig.TipType.UseMeleeToKill)
        else
            UGCEventSystem.SetTimer(UGCGameSystem.GameState,
                function()
                    PlayerPawn = UGCGameSystem.GetPlayerPawnByPlayerKey(PlayerKey)
                    if UE.IsValid(PlayerPawn) then
                        if UGCWeaponManagerSystem.GetWeaponBySlot(PlayerPawn, ESurviveWeaponPropSlot.SWPS_MainShootWeapon1) then
                            UGCWeaponManagerSystem.SwitchWeaponBySlot(PlayerPawn, ESurviveWeaponPropSlot.SWPS_MainShootWeapon1, false)
                        else
                            UGCWeaponManagerSystem.SwitchWeaponBySlot(PlayerPawn, ESurviveWeaponPropSlot.SWPS_MainShootWeapon2, false)
                            UGCLogSystem.LogError("[UGCGameState_SetPlayerWeaponGrade] 插槽位错误")
                        end
                    end
                end,
                0.5
            )
        end
    end
end

--- 根据玩家等级刷新玩家武器
function UGCGameState:RefreshPlayerWeapons(PlayerKey)
    local Grade = self:GetPlayerWeaponGrade(PlayerKey)
    WeaponGradientManager.UpdatePlayerGradientWeaponMatching(PlayerKey, Grade, self:GetPlayerDefaultMeleeWeaponByPlayerKey(PlayerKey))
    UGCLogSystem.LogTree("[UGCGameState_RefreshPlayerWeapons]", self.PlayerWeaponGradient)
    if self.PlayerWeaponGradient[PlayerKey][Grade] < 0 then
        local PlayerPawn = UGCGameSystem.GetPlayerPawnByPlayerKey(PlayerKey)
        UGCWeaponManagerSystem.SwitchWeaponBySlot(PlayerPawn, ESurviveWeaponPropSlot.SWPS_MeleeWeapon, true)
    end
end

function UGCGameState:GetPlayerNextWeaponID(PlayerKey)
    if self.PlayerWeaponGradient[PlayerKey] then
        return self.PlayerWeaponGradient[PlayerKey][self:GetPlayerWeaponGrade(PlayerKey) + 1]
    end
    return nil
end

--- 重置所有玩家的玩家等级，用于游戏开始阶段
function UGCGameState:ResetAllPlayerGrade()
    for PlayerKey, v in pairs(self.PlayerPersonalInfos) do
        self:SetPlayerWeaponGrade(PlayerKey, 1, true)
    end
end

--- 玩家增加等级
function UGCGameState:PlayerAddWeaponGrade(PlayerKey, AddGrade)
    local WeaponGradient = WeaponGradientManager.GetPlayerGradient(PlayerKey)
    local PlayerLastGrade = self:GetPlayerWeaponGrade(PlayerKey)
    if PlayerLastGrade == #WeaponGradient then
        self.PlayerWeaponGradient[PlayerKey] = WeaponGradientManager.UpdatePlayerNextGradient(PlayerKey)
        DOREPONCE(self, "PlayerWeaponGradient")
        self:SetPlayerWeaponGrade(PlayerKey, 1, true)
        self:AddScore(PlayerKey, GlobalConfigs.GameSetting.FullGradientAddScore)
        UGCLogSystem.LogTree("[UGCGameState_PlayerAddWeaponGrade] " .. PlayerKey .. " PlayerWeaponGradient:", self.PlayerWeaponGradient[PlayerKey])
        UGCSendRPCSystem.RPCEvent(nil, EventEnum.AddTip, TipConfig.TipType.PlayerCompleteGradient, PlayerKey)
    else
        self:SetPlayerWeaponGrade(PlayerKey, math.clamp(AddGrade + PlayerLastGrade, 1, #WeaponGradient), true)
    end
end


--- 获取玩家选择的默认近战武器
function UGCGameState:GetPlayerDefaultMeleeWeaponByPlayerKey(PlayerKey)
    return self.PlayerDefaultMeleeWeapon[PlayerKey] and self.PlayerDefaultMeleeWeapon[PlayerKey] or GlobalConfigs.GameSetting.DefaultMeleeWeapon
end

function UGCGameState:OnRep_PlayerGradientGrade()
    UGCEventSystem.SendEvent(EventEnum.PlayerGradientGradeChange)
end

---------------------------------------------- GameState WeaponGradient End ----------------------------------------------


--------------------------------------------- SelectMap ---------------------------------------------


function UGCGameState:SetMapSelectionResult(NewMapType)
    self.MapSelectionResult = NewMapType
    if self.MapSelectionResult == MapConfig.MapType.Random then
        self.MapSelectionFinalResult = table.Rand(self:GetEnableMapExcludeRandom())
    else
        self.MapSelectionFinalResult = self.MapSelectionResult
    end
    DOREPONCE(self, "MapSelectionFinalResult")
    DOREPONCE(self, "MapSelectionResult")
end

--- 获取当前地图玩法类型
function UGCGameState:GetSpecialModeType()
    if self.MapSelectionFinalResult then
        return MapConfig.MapInfo[self.MapSelectionFinalResult].SpecialModeType
    end
end

--- 获取当前已选择好的地图Type
---@return MapSelectionResult MapConfig.MapType 若未选择则返回nil
function UGCGameState:GetMapSelectionResult(bMustObtain)
    if bMustObtain and self.MapSelectionResult == nil then
        local MapTypes = self:GetMaxSameVotesMap()
        self:SetMapSelectionResult(table.Rand(MapTypes))
    end
    return self.MapSelectionResult
end

function UGCGameState:GetPlayerSelectMapList()
    return self.PlayerSelectMapList
end

function UGCGameState:GetMaxSameVotesMap()
    local MaxType = self:GetMaxAndSecondMapType()
    local Res = {}
    for i, v in pairs(self.SelectMapInfo) do
        if v == self.SelectMapInfo[MaxType] and MapConfig.MapEnable[i] then
            Res[#Res + 1] = i
        end
    end
    return Res
end

function UGCGameState:GetEnableMapExcludeRandom()
    local Res = {}
    for i, v in pairs(MapConfig.MapEnable) do
        if v and (i ~= MapConfig.MapType.Random) then
            Res[#Res + 1] = i
        end
    end
    return Res
end

function UGCGameState:GetMapSelectionFinalResult()
    return self.MapSelectionFinalResult
end

---@param MapType MapConfig.MapType
function UGCGameState:PlayerSelectMap(PlayerKey, MapType)
    UGCLogSystem.Log("[UGCGameState_PlayerSelectMap] Begin")
    if self.PlayerSelectMapList[PlayerKey] == nil and table.hasValue(MapConfig.MapType, MapType)  then
        self.PlayerSelectMapList[PlayerKey] = MapType
        if #self.SelectMapInfo == 0 then
            self:InitSelectMapInfo()
        end
        self.SelectMapInfo[MapType] = self.SelectMapInfo[MapType] + 1
        DOREPONCE(self, "SelectMapInfo")
        local MaxSelectMap, SecondSelectMap = self:GetMaxAndSecondMapType()
        local SelectMapNum = self:GetSelectMapNum()
        local MaxSelectMapNum = self.SelectMapInfo[MaxSelectMap]
        local SecondSelectMapNum = (SecondSelectMap and self.SelectMapInfo[SecondSelectMap] or 0)
        if (MaxSelectMapNum - SecondSelectMapNum) > (GlobalConfigs.GameModeSetting.MaxPlayerNum - SelectMapNum)
                or (SelectMapNum == GlobalConfigs.GameModeSetting.MaxPlayerNum)
        then
            -- self:SetMapSelectionResult(MaxSelectMap)
            local MapTypes = self:GetMaxSameVotesMap()
            self:SetMapSelectionResult(table.Rand(MapTypes))
        end
        UGCSendRPCSystem.RPCEvent(PlayerKey, EventEnum.SelectMapCallBack, true, MapType)
        UGCLogSystem.Log("[UGCGameState_PlayerSelectMap] Finish")
        UGCLogSystem.LogTree("[UGCGameState_PlayerSelectMap] ", self.SelectMapInfo)
    else
        UGCSendRPCSystem.RPCEvent(PlayerKey, EventEnum.SelectMapCallBack, false, MapType)
    end
end


function UGCGameState:PlayerOverlapSelectMap(PlayerKey, MapType)
    UGCLogSystem.Log("[UGCGameState_PlayerOverlapSelectMap] Begin")
    if self.PlayerSelectMapList[PlayerKey] ~= MapType and table.hasValue(MapConfig.MapType, MapType) then
        self.PlayerSelectMapList[PlayerKey] = MapType
        self:UpdateSelectMapInfo()
        DOREPONCE(self, "SelectMapInfo")

        UGCSendRPCSystem.RPCEvent(PlayerKey, EventEnum.SelectMapCallBack, true, MapType)
        UGCLogSystem.Log("[UGCGameState_PlayerOverlapSelectMap] Finish")
        UGCLogSystem.LogTree("[UGCGameState_PlayerOverlapSelectMapp] ", self.SelectMapInfo)
    else
        UGCSendRPCSystem.RPCEvent(PlayerKey, EventEnum.SelectMapCallBack, false, MapType)
    end
end


function UGCGameState:InitSelectMapInfo()
    if #self.SelectMapInfo == 0 then
        self:ResetSelectMapInfo()
    end
end

function UGCGameState:ResetSelectMapInfo()
    for i, v in pairs(MapConfig.MapType) do
        self.SelectMapInfo[v] = 0
    end
end

function UGCGameState:UpdateSelectMapInfo()
    self:ResetSelectMapInfo()
    for PlayerKey, MapType in pairs(self.PlayerSelectMapList) do
        self.SelectMapInfo[MapType] = self.SelectMapInfo[MapType] + 1
    end
end

function UGCGameState:GetSelectMapNumFromMapType(SelectMapType)
    return (self.SelectMapInfo[SelectMapType] and self.SelectMapInfo[SelectMapType] or 0)
end

function UGCGameState:GetSelectMapNum()
    local Sum = 0
    for i, v in pairs(self.SelectMapInfo) do
        Sum = Sum + v
    end
    return Sum
end

function UGCGameState:GetMaxAndSecondMapType()
    local AllSelectType = {}
    if #self.SelectMapInfo == 0 then
        self:InitSelectMapInfo()
    end
    for i, v in pairs(self.SelectMapInfo) do
        AllSelectType[#AllSelectType + 1] = {MapType = i, Num = v}
    end
    table.sort(AllSelectType, function(a, b) return a.Num > b.Num end)
    UGCLogSystem.LogTree("[UGCGameState_GetMaxAndSecondMapType] AllSelectType", AllSelectType)
    return AllSelectType[1].MapType, AllSelectType[2].MapType
end

function UGCGameState:OnRep_MapSelectionFinalResult()
    self:LoadNowMiniMap()
    local SceneItemGuide = WidgetManager:GetPanel(WidgetConfig.EUIType.SceneItemGuide)
    if SceneItemGuide and self.MapSelectionFinalResult then
        SceneItemGuide:UpdateMechanismDesc(self.MapSelectionFinalResult)
        WidgetManager:ShowPanel(WidgetConfig.EUIType.SceneItemGuide, false)
    end
    UGCEventSystem.SendEvent(EventEnum.UpdateMapSelectionFinalResult, self.MapSelectionFinalResult)
end

function UGCGameState:LoadNowMiniMap()
    UGCLogSystem.Log("[UGCGameState_LoadNowMiniMap]")
    if self:HasAuthority() or self.MapSelectionFinalResult == nil then
        UGCLogSystem.Log("[UGCGameState_LoadNowMiniMap] self.MapSelectionFinalResult is nil")
        return
    end
    local MiniMapInfo = MapConfig.MapInfo[self.MapSelectionFinalResult].MiniMapInfo
    UGCLogSystem.LogTree("[UGCGameState_LoadNowMiniMap]", MiniMapInfo)
    UGCWidgetManagerSystem.ChangeMap(MiniMapInfo.MapPath, MiniMapInfo.MapCentre, MiniMapInfo.MapSize, MiniMapInfo.MapScale)
    UGCLogSystem.Log("[UGCGameState_LoadNowMiniMap] Finish")
end


function UGCGameState:PlayerSelectDefaultWeapon(PlayerKey, WeaponID)
    if table.hasValue(WeaponGradientTable.DefaultWeapon, WeaponID) then
        self.PlayerDefaultMeleeWeapon[PlayerKey] = WeaponID
        UGCSendRPCSystem.RPCEvent(PlayerKey, EventEnum.SelectDefaultWeaponCallBack, true, WeaponID)
    else
        UGCLogSystem.LogError("[UGCGameState_PlayerSelectDefaultWeapon] PlayerKey:%s, 默认武器表内没有武器：%s", tostring(PlayerKey), tostring(WeaponID))
        UGCSendRPCSystem.RPCEvent(PlayerKey, EventEnum.SelectDefaultWeaponCallBack, false, WeaponID)
    end
end


------------------------------------------- SelectMap End -------------------------------------------


function UGCGameState:GetGameTime()
    return self.GameTime
end

function UGCGameState:SetGameTime(NewTime)
    if UGCGameSystem.IsServer() then
        self.GameTime = NewTime
    else
        UGCLogSystem.LogError("[UGCGameState_SetGameTime] 客户端无法设置游戏时间")
    end
end

function UGCGameState:SetPlayerIsAlive(PlayerKey, Pawn)
    if Pawn then
        self.PlayerIsAlive[PlayerKey] = Pawn
    else
        self.PlayerIsAlive[PlayerKey] = nil
    end
end

function UGCGameState:OnRep_PlayerIsAlive()
    UGCEventSystem.SendEvent(EventEnum.PlayerIsAliveIsChange)
end

function UGCGameState:GetPlayerIsAlive(PlayerKey)
    if self.PlayerIsAlive[PlayerKey] then
        return true
    end
    return false
end

function UGCGameState:GetAlivePawn(PlayerKey)
    return self.PlayerIsAlive[PlayerKey]
end





------------------------------------------------ GameState Abstract RPC ------------------------------------------------
function UGCGameState:UGCSendRPCSystemFunc(...)
    UGCSendRPCSystem.RPCFunc(...)
end
---------------------------------------------- GameState Abstract RPC End ----------------------------------------------



function UGCGameState:GetAvailableServerRPCs()
    return  

    "MulticastRPC_SpawnParticleAttachPlayer",

    "UGCSendRPCSystemFunc",

    "Server_ControllerInitFinish",
    "Server_SaveButtonSetting",
    "Server_GetButtonSetting"
end
return UGCGameState;