---@type table<string, UClass>
---@private
UE.CachedClasses = {};

--- 组件位置
UE.ComponentPath = {
	Camera = "/Script/Engine.CameraComponent",
	SpringArm = "/Script/Engine.SpringArmComponent",
}

---@param InInfo PlayerAccountInfo
---@return PlayerAccountInfo
function UE.HandleAccountInfo(InInfo)
	return {
		UID = InInfo.UID,
		PlayerName = InInfo.PlayerName,
		TeamID = InInfo.TeamID,
		Gender = InInfo.Gender,
		PlatformGender = InInfo.PlatformGender,
		PlayerLevel = InInfo.PlayerLevel,
		SegmentLevel = InInfo.SegmentLevel,
		IconURL = InInfo.IconURL,
	};
end

---@return table
function UE.InitArchiveData()
	return {
		GameTimes = 0,
	}
end

---@param InClass UClass<AActor>
---@param InTable table<int32, AActor> 获得的
---@param InFunc fun(InIndex:int32, InActor:AActor): bool
---@return table<int32, AActor>
function UE.FindActorsByClass(InClass, InTable, InFunc)
	if InTable == nil then InTable = {}; end
	local AllActors = {};
	GameplayStatics.GetAllActorsOfClass(UGCGameSystem.GameState, InClass, AllActors);
	for i, v in pairs(AllActors) do if InFunc == nil or InFunc(i, v) then table.insert(InTable, v); end end
	return InTable;
end

---@param InTable table<int32, AActor>
---@param InTag FName
---@param InFunc fun(InActor: AActor): bool
---@return table<int32, AActor>
function UE.FindActorsByTag(InTag, InTable, InFunc)
	if table.isEmpty(InTable) then InTable = {}; end
	local AllActors = {};
	GameplayStatics.GetAllActorsWithTag(UGCGameSystem.GameState, InTag, AllActors);
	for i, v in pairs(AllActors) do if InFunc == nil or InFunc(v) then table.insert(InTable, v); end end
	return InTable;
end

---@param InTag FName
---@param InFunc fun(InActor: AActor): bool
---@return table<int32, AActor>
function UE.FindActorByTag(InTag, InFunc)
	local AllActors = {};
	GameplayStatics.GetAllActorsWithTag(UGCGameSystem.GameState, InTag, AllActors);
	for i, v in pairs(AllActors) do if InFunc == nil or InFunc(v) then return v; end end
	return nil;
end

---@param InClass UClass<AActor>
---@param InFunc fun(InIndex:int32, InActor:AActor): bool
---@return AActor
function UE.FindActorByClass(InClass, InFunc)
	local Table = {};
	UE.FindActorsByClass(InClass, Table, InFunc);
	if table.isEmpty(Table) then return nil; end
	return Table[1];
end

---@type table<UClass, AActor>
UE.GlobalCachedActor = {};

---@param InClass UClass
---@return nil | AActor
function UE.FindOrCreateActorByClass(InClass, bDestroyOther)
	print(string.format('[UE.FindOrCreateActorByClass] 开始执行, ClassName = %s', UE.GetName(InClass)));
    if InClass == nil then return nil; end
	
	local CachedActor = UE.GlobalCachedActor[InClass];
	if CachedActor ~= nil and UE.IsValid(CachedActor) then return CachedActor; end
	local Actors = {}
	UE.FindActorsByClass(InClass, Actors);
	local Actor = nil;
	for i, v in pairs(Actors) do
	    Actor = v;
		if Actor ~= v and bDestroyOther then v:K2_DestroyActor(); end
    end
	if Actor ~= nil then
		UE.GlobalCachedActor[InClass] = Actor;
		return Actor;
	end
	return UE.CreateActor(InClass);
end

---@param ClassPath string 类路径
---@return UClass | nil
function UE.CachedLoadClass(ClassPath)
    if UE.CachedClasses[ClassPath] == nil then UE.CachedClasses[ClassPath] = UE.LoadClass(ClassPath); end
    if UE.CachedClasses[ClassPath] == nil then
        print(string.format('[UE.CachedLoadClass] Error Cant Load Class By Path: %s', ClassPath));
	    return nil;
    end
    return UE.CachedClasses[ClassPath];
end

function UE.CreateActor(InClass, InCount, InOuter)
	if InOuter == nil then InOuter = UGCGameSystem.GameState; end
	if InCount == nil then InCount = 1 end
	local Actors = {};
	for i = 1, InCount do table.insert(Actors, UE.SpawnActor(InClass, InOuter)) end
	if InCount == 1 then return Actors[1]; end
	return Actors;
end

---@param InClass UClass
---@param Loc FVector
---@param Rot FRotator
---@param Scale FVector
function UE.SpawnActor(InClass, InOuter, Loc, Rot, Scale)
	Loc = Loc == nil and VectorHelper.MakeVector1(0);
	Rot = Rot == nil and VectorHelper.MakeRotator(VectorHelper.MakeVector1(0));
	Scale = Scale == nil and VectorHelper.MakeVector1(1);
	if InOuter == nil then InOuter = GameState; end
	return ScriptGameplayStatics.SpawnActor(InOuter, InClass, Loc, Rot, Scale);
end

--- 玩家重生
---@param InPlayerKey PlayerKey
---@param InTime float
function UE.RespawnPlayer(InPlayerKey, InTime)
	if InTime == nil or InTime <= 0 then
		local Pawn = UGCGameSystem.GetPlayerPawnByPlayerKey(InPlayerKey);
		if Pawn then Pawn:K2_DestroyActor(); end
		UGCGameSystem.RespawnPlayer(InPlayerKey);
		return;
	end
	UGCEventSystem.SetTimer(GameState, function()
		local Pawn = UGCGameSystem.GetPlayerPawnByPlayerKey(InPlayerKey);
		if Pawn then Pawn:K2_DestroyActor(); end
		UGCGameSystem.RespawnPlayer(InPlayerKey);
	end, InTime);
end

--- 获取当前时间
function UE.GetCurrentTime() return KismetSystemLibrary.GetGameTimeInSeconds(UGCGameSystem.GameState); end

---@param InPlayerKey PlayerKey
---@return PlayerAccountInfo
function UE.GetAccountInfo(InPlayerKey) return GameState.PlayerDatas.AccountInfo[InPlayerKey]; end

--- 移动玩家到某个地方
---@param InPawn UGCPlayerPawn_C
---@param Location FVector
---@param Rotation FRotator
function UE.MovePlayerToLocation(InPawn, Location, Rotation)
	if InPawn == nil then return end
	InPawn:bShouldDumpCallstackWhenMovingfast_Tofalse()
	InPawn:SetClientLocationOrRotation(Location, Rotation, true, Rotation ~= nil, false);
	InPawn:bShouldDumpCallstackWhenMovingfast_ToTrue()
end

--- 激活对应的 Camera
---@param InPawn UGCPlayerPawn_C
---@param InCamera UCameraComponent
---@param InArm USpringArmComponent
function UE.ActiveCamera(InPawn, InCamera, InArm)
	if InPawn == nil then return end
	UE.ForeachComponent(InPawn, UE.ComponentPath.Camera, function(c) c:Deactivate() end)
	UE.ForeachComponent(InPawn, UE.ComponentPath.SpringArm, function(c) c:Deactivate() end)
	InCamera:Activate();
	InArm:Activate();
	table.func(InPawn, "SetCurrentCamera", InCamera, InArm);
end

--- 遍历 Actor 上面的所有组件
---@param InActor AActor
---@param InComponent UActorComponent
---@param cb fun(c: UActorComponent)
function UE.ForeachComponent(InActor, InComponent, cb)
	local Path = UE.ComponentPath[InComponent] == nil and InComponent or UE.ComponentPath[InComponent];
	for i, v in pairs(InActor:GetComponentsByClass(LoadClass(Path))) do cb(v); end
end

---清空地图上的 Wrapper
function UE.ClearWrappers(bWeapon, bPart, bBullet, bEquipment, bSkin, bSupplies)
	local AllActors = {};
	local Func = function(b) if b == nil then return true end return b; end
	bWeapon = Func(bWeapon);
	bPart = Func(bPart);
	bBullet = Func(bBullet);
	bEquipment = Func(bEquipment);
	bSkin = Func(bSkin);
	bSupplies = Func(bSupplies);
	UE.FindActorsByClass(GameState:GetWrapperClass(), AllActors, function(InIndex, InActor)
		if InActor.DefineID == nil then return true; end
		local ItemId = InActor.DefineID.TypeSpecificID;
		if ItemId == nil or (not InActor.DefineID.bValidItem) then return true; end
		UGCLogSystem.Log("[UE.ClearWrappers] ItemId = %s", tostring(ItemId));
		local Type = GetCustomItemType(ItemId);
		if (bWeapon and Type == ECustomItemType.Weapon) or
				(bPart and Type == ECustomItemType.Part) or
				(bBullet and Type == ECustomItemType.Bullet) or
				(bEquipment and Type == ECustomItemType.Equipment) or
				(bSkin and Type == ECustomItemType.Skin) or
				(bSupplies and Type == ECustomItemType.Supplies) then
			InActor:K2_DestroyActor()
		end
	end);
end

--- 组件朝向玩家
---@param InComponent USceneComponent
---@param InActor AActor
---@param Lock string
function UE.ComponentTowardActor(InComponent, InActor, Lock)
	if InComponent == nil then return; end
	local Rot = KismetMathLibrary.Conv_VectorToRotator(VectorHelper.Sub(InActor:K2_GetActorLocation(), InComponent:GetOwner():K2_GetActorLocation()));
	if Lock ~= nil then
		if Lock == 'Z' or Lock == 'Yaw' then
			Rot = { Roll = Rot.Roll, Pitch = Rot.Pitch, Yaw = 0 };
		elseif Lock == 'Y' or Lock == 'Pitch' then
			Rot = { Roll = Rot.Roll, Pitch = 0, Yaw = Rot.Yaw };
		elseif Lock == 'X' or Lock == 'Roll' then
			Rot = { Roll = 0, Pitch = Rot.Pitch, Yaw = Rot.Yaw };
		end
	end
	InComponent:K2_SetWorldRotation(Rot);
end

--- 获取服务器时间
function UE.GetServerTime()
	if UGCGameSystem.GameState then return UGCGameSystem.GameState:GetServerTime(); end
	return nil
end

---@param InTable table<int32|string, AActor>
---@param InFunc fun(InActor:AActor):bool
function UE.DestroyTable(InTable, InFunc)
	if table.isEmpty(InTable) then return; end
	for i, v in pairs(InTable) do if InFunc == nil or InFunc(v) then v:K2_DestroyActor(); end end
	InTable = {};
end

function UE.IsPlayerPawn(InPawn) return UE.IsA(InPawn, ObjectPath.UGCPlayerPawn) end

function UE.ReturnToLobby()
	NetUtil.SendPkg("giveup_enter_game");
	LobbySystem.ReturnToLobby();
end

function UE.LoadClass1(Path, cb)
	local Class UE.LoadClass(Path);
	if cb ~= nil then cb(Class); end
	return Class
end

UE.AsyncCachedItems = {};

---@param Path string
---@param cb fun(TargetClass: UClass)
function UE.AsyncLoadClass(Path, cb)
	if cb == nil then return end
	if UE.AsyncCachedItems[Path] then
		cb(UE.AsyncCachedItems[Path]);
		return;
	end
	CommonUtils:AsyncLoadClass(UGCGameSystem.GameState, Path, function(TargetClass)
		if TargetClass and UE.IsValid(TargetClass) then cb(TargetClass); end
	end)
end

---@param Path string
---@param cb fun(TargetClass: UClass)
function UE.AsyncLoadClass_Cached(Path, cb)
	if UE.AsyncCachedItems[Path] ~= nil then
		if cb then cb(UE.AsyncCachedItems[Path]); end
		return;
	end
	if cb == nil then return end
	CommonUtils:AsyncLoadClass(UGCGameSystem.GameState, Path, function(TargetClass)
		if TargetClass and UE.IsValid(TargetClass) then
			UE.AsyncCachedItems[Path] = TargetClass;
			if cb then cb(UE.AsyncCachedItems[Path]); end
		end
	end)
end

---@param Path string
---@param cb fun(TargetObject: UObject)
function UE.AsyncLoadObject(Path, cb)
	if cb == nil then return end
	if UE.AsyncCachedItems[Path] then
		cb(UE.AsyncCachedItems[Path]);
		return;
	end
	CommonUtils:AsyncLoadObject(UGCGameSystem.GameState, Path, function(TargetObject)
		if TargetObject and UE.IsValid(TargetObject) then cb(TargetObject); end
	end)
end

---@param Path string
---@param cb fun(TargetObject: UObject)
function UE.AsyncLoadObject_Cached(Path, cb)
	if UE.AsyncCachedItems[Path] ~= nil then
		if cb then cb(UE.AsyncCachedItems[Path]); end
		return;
	end
	CommonUtils:AsyncLoadObject(UGCGameSystem.GameState, Path, function(TargetObject)
		if TargetObject and UE.IsValid(TargetObject) then
			UE.AsyncCachedItems[Path] = TargetObject;
			if cb then cb(TargetObject); end
		end
	end)
end