using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Wizard;

namespace Cute;

public class ResourcesManager : MonoBehaviour, IManager
{
	public enum AssetLoadPathType
	{
		Master,
		MasterEtc,
		CharaMaster,
		Tutorial,
		StoryTutorial,
		StoryParam,
		StoryParamDiff,
		StoryText,
		StoryMovieSubtitles,
		StoryCharacter,
		StoryBackground,
		StoryEndingStill,
		StorySubChapterBtnTexture,
		StoryChapterHeader,
		StorySelectWorldPanel,
		HandCard,
		HandCardSpecular,
		CardFrame,
		CardFrameClassIcon,
		CardDeco,
		SleeveTexture,
		SleeveTextureMask,
		SleeveTextureBasePath,
		SleeveTextureAORefSpec,
		SleeveTextureNormalMap,
		SleeveMaterial,
		SleeveMesh,
		SleeveSpecular,
		CardFrameMesh,
		CardFrameMaterial,
		CardFrameMaterialPlus,
		CardFrameTextureCommon,
		FoilTextures,
		UnitCardMaterial,
		UnitCardTextures,
		SpellCardMaterial,
		SpellCardTextures,
		Effect2D,
		Effect2DMaterials,
		Effect3D,
		Effect3DAnim,
		Effect3DMat,
		Emblem_S,
		Emblem_M,
		Degree_S,
		Degree_M,
		DegreeMaterial_S,
		DegreeMaterial_M,
		DegreeMask,
		RankIcon_S,
		RankIcon_L,
		Country_S,
		Country_M,
		Font,
		DeckListTexture,
		DeckEditBGTexture,
		ClassCharaSpine,
		ClassCharaBase,
		ClassCharaBaseWin,
		ClassCharaBaseLose,
		ClassCharaEvolve,
		ClassCharaEvolveWin,
		ClassCharaEvolveLose,
		ClassCharaHeader,
		ClassCharaSkinThumbnail,
		ClassCharaWideThumbnail,
		ClassCharaButton,
		ClassCharaIconLevel,
		ClassCharaEncampment,
		ClassCharaMesh,
		ClassCharaMaterial,
		ClassCharaMaterialMain,
		ClassCharaTexture,
		ClassCharaFrameTexture,
		ClassCharaProfile,
		ClassCharaStory,
		ClassChara3D,
		AreaSelectTexture,
		GachaTexture,
		ShopCardPack,
		ShopBuildDeckThumbnail,
		ShopBuildDeck,
		ShopSleeve,
		ShopClassSkin,
		ShopItem,
		BattleTexture,
		BattleLangTexture,
		Field3D,
		Background,
		CardMenu,
		BossRushSpecialCard,
		FirstTips,
		Arena,
		Item,
		Lottery,
		UiOtherTexture,
		UilangOtherTexture,
		UiStory,
		UiStorySectionSummary,
		PackBox,
		UnitHeader,
		OtherHeader,
		UiDownLoad,
		UiDownLoadInfo,
		SpecialCrystal,
		GrandPrixSpecialAtlas,
		QuestAtlas,
		Stamp,
		Uilang3DField,
		BattlePass,
		BattleStage,
		Bingo,
		PracticePuzzleThumbnail,
		NeutralVote,
		NeutralVoteThumbnail_S,
		NeutralVoteThumbnail_M,
		LeaderVote,
		LeaderVoteThumbnail_S,
		UISpine,
		FlowChart,
		MyPageBackGround,
		MyPageCharacter,
		MyPageCharacterMask,
		MyPageBackGroundIcon,
		MyPageBackGroundRandomSelectIcon,
		Competition,
		FreeCardPack,
		SpecialTitle
	}

	private enum ProgressDebugType
	{
		Progress_NONE,
		Progress_DOWNLOAD,
		Progress_LOAD
	}

	public enum BackgroundDownloadState
	{
		None,
		Init,
		Download,
		StopRequest
	}

	public enum StopResult
	{
		Paused,
		Stopped,
		Finished
	}

	public List<string> Card3DAssetPathList = new List<string>();

	public List<string> Card2DAssetPathList = new List<string>();

	public List<string> CardListAssetPathList = new List<string>();

	public List<string> SleeveListAssetPathList = new List<string>();

	public List<string> BattleListAssetPathList = new List<string>();

	private bool downloadSemaphore;

	private AssetRequestContext downloadRequestContext = new AssetRequestContext(null, new Utility.LeanSemaphore(0), new AssetErrorState());

	private bool loadSemaphore;

	private AssetRequestContext loadRequestContext = new AssetRequestContext(null, new Utility.LeanSemaphore(0), new AssetErrorState());

	private bool useAssetBundle = true;

	public static int fixedParallelTasks;

	private int _preferredParallelLoadTasks = -1;

	private int _preferredParallelDownloadTasks = -1;

	private List<string> downloadList;

	public BackgroundDownloadState BgDownloadState;

	private bool _stopForMovie;

	public static float TextureScaleRatio
	{
		get
		{
			if (QualityManager.GetAssetQualityLevel() == QualityManager.AssetQualityLevel.Level_1)
			{
				return 2f;
			}
			return 1f;
		}
	}

	public static float AtlasValueRatio
	{
		get
		{
			if (QualityManager.GetAssetQualityLevel() == QualityManager.AssetQualityLevel.Level_1)
			{
				return 0.5f;
			}
			return 1f;
		}
	}

	public string GetAssetTypePath(string path, AssetLoadPathType type, bool isfetch = false)
	{
		if (string.IsNullOrEmpty(path))
		{
			return "";
		}
		string result = "";
		int result2 = 0;
		if (isfetch)
		{
			switch (type)
			{
			case AssetLoadPathType.Master:
				result = "Master/" + path;
				break;
			case AssetLoadPathType.MasterEtc:
				result = "Master/etc/" + path;
				break;
			case AssetLoadPathType.CharaMaster:
				result = "Master/chara/" + path;
				break;
			case AssetLoadPathType.Tutorial:
				result = "Tutorial/TutorialTextureAtlas/" + path;
				break;
			case AssetLoadPathType.StoryTutorial:
				result = "Storylang/StoryTutorialTextureAtlas/" + path;
				break;
			case AssetLoadPathType.StoryParam:
				result = "Story/Param/" + path;
				break;
			case AssetLoadPathType.StoryParamDiff:
				result = "Storylang/ParamDiff/" + path;
				break;
			case AssetLoadPathType.StoryText:
				result = "Storylang/Text/" + path;
				break;
			case AssetLoadPathType.StoryMovieSubtitles:
				result = "Storylang/MovieSubtitles/" + path;
				break;
			case AssetLoadPathType.StoryCharacter:
				result = "Story/Character/" + path;
				break;
			case AssetLoadPathType.StoryBackground:
				result = "Story/Background/" + path;
				break;
			case AssetLoadPathType.StoryEndingStill:
				result = "Story/EndingStill/" + path;
				break;
			case AssetLoadPathType.HandCard:
				result = "Card/CardFrame/HandCard/" + path;
				break;
			case AssetLoadPathType.HandCardSpecular:
				result = "Card/CardFrame/HandCardSpecular/" + path;
				break;
			case AssetLoadPathType.CardFrame:
				result = "Card/CardFrame/" + path;
				break;
			case AssetLoadPathType.CardFrameClassIcon:
				result = "Card/CardFrame/ClassIcon/" + path;
				break;
			case AssetLoadPathType.CardFrameMesh:
				result = "Card/Common/Frame/Meshes/" + path;
				break;
			case AssetLoadPathType.CardFrameMaterial:
				result = "Card/Common/Frame/" + path + "/" + path;
				break;
			case AssetLoadPathType.CardFrameMaterialPlus:
				result = "Card/Common/Frame/Materials/" + path;
				break;
			case AssetLoadPathType.CardFrameTextureCommon:
				result = "Card/Common/Frame/Textures/" + path;
				break;
			case AssetLoadPathType.FoilTextures:
				result = "Card/Common/Foil/Textures/" + path;
				break;
			case AssetLoadPathType.UnitCardMaterial:
				result = "Card/Field/Materials/" + path;
				break;
			case AssetLoadPathType.UnitCardTextures:
				result = "Card/Field/Textures/" + path;
				break;
			case AssetLoadPathType.SpellCardMaterial:
				result = "Card/Spell/Materials/" + path;
				break;
			case AssetLoadPathType.SpellCardTextures:
				result = "Card/Spell/Textures/" + path;
				break;
			case AssetLoadPathType.UnitHeader:
				result = "Card/Field/Header/log_" + path;
				break;
			case AssetLoadPathType.OtherHeader:
				result = "Card/Spell/Header/log_" + path;
				break;
			case AssetLoadPathType.Effect2D:
				result = "Effect/Effects/" + path;
				break;
			case AssetLoadPathType.Effect2DMaterials:
				result = "Effect/Images/Materials/" + path;
				break;
			case AssetLoadPathType.Effect3D:
				result = "Effect/FBX/" + path;
				break;
			case AssetLoadPathType.Effect3DAnim:
				result = "Effect/FBX/" + path + "/Motions/";
				break;
			case AssetLoadPathType.Effect3DMat:
				result = "Effect/FBX/" + path + "/Materials/";
				break;
			case AssetLoadPathType.Emblem_S:
				result = "Ui/Emblem/S/" + Data.Master.EmblemMgr.GetResourcePath(long.Parse(path)) + "_s";
				break;
			case AssetLoadPathType.Emblem_M:
				result = "Ui/Emblem/M/" + Data.Master.EmblemMgr.GetResourcePath(long.Parse(path)) + "_m";
				break;
			case AssetLoadPathType.Degree_S:
				result = "Uilang/Degree/S/" + Data.Master.DegreeMgr.GetResourcePath(int.Parse(path)) + "_s";
				break;
			case AssetLoadPathType.DegreeMaterial_S:
				result = "Uilang/Degree/Materials/" + Data.Master.DegreeMgr.GetResourcePath(int.Parse(path)) + "_s_M";
				break;
			case AssetLoadPathType.Degree_M:
				result = "Uilang/Degree/M/" + Data.Master.DegreeMgr.GetResourcePath(int.Parse(path)) + "_m";
				break;
			case AssetLoadPathType.DegreeMaterial_M:
				result = "Uilang/Degree/Materials/" + Data.Master.DegreeMgr.GetResourcePath(int.Parse(path)) + "_m_M";
				break;
			case AssetLoadPathType.DegreeMask:
				result = "Uilang/Degree/Masks/" + Data.Master.DegreeMgr.GetMaskTexturePath(int.Parse(path));
				break;
			case AssetLoadPathType.RankIcon_S:
				result = "Uilang/RankIcon/S/icon_rank_" + path + "_s";
				break;
			case AssetLoadPathType.RankIcon_L:
				result = "Uilang/RankIcon/L/icon_rank_" + path + "_l";
				break;
			case AssetLoadPathType.Country_S:
				result = "Ui/Country/S/country_" + path + "_s";
				break;
			case AssetLoadPathType.Country_M:
				result = "Ui/Country/M/country_" + path + "_m";
				break;
			case AssetLoadPathType.DeckListTexture:
				result = $"Ui/TextureAtlas/DeckListTextureAtlas/btn_deck_{int.Parse(path):D2}";
				break;
			case AssetLoadPathType.DeckEditBGTexture:
				result = "Ui/TextureAtlas/DeckListTextureAtlas/" + path;
				break;
			case AssetLoadPathType.ClassCharaSpine:
				result = "Ui/ClassChar/Prefab/class_" + path;
				break;
			case AssetLoadPathType.ClassCharaBase:
				result = ((!int.TryParse(path, out result2)) ? $"Ui/ClassChar/Textures/Base/class_{path}_base" : $"Ui/ClassChar/Textures/Base/class_{result2:D2}_base");
				break;
			case AssetLoadPathType.ClassCharaBaseWin:
				result = "Ui/ClassChar/Textures/Base/class_" + path + "_base_win";
				break;
			case AssetLoadPathType.ClassCharaBaseLose:
				result = "Ui/ClassChar/Textures/Base/class_" + path + "_base_lose";
				break;
			case AssetLoadPathType.ClassCharaEvolve:
				result = ((!int.TryParse(path, out result2)) ? $"Ui/ClassChar/Textures/Base/class_{path}_base_evolve" : $"Ui/ClassChar/Textures/Base/class_{result2:D2}_base_evolve");
				break;
			case AssetLoadPathType.ClassCharaEvolveWin:
				result = "Ui/ClassChar/Textures/Base/class_" + path + "_base_evolve_win";
				break;
			case AssetLoadPathType.ClassCharaEvolveLose:
				result = "Ui/ClassChar/Textures/Base/class_" + path + "_base_evolve_lose";
				break;
			case AssetLoadPathType.ClassCharaHeader:
				result = "Ui/ClassChar/Textures/Header/" + path;
				break;
			case AssetLoadPathType.ClassCharaSkinThumbnail:
				result = $"Ui/ClassChar/Textures/SkinThumbnail/class_skin_{int.Parse(path):D2}";
				break;
			case AssetLoadPathType.ClassCharaWideThumbnail:
			{
				int result5 = 0;
				result = ((!int.TryParse(path, out result5)) ? $"Ui/ClassChar/Textures/WideThumbnail/chara_select_thumbnail_wide_class_{path}" : $"Ui/ClassChar/Textures/WideThumbnail/chara_select_thumbnail_wide_class_{result5:D2}");
				break;
			}
			case AssetLoadPathType.ClassCharaButton:
			{
				int result4 = 0;
				result = ((!int.TryParse(path, out result4)) ? $"Ui/ClassChar/Textures/Button/class_select_thumbnail_{path}" : $"Ui/ClassChar/Textures/Button/class_select_thumbnail_{result4:D2}");
				break;
			}
			case AssetLoadPathType.PracticePuzzleThumbnail:
			{
				result = ((!int.TryParse(path, out var result3)) ? $"Ui/Puzzle/Thumbnail/puzzle_thumbnail_{path}" : $"Ui/Puzzle/Thumbnail/puzzle_thumbnail_{result3:D2}");
				break;
			}
			case AssetLoadPathType.ClassCharaIconLevel:
				result = "Ui/ClassChar/Textures/Icon/class_" + path + "_level";
				break;
			case AssetLoadPathType.ClassCharaEncampment:
				result = "Ui/ClassChar/Textures/Encampment/class_" + path + "_encampment";
				break;
			case AssetLoadPathType.ClassCharaMesh:
				result = "Ui/ClassChar/Meshes/" + path;
				break;
			case AssetLoadPathType.ClassCharaMaterial:
				result = "Ui/ClassChar/Materials/" + path;
				break;
			case AssetLoadPathType.ClassCharaMaterialMain:
				result = "Ui/ClassChar/Materials/Main/" + path;
				break;
			case AssetLoadPathType.ClassCharaTexture:
				result = "Ui/ClassChar/Textures/" + path;
				break;
			case AssetLoadPathType.ClassCharaFrameTexture:
				result = "Ui/ClassChar/Textures/Frame/" + path;
				break;
			case AssetLoadPathType.ClassCharaProfile:
				result = "Ui/ClassChar/Textures/Profile/" + path;
				break;
			case AssetLoadPathType.ClassCharaStory:
				result = $"Ui/ClassChar/Textures/Story/class_{int.Parse(path):D2}_story";
				break;
			case AssetLoadPathType.ClassChara3D:
				result = "Ui/Class3dChar/Prehab/" + path + "/chr" + path;
				break;
			case AssetLoadPathType.AreaSelectTexture:
				result = "Ui/TextureAtlas/AreaSelectTextureAtlas/" + path;
				break;
			case AssetLoadPathType.GachaTexture:
				result = "Ui/TextureAtlas/GachaTextureAtlas/" + path;
				break;
			case AssetLoadPathType.ShopCardPack:
				result = "Uilang/Shop/CardPack/" + path;
				break;
			case AssetLoadPathType.ShopBuildDeck:
				result = "Uilang/Shop/BuildDeck/" + path;
				break;
			case AssetLoadPathType.ShopBuildDeckThumbnail:
				result = "Uilang/Shop/BuildDeck/build_deck_thumbnail_" + path;
				break;
			case AssetLoadPathType.ShopSleeve:
				result = "Uilang/Shop/Sleeve/" + path;
				break;
			case AssetLoadPathType.ShopClassSkin:
				result = "Uilang/Shop/ClassSkin/" + path;
				break;
			case AssetLoadPathType.ShopItem:
				result = "Uilang/Shop/Ticket/" + path;
				break;
			case AssetLoadPathType.CardDeco:
				result = "Sleeve/CardDeco/" + path;
				break;
			case AssetLoadPathType.SleeveTexture:
				result = "Sleeve/Textures/" + Data.Master.SleeveMgr.GetResourcePath(long.Parse(path)).ToString();
				break;
			case AssetLoadPathType.SleeveTextureMask:
			{
				Sleeve sleeve = Data.Master.SleeveMgr.Get(long.Parse(path));
				result = ((!sleeve.IsPremiumSleeve) ? string.Empty : ("Sleeve/Masks/sleeve_mask_" + sleeve.sleeve_id));
				break;
			}
			case AssetLoadPathType.SleeveTextureBasePath:
				result = "Sleeve/Textures/" + path;
				break;
			case AssetLoadPathType.SleeveTextureAORefSpec:
				result = "Sleeve/Textures/sleeve_" + DataMgr.GetAbleSleeveId(long.Parse(path)) + "_a";
				break;
			case AssetLoadPathType.SleeveTextureNormalMap:
				result = "Sleeve/Textures/sleeve_" + DataMgr.GetAbleSleeveId(long.Parse(path)) + "_n";
				break;
			case AssetLoadPathType.SleeveMaterial:
				result = "Sleeve/Materials/sleeve_" + DataMgr.GetAbleSleeveId(long.Parse(path)) + "_M";
				break;
			case AssetLoadPathType.SleeveMesh:
				result = "Sleeve/Meshes/" + path;
				break;
			case AssetLoadPathType.SleeveSpecular:
				result = "Sleeve/Meshes/Materials/" + path;
				break;
			case AssetLoadPathType.BattleTexture:
				result = "Ui/TextureAtlas/BattleTextureAtlas/" + path;
				break;
			case AssetLoadPathType.BattleLangTexture:
				result = "Uilang/TextureAtlas/BattleLangTextureAtlas/" + path;
				break;
			case AssetLoadPathType.Field3D:
				result = "Bg/" + path + "/_Battle" + path;
				break;
			case AssetLoadPathType.Font:
				result = "Ui/Fonts/" + path;
				break;
			case AssetLoadPathType.Background:
				result = "Ui/Background/" + path;
				break;
			case AssetLoadPathType.CardMenu:
				result = "Ui/CardMenu/" + path;
				break;
			case AssetLoadPathType.BossRushSpecialCard:
				result = "Ui/BossRush/boss_rush_" + path;
				break;
			case AssetLoadPathType.FirstTips:
				result = "Uilang/FirstTips/" + path;
				break;
			case AssetLoadPathType.Arena:
				result = "Ui/TextureAtlas/ArenaTextureAtlas/" + path;
				break;
			case AssetLoadPathType.Item:
				result = "Ui/Item/" + path;
				break;
			case AssetLoadPathType.Lottery:
				result = "Ui/Lottery/" + path;
				break;
			case AssetLoadPathType.UiOtherTexture:
				result = "Ui/Other/" + path;
				break;
			case AssetLoadPathType.UilangOtherTexture:
				result = "Uilang/Other/" + path;
				break;
			case AssetLoadPathType.UiStory:
				result = "Ui/Story/" + path;
				break;
			case AssetLoadPathType.UiStorySectionSummary:
				result = "Ui/Story/SectionSummary/" + path;
				break;
			case AssetLoadPathType.StorySubChapterBtnTexture:
				result = "Ui/Story/StorySelect/" + path;
				break;
			case AssetLoadPathType.StoryChapterHeader:
				result = "Ui/Story/ChapterHeader/" + path;
				break;
			case AssetLoadPathType.StorySelectWorldPanel:
				result = "Ui/Story/StorySelectWorldPanel/" + path;
				break;
			case AssetLoadPathType.BattlePass:
				result = "Ui/BattlePass/" + path;
				break;
			case AssetLoadPathType.BattleStage:
				result = "Ui/BattleStage/" + path;
				break;
			case AssetLoadPathType.PackBox:
				result = "PackBox/prefab/" + path;
				break;
			case AssetLoadPathType.UiDownLoad:
				result = "UiDownload/" + path;
				break;
			case AssetLoadPathType.UiDownLoadInfo:
				result = "UiDownload/Info/" + path;
				break;
			case AssetLoadPathType.SpecialCrystal:
				result = "Uilang/LegendCrystal/" + path;
				break;
			case AssetLoadPathType.GrandPrixSpecialAtlas:
				result = "Ui/TextureAtlas/GrandPrixSpecial/" + path;
				break;
			case AssetLoadPathType.QuestAtlas:
				result = "Ui/TextureAtlas/Quest/Quest";
				break;
			case AssetLoadPathType.Stamp:
				result = "Uilang/Stamp/stamp_" + path;
				break;
			case AssetLoadPathType.Uilang3DField:
				result = "Uilang/3DField/" + path;
				break;
			case AssetLoadPathType.Bingo:
				result = "Ui/Bingo/" + path;
				break;
			case AssetLoadPathType.NeutralVote:
				result = "Ui/PopularityVote/Neutral/neutral_vote_" + path;
				break;
			case AssetLoadPathType.NeutralVoteThumbnail_S:
				result = "Ui/PopularityVote/Neutral/Thumbnail_S/neutral_vote_thumb_" + path + "_s";
				break;
			case AssetLoadPathType.NeutralVoteThumbnail_M:
				result = "Ui/PopularityVote/Neutral/Thumbnail_M/neutral_vote_thumb_" + path + "_m";
				break;
			case AssetLoadPathType.LeaderVote:
				result = "Ui/PopularityVote/Leader/leader_vote_" + path;
				break;
			case AssetLoadPathType.LeaderVoteThumbnail_S:
				result = "Ui/PopularityVote/Leader/Thumbnail_S/leader_vote_thumb_" + path + "_s";
				break;
			case AssetLoadPathType.UISpine:
				result = "Ui/UISpine/Prefab/" + path.Replace("_body", "") + "/" + path;
				break;
			case AssetLoadPathType.FlowChart:
				result = "Ui/FlowChart/" + path;
				break;
			case AssetLoadPathType.MyPageBackGround:
				result = "Ui/MyPageBackGround/bg_mypage_" + path;
				break;
			case AssetLoadPathType.MyPageCharacter:
				result = "Ui/MyPageCharacter/" + path + "/" + path + "_mypage";
				break;
			case AssetLoadPathType.MyPageCharacterMask:
				result = "Ui/MyPageCharacter/" + path + "/" + path + "_mypage_mask";
				break;
			case AssetLoadPathType.MyPageBackGroundIcon:
				result = "Ui/MyPageBackGroundIcon/mypage_bg_icon_" + path;
				break;
			case AssetLoadPathType.MyPageBackGroundRandomSelectIcon:
				result = "Ui/MyPageBackGroundIcon/mypage_bg_random_icon_" + path;
				break;
			case AssetLoadPathType.Competition:
				result = "Ui/Competition/" + path;
				break;
			case AssetLoadPathType.FreeCardPack:
				result = "Ui/FreeCardPack/" + path;
				break;
			case AssetLoadPathType.SpecialTitle:
				result = "Ui/SpecialTitle/" + path + "/special_title_" + path;
				break;
			}
		}
		else
		{
			switch (type)
			{
			case AssetLoadPathType.Master:
			case AssetLoadPathType.MasterEtc:
			case AssetLoadPathType.CharaMaster:
				result = "master_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.StoryParam:
			case AssetLoadPathType.StoryCharacter:
			case AssetLoadPathType.StoryBackground:
			case AssetLoadPathType.StoryEndingStill:
				result = "story_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.StoryTutorial:
			case AssetLoadPathType.StoryParamDiff:
			case AssetLoadPathType.StoryText:
			case AssetLoadPathType.StoryMovieSubtitles:
				result = "storylang_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.HandCard:
			case AssetLoadPathType.HandCardSpecular:
			case AssetLoadPathType.CardFrame:
			case AssetLoadPathType.CardFrameClassIcon:
			case AssetLoadPathType.CardDeco:
			case AssetLoadPathType.SleeveTextureBasePath:
			case AssetLoadPathType.SleeveMesh:
			case AssetLoadPathType.SleeveSpecular:
			case AssetLoadPathType.CardFrameMesh:
			case AssetLoadPathType.CardFrameMaterial:
			case AssetLoadPathType.CardFrameMaterialPlus:
			case AssetLoadPathType.CardFrameTextureCommon:
			case AssetLoadPathType.FoilTextures:
			case AssetLoadPathType.UnitHeader:
			case AssetLoadPathType.OtherHeader:
				result = "card_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.SleeveMaterial:
				result = "card_sleeve_" + Data.Master.SleeveMgr.Get(long.Parse(path)).sleeve_id + "_m.unity3d";
				break;
			case AssetLoadPathType.SleeveTexture:
				result = "card_sleeve_" + Data.Master.SleeveMgr.Get(long.Parse(path)).sleeve_id + ".unity3d";
				break;
			case AssetLoadPathType.SleeveTextureMask:
			{
				Sleeve sleeve2 = Data.Master.SleeveMgr.Get(long.Parse(path));
				result = ((!sleeve2.IsPremiumSleeve) ? string.Empty : ("card_sleeve_mask_" + sleeve2.sleeve_id + ".unity3d"));
				break;
			}
			case AssetLoadPathType.SleeveTextureAORefSpec:
				result = "card_sleeve_" + DataMgr.GetAbleSleeveId(long.Parse(path)) + "_a.unity3d";
				break;
			case AssetLoadPathType.SleeveTextureNormalMap:
				result = "card_sleeve_" + DataMgr.GetAbleSleeveId(long.Parse(path)) + "_n.unity3d";
				break;
			case AssetLoadPathType.UnitCardMaterial:
			case AssetLoadPathType.UnitCardTextures:
			case AssetLoadPathType.SpellCardMaterial:
			case AssetLoadPathType.SpellCardTextures:
				result = "card_" + path.ToLower() + "0.unity3d";
				break;
			case AssetLoadPathType.Effect2D:
			case AssetLoadPathType.Effect2DMaterials:
			case AssetLoadPathType.Effect3D:
			case AssetLoadPathType.Effect3DAnim:
			case AssetLoadPathType.Effect3DMat:
				result = "effect_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.Emblem_S:
				result = "ui_" + Data.Master.EmblemMgr.GetResourcePath(long.Parse(path)) + "_s.unity3d";
				break;
			case AssetLoadPathType.Emblem_M:
				result = "ui_" + Data.Master.EmblemMgr.GetResourcePath(long.Parse(path)) + "_m.unity3d";
				break;
			case AssetLoadPathType.Degree_S:
				result = "uilang_" + Data.Master.DegreeMgr.GetResourcePath(int.Parse(path)) + "_s.unity3d";
				break;
			case AssetLoadPathType.DegreeMaterial_S:
				result = "uilang_" + Data.Master.DegreeMgr.GetResourcePath(int.Parse(path)) + "_s_m.unity3d";
				break;
			case AssetLoadPathType.Degree_M:
				result = "uilang_" + Data.Master.DegreeMgr.GetResourcePath(int.Parse(path)) + "_m.unity3d";
				break;
			case AssetLoadPathType.DegreeMaterial_M:
				result = "uilang_" + Data.Master.DegreeMgr.GetResourcePath(int.Parse(path)) + "_m_m.unity3d";
				break;
			case AssetLoadPathType.DegreeMask:
				result = "uilang_" + Data.Master.DegreeMgr.GetMaskTexturePath(int.Parse(path)) + ".unity3d";
				break;
			case AssetLoadPathType.RankIcon_S:
				result = "uilang_icon_rank_" + path + "_s.unity3d";
				break;
			case AssetLoadPathType.RankIcon_L:
				result = "uilang_icon_rank_" + path + "_l.unity3d";
				break;
			case AssetLoadPathType.Country_S:
				result = "ui_country_" + path.ToLower() + "_s.unity3d";
				break;
			case AssetLoadPathType.Country_M:
				result = "ui_country_" + path.ToLower() + "_m.unity3d";
				break;
			case AssetLoadPathType.DeckListTexture:
				result = $"ui_btn_deck_{int.Parse(path):D2}.unity3d";
				break;
			case AssetLoadPathType.DeckEditBGTexture:
				result = "ui_" + path + ".unity3d";
				break;
			case AssetLoadPathType.ClassCharaSpine:
				result = "ui_class_" + path + ".unity3d";
				break;
			case AssetLoadPathType.ClassCharaBase:
				result = ((!int.TryParse(path, out result2)) ? $"ui_class_{path}_base.unity3d" : $"ui_class_{result2:D2}_base.unity3d");
				break;
			case AssetLoadPathType.ClassCharaBaseWin:
				result = "ui_class_" + path + "_base_win.unity3d";
				break;
			case AssetLoadPathType.ClassCharaBaseLose:
				result = "ui_class_" + path + "_base_lose.unity3d";
				break;
			case AssetLoadPathType.ClassCharaEvolve:
				result = ((!int.TryParse(path, out result2)) ? $"ui_class_{path}_base_evolve.unity3d" : $"ui_class_{result2:D2}_base_evolve.unity3d");
				break;
			case AssetLoadPathType.ClassCharaEvolveWin:
				result = "ui_class_" + path + "_base_evolve_win.unity3d";
				break;
			case AssetLoadPathType.ClassCharaEvolveLose:
				result = "ui_class_" + path + "_base_evolve_lose.unity3d";
				break;
			case AssetLoadPathType.ClassCharaHeader:
				result = "ui_" + path + ".unity3d";
				break;
			case AssetLoadPathType.ClassCharaSkinThumbnail:
				result = $"ui_class_skin_{int.Parse(path):D2}.unity3d";
				break;
			case AssetLoadPathType.PracticePuzzleThumbnail:
				result = $"ui_puzzle_thumbnail_{int.Parse(path):D2}.unity3d";
				break;
			case AssetLoadPathType.ClassCharaWideThumbnail:
			{
				int result7 = 0;
				result = ((!int.TryParse(path, out result7)) ? $"ui_chara_select_thumbnail_wide_class_{path}.unity3d" : $"ui_chara_select_thumbnail_wide_class_{result7:D2}.unity3d");
				break;
			}
			case AssetLoadPathType.ClassCharaButton:
			{
				int result6 = 0;
				result = ((!int.TryParse(path, out result6)) ? $"ui_class_select_thumbnail_{path}.unity3d" : $"ui_class_select_thumbnail_{result6:D2}.unity3d");
				break;
			}
			case AssetLoadPathType.ClassCharaStory:
				result = $"ui_class_{int.Parse(path):D2}_story.unity3d";
				break;
			case AssetLoadPathType.ClassChara3D:
				result = $"ui_chr{path}.unity3d";
				break;
			case AssetLoadPathType.ClassCharaIconLevel:
				result = "ui_class_" + path + "_level.unity3d";
				break;
			case AssetLoadPathType.ClassCharaEncampment:
				result = "ui_class_" + path + "_encampment.unity3d";
				break;
			case AssetLoadPathType.Field3D:
				result = "bg_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.Tutorial:
				result = "tutorial_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.BossRushSpecialCard:
				result = "ui_boss_rush_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.StorySubChapterBtnTexture:
			case AssetLoadPathType.StoryChapterHeader:
			case AssetLoadPathType.StorySelectWorldPanel:
			case AssetLoadPathType.Font:
			case AssetLoadPathType.ClassCharaMesh:
			case AssetLoadPathType.ClassCharaMaterial:
			case AssetLoadPathType.ClassCharaMaterialMain:
			case AssetLoadPathType.ClassCharaTexture:
			case AssetLoadPathType.ClassCharaFrameTexture:
			case AssetLoadPathType.ClassCharaProfile:
			case AssetLoadPathType.AreaSelectTexture:
			case AssetLoadPathType.GachaTexture:
			case AssetLoadPathType.BattleTexture:
			case AssetLoadPathType.Background:
			case AssetLoadPathType.CardMenu:
			case AssetLoadPathType.Arena:
			case AssetLoadPathType.UiOtherTexture:
			case AssetLoadPathType.UiStory:
			case AssetLoadPathType.UiStorySectionSummary:
			case AssetLoadPathType.GrandPrixSpecialAtlas:
			case AssetLoadPathType.BattlePass:
			case AssetLoadPathType.BattleStage:
			case AssetLoadPathType.Bingo:
			case AssetLoadPathType.FlowChart:
			case AssetLoadPathType.Competition:
			case AssetLoadPathType.FreeCardPack:
				result = "ui_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.MyPageBackGround:
				result = "ui_bg_mypage_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.MyPageCharacter:
				result = "ui_" + path.ToLower() + "_mypage.unity3d";
				break;
			case AssetLoadPathType.MyPageCharacterMask:
				result = "ui_" + path.ToLower() + "_mypage_mask.unity3d";
				break;
			case AssetLoadPathType.MyPageBackGroundIcon:
				result = "ui_mypage_bg_icon_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.MyPageBackGroundRandomSelectIcon:
				result = "ui_mypage_bg_random_icon_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.QuestAtlas:
				result = "ui_quest.unity3d";
				break;
			case AssetLoadPathType.UilangOtherTexture:
				result = "uilang_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.ShopBuildDeckThumbnail:
				result = "uilang_build_deck_thumbnail_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.SpecialTitle:
				result = "ui_special_title_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.ShopCardPack:
			case AssetLoadPathType.ShopBuildDeck:
			case AssetLoadPathType.ShopSleeve:
			case AssetLoadPathType.ShopClassSkin:
			case AssetLoadPathType.ShopItem:
			case AssetLoadPathType.BattleLangTexture:
				result = "uilang_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.FirstTips:
				result = "uilang_" + path + ".unity3d";
				break;
			case AssetLoadPathType.SpecialCrystal:
				result = "uilang_" + path.ToLower() + ".unity3d";
				break;
			case AssetLoadPathType.Item:
			case AssetLoadPathType.Lottery:
				result = "ui_" + path + ".unity3d";
				break;
			case AssetLoadPathType.PackBox:
				result = "packbox_" + path + ".unity3d";
				break;
			case AssetLoadPathType.UiDownLoad:
			case AssetLoadPathType.UiDownLoadInfo:
				result = "uidownload_" + path + ".unity3d";
				break;
			case AssetLoadPathType.Stamp:
				result = "uilang_stamp_" + path + ".unity3d";
				break;
			case AssetLoadPathType.Uilang3DField:
				result = "uilang_" + path + ".unity3d";
				break;
			case AssetLoadPathType.NeutralVote:
				result = "ui_neutral_vote_" + path + ".unity3d";
				break;
			case AssetLoadPathType.NeutralVoteThumbnail_S:
				result = "ui_neutral_vote_thumb_" + path + "_s.unity3d";
				break;
			case AssetLoadPathType.NeutralVoteThumbnail_M:
				result = "ui_neutral_vote_thumb_" + path + "_m.unity3d";
				break;
			case AssetLoadPathType.LeaderVote:
				result = "ui_leader_vote_" + path + ".unity3d";
				break;
			case AssetLoadPathType.LeaderVoteThumbnail_S:
				result = "ui_leader_vote_thumb_" + path + "_s.unity3d";
				break;
			case AssetLoadPathType.UISpine:
				result = "ui_" + path + ".unity3d";
				break;
			}
		}
		return result;
	}

	public long GetExistingSleeveId(long sleeveId)
	{
		string path = sleeveId.ToString();
		string assetTypePath = GetAssetTypePath(path, AssetLoadPathType.SleeveMaterial);
		if (!ExistsAssetBundleManifest(assetTypePath))
		{
			AddAssetNotFoundLog(assetTypePath);
			return 3000011L;
		}
		string assetTypePath2 = GetAssetTypePath(path, AssetLoadPathType.SleeveTexture);
		if (!ExistsAssetBundleManifest(assetTypePath2))
		{
			AddAssetNotFoundLog(assetTypePath2);
			return 3000011L;
		}
		if (Data.Master.SleeveMgr.Get(sleeveId).IsPremiumSleeve)
		{
			string assetTypePath3 = GetAssetTypePath(path, AssetLoadPathType.SleeveTextureMask);
			if (!ExistsAssetBundleManifest(assetTypePath3))
			{
				AddAssetNotFoundLog(assetTypePath3);
				return 3000011L;
			}
		}
		return sleeveId;
	}

	public bool IsExistSleeveNormalMap(long sleeveId)
	{
		string assetTypePath = GetAssetTypePath(sleeveId.ToString(), AssetLoadPathType.SleeveTextureNormalMap);
		return ExistsAssetBundleManifest(assetTypePath);
	}

	private void AddAssetNotFoundLog(string path)
	{
		string text = "asset not found : " + path;
		Debug.LogError(text);
		LocalLog.AccumulateTraceLog(text);
	}

	public string GetLoadFontFilePath(string fileName)
	{
		return "f/" + fileName;
	}

	public Material FindCardMaterial(int cardId, AssetLoadPathType type, bool isEvol = false, bool isMutation = false, CardBasePrm.CharaType originalType = CardBasePrm.CharaType.NORMAL, bool isChoiceBrave = false)
	{
		string text = ((cardId / 1000000000 == 1) ? GetAssetTypePath($"{cardId}_M", AssetLoadPathType.UnitCardMaterial, isfetch: true) : ((isEvol && type == AssetLoadPathType.UnitCardMaterial) ? GetAssetTypePath($"{cardId}1_M", type, isfetch: true) : ((!(isMutation || isChoiceBrave)) ? GetAssetTypePath($"{cardId}0_M", type, isfetch: true) : ((originalType != CardBasePrm.CharaType.NORMAL) ? GetAssetTypePath($"{cardId}0_M", AssetLoadPathType.SpellCardMaterial, isfetch: true) : GetAssetTypePath($"{cardId}0_M", AssetLoadPathType.UnitCardMaterial, isfetch: true)))));
		Material obj = LoadObject(text) as Material;
		if (obj == null)
		{
			AddAssetNotFoundLog(text);
		}
		return obj;
	}

	public int GetPreferredParallelDownloadNum()
	{
		if (fixedParallelTasks > 0)
		{
			return fixedParallelTasks;
		}
		if (_preferredParallelDownloadTasks < 0)
		{
			_preferredParallelDownloadTasks = 4;
		}
		return _preferredParallelDownloadTasks;
	}

	public int GetPreferredParallelLoadNum()
	{
		if (fixedParallelTasks > 0)
		{
			return fixedParallelTasks;
		}
		if (_preferredParallelLoadTasks < 0)
		{
			_preferredParallelLoadTasks = 8;
		}
		return _preferredParallelLoadTasks;
	}

	private void Awake()
	{
	}

	private void Start()
	{
		downloadList = new List<string>();
		Toolbox.ResourcesManager = this;
	}

	public void RequestDownloadStopForMovie()
	{
		if (BgDownloadState == BackgroundDownloadState.Download)
		{
			BgDownloadState = BackgroundDownloadState.StopRequest;
			_stopForMovie = true;
		}
	}

	public void RequestDownloadStopForMainDownload()
	{
		if (BgDownloadState == BackgroundDownloadState.Download)
		{
			BgDownloadState = BackgroundDownloadState.StopRequest;
		}
	}

	private IEnumerator WaitBgDownloadStopRequestFulfilled()
	{
		while (!Toolbox.AssetManager.IsDownloadJobIdle())
		{
			yield return null;
		}
		BgDownloadState = BackgroundDownloadState.None;
	}

	public StopResult Stop()
	{
		if (BgDownloadState == BackgroundDownloadState.StopRequest)
		{
			BgDownloadState = BackgroundDownloadState.None;
			if (_stopForMovie)
			{
				_stopForMovie = false;
				return StopResult.Paused;
			}
			return StopResult.Stopped;
		}
		if (BgDownloadState == BackgroundDownloadState.Download)
		{
			BgDownloadState = BackgroundDownloadState.None;
			return StopResult.Finished;
		}
		return StopResult.Stopped;
	}

	public bool CanStartBgDownload()
	{
		if (CanStartDownload())
		{
			return !Toolbox.MovieManager.IsPlaying();
		}
		return false;
	}

	public bool CanStartDownload()
	{
		if (BgDownloadState == BackgroundDownloadState.None && !downloadSemaphore)
		{
			return Toolbox.AssetManager.IsDownloadJobIdle();
		}
		return false;
	}

	public IEnumerator DownloadAssetGroupBackground(List<string> assetList, Action callback, bool isProgress = true, bool isSavePlayerPrefs = true)
	{
		if (BgDownloadState == BackgroundDownloadState.Init)
		{
			BgDownloadState = BackgroundDownloadState.Download;
			yield return _DownloadAssetGroup(assetList, callback, isProgress, isSavePlayerPrefs);
		}
	}

	public IEnumerator DownloadAssetGroup(List<string> assetList, Action callback, bool isProgress = true, bool isSavePlayerPrefs = true)
	{
		while (BgDownloadState == BackgroundDownloadState.Init)
		{
			yield return null;
		}
		if (BgDownloadState == BackgroundDownloadState.Download)
		{
			BgDownloadState = BackgroundDownloadState.StopRequest;
		}
		while (BgDownloadState == BackgroundDownloadState.StopRequest)
		{
			yield return WaitBgDownloadStopRequestFulfilled();
		}
		Action callback2 = delegate
		{
			if (callback != null)
			{
				callback();
			}
		};
		yield return _DownloadAssetGroup(assetList, callback2, isProgress, isSavePlayerPrefs);
	}

	private IEnumerator _DownloadAssetGroup(List<string> assetList, Action callback, bool isProgress = true, bool isSavePlayerPrefs = true)
	{
		if (assetList == null || assetList.Count == 0)
		{
			callback?.Invoke();
			yield break;
		}
		while (downloadSemaphore)
		{
			yield return null;
		}
		SetDownloadProcessLock(enable_lock: true);
		QualitySettings.vSyncCount = 0;
		Application.targetFrameRate = 60;
		if (downloadList.Count > 0)
		{
			downloadList.Clear();
		}
		bool isDownloadVoiceUse = Toolbox.AudioManager.isDownloadVoiceUse;
		for (int i = 0; i < assetList.Count; i++)
		{
			AssetHandle assetHandle = Toolbox.AssetManager.GetAssetHandle(assetList[i]);
			if (assetHandle != null && (!assetHandle.IsSoundVoice() || isDownloadVoiceUse) && assetHandle.isReDownloadAsset(CustomPreference.IsNormalResource))
			{
				downloadList.Add(assetList[i]);
			}
		}
		if (downloadList.Count > 0)
		{
			Toolbox.AssetManager.AddDownloadMaxCount(downloadList.Count);
			yield return StartCoroutine(DownloadAssetGroupSub(downloadList, isProgress));
			yield return new WaitForFixedUpdate();
			if (isSavePlayerPrefs)
			{
				Toolbox.SavedataManager.Save();
			}
		}
		QualitySettings.vSyncCount = 0;
		Application.targetFrameRate = Toolbox.QualityManager.GetFrameRate();
		SetDownloadProcessLock(enable_lock: false);
		callback?.Invoke();
	}

	private IEnumerator DownloadAssetGroupSub(List<string> assetList, bool isProgress = true)
	{
		if (isProgress)
		{
			UIManager.GetInstance().LoadingViewManager.UpdateLoadingNum(0);
		}
		if (BgDownloadState != BackgroundDownloadState.StopRequest)
		{
			downloadRequestContext.callback = null;
			yield return StartCoroutine(ParallelAssetListExec(assetList, GetPreferredParallelDownloadNum(), downloadRequestContext, DownloadAssetSub, isProgress ? ProgressDebugType.Progress_DOWNLOAD : ProgressDebugType.Progress_NONE));
			UIManager.GetInstance().LoadingViewManager.UpdateLoadingNum(100);
		}
	}

	public IEnumerator DownloadAsset(string assetName, Action callback, bool isSavePlayerPrefs = true)
	{
		List<string> assetList = new List<string> { assetName };
		yield return StartCoroutine(DownloadAssetGroup(assetList, callback, isProgress: true, isSavePlayerPrefs));
	}

	private void DownloadAssetSub(string assetName, AssetRequestContext requestContext)
	{
		Toolbox.AssetManager.DownloadAsset(assetName, requestContext);
	}

	private List<string> FilterAssetList(List<string> assetList, ref List<string> duplicateList)
	{
		if (assetList.Count < 2)
		{
			return assetList;
		}
		List<string> list = new List<string>(new HashSet<string>(assetList));
		if (list.Count != assetList.Count)
		{
			duplicateList = assetList;
			for (int i = 0; i < list.Count; i++)
			{
				duplicateList.Remove(list[i]);
			}
		}
		return list;
	}

	private IEnumerator ParallelAssetListExec(List<string> assetList, int numParallelTasks, AssetRequestContext requestContext, Action<string, AssetRequestContext> exec, ProgressDebugType Progress = ProgressDebugType.Progress_NONE, bool preferSynchornousLoad = false)
	{
		if (BgDownloadState == BackgroundDownloadState.StopRequest)
		{
			yield break;
		}
		List<string> duplist = null;
		assetList = FilterAssetList(assetList, ref duplist);
		int totalJobs = assetList.Count;
		int finishedJobs = 0;
		if (requestContext == null)
		{
			requestContext = new AssetRequestContext(null, new Utility.LeanSemaphore(0), new AssetErrorState());
		}
		requestContext.callback = delegate(AssetHandle handle)
		{
			if (handle == null || string.IsNullOrEmpty(handle.AssetName) || assetList == null)
			{
				finishedJobs++;
			}
			else if (assetList.Contains(handle.AssetName))
			{
				finishedJobs++;
			}
		};
		requestContext.semaphore.Reset(numParallelTasks);
		requestContext.preferSynchronousLoad = preferSynchornousLoad;
		requestContext.errorState.Reset();
		AssetErrorState errorState = requestContext.errorState;
		LocalLog.UpdateLoadResourceLog("JustBeforeExec");
		do
		{
			if (BgDownloadState == BackgroundDownloadState.StopRequest)
			{
				yield break;
			}
			int count = assetList.Count;
			for (int num = 0; num < count; num++)
			{
				exec(assetList[num], requestContext);
			}
			while (finishedJobs < totalJobs && BgDownloadState != BackgroundDownloadState.StopRequest)
			{
				if (errorState.HasError())
				{
					errorState.SetCanceled();
				}
				yield return 0;
			}
			if (errorState.HasError())
			{
				if (errorState.lastDialogDecision != AssetErrorState.DialogDecision.RETRY)
				{
					LocalLog.RecordResouseLoadError(errorState.errorFlag);
					while (true)
					{
						yield return 0;
					}
				}
				assetList = errorState.GatherErrorFilenames();
				finishedJobs = totalJobs - assetList.Count;
			}
			if (BgDownloadState == BackgroundDownloadState.StopRequest)
			{
				Toolbox.AssetManager.CancelDownloadAsyncJob();
				break;
			}
		}
		while (errorState.HasError());
		requestContext.callback = null;
		if (duplist == null)
		{
			yield break;
		}
		for (int num2 = 0; num2 < duplist.Count; num2++)
		{
			AssetHandle assetHandle = Toolbox.AssetManager.GetAssetHandle(duplist[num2]);
			if (assetHandle != null && assetHandle.reference >= 1)
			{
				assetHandle.reference++;
			}
		}
	}

	public IEnumerator LoadAssetGroupAsync(List<string> rogueAssetList, Action callback, bool isProgress = true)
	{
		return LoadAssetGroup(rogueAssetList, callback, isProgress);
	}

	public IEnumerator LoadAssetGroupSync(List<string> rogueAssetList, Action callback, bool isProgress = true)
	{
		return LoadAssetGroup(rogueAssetList, callback, isProgress, preferSynchronousLoad: true);
	}

	public IEnumerator LoadAssetGroup(List<string> rogueAssetList, Action callback, bool isProgress = true, bool preferSynchronousLoad = false)
	{
		List<string> filteredAssetList = QuickLoadAssetGroup(rogueAssetList);
		if (filteredAssetList == null || filteredAssetList.Count == 0)
		{
			callback?.Invoke();
			yield break;
		}
		LocalLog.UpdateLoadResourceLog("BeforeSemaphore");
		while (loadSemaphore)
		{
			yield return null;
		}
		SetLoadProcessLock(enable_lock: true);
		QualitySettings.vSyncCount = 0;
		Application.targetFrameRate = 60;
		_ = isProgress;
		LocalLog.UpdateLoadResourceLog("BeforeParallelAssetListExec");
		Toolbox.AssetManager.AddLoadingMaxCount(rogueAssetList.Count);
		yield return StartCoroutine(ParallelAssetListExec(filteredAssetList, GetPreferredParallelLoadNum(), loadRequestContext, LoadAssetSub, isProgress ? ProgressDebugType.Progress_LOAD : ProgressDebugType.Progress_NONE, preferSynchronousLoad));
		LocalLog.UpdateLoadResourceLog("AfterParallelAssetListExec");
		yield return new WaitForFixedUpdate();
		QualitySettings.vSyncCount = 0;
		Application.targetFrameRate = Toolbox.QualityManager.GetFrameRate();
		SetLoadProcessLock(enable_lock: false);
		callback?.Invoke();
		LocalLog.UpdateLoadResourceLog("FinishLoad");
	}

	public IEnumerator DownloadAssetGroupWithLoadAsset(List<string> assetList, Action callback, bool isProgress = true)
	{
		if (assetList == null || assetList.Count == 0)
		{
			callback?.Invoke();
			yield break;
		}
		yield return StartCoroutine(DownloadAssetGroup(assetList, null, isProgress));
		yield return StartCoroutine(LoadAssetGroupAsync(assetList, null, isProgress));
	}

	private bool QuickLoadAsset(string assetName)
	{
		AssetHandle assetHandle = Toolbox.AssetManager.GetAssetHandle(assetName);
		bool result = false;
		if (assetHandle != null)
		{
			result = assetHandle.QuickLoadIfPossible();
		}
		return result;
	}

	private List<string> QuickLoadAssetGroup(List<string> assetList)
	{
		if (assetList == null || assetList.Count == 0)
		{
			return null;
		}
		List<string> list = null;
		int count = assetList.Count;
		if (count == 1)
		{
			string text = assetList[0];
			if (!QuickLoadAsset(text))
			{
				list = new List<string>(1);
				list.Add(text);
			}
		}
		else
		{
			HashSet<string> hashSet = null;
			for (int i = 0; i < count; i++)
			{
				string text2 = assetList[i];
				if (string.IsNullOrEmpty(text2))
				{
					continue;
				}
				if (hashSet != null && hashSet.Contains(text2))
				{
					AssetHandle assetHandle = Toolbox.AssetManager.GetAssetHandle(text2);
					if (assetHandle != null && assetHandle.reference >= 1)
					{
						assetHandle.reference++;
					}
				}
				else if (QuickLoadAsset(text2))
				{
					if (hashSet == null)
					{
						hashSet = new HashSet<string>();
					}
					hashSet.Add(text2);
				}
				else
				{
					if (list == null)
					{
						list = new List<string>();
					}
					list.Add(text2);
				}
			}
		}
		return list;
	}

	public IEnumerator LoadAssetAsync(string assetName, Action callback)
	{
		List<string> rogueAssetList = new List<string> { assetName };
		yield return StartCoroutine(LoadAssetGroupAsync(rogueAssetList, null));
		callback?.Invoke();
	}

	private void LoadAssetSub(string assetName, AssetRequestContext requestContext)
	{
		Toolbox.AssetManager.CacheAsset(assetName, requestContext);
	}

	public void StartCoroutine_DownloadAssetGroupWithLoadAsset(List<string> assetList, Action callback, bool isProgress = true)
	{
		if (assetList == null || assetList.Count == 0)
		{
			callback?.Invoke();
		}
		else
		{
			StartCoroutine(DownloadAssetGroupWithLoadAsset(assetList, callback, isProgress));
		}
	}

	public void StartCoroutine_DownloadAssetGroupWithLoadAsset(string asset, Action callback, bool isProgress = true)
	{
		StartCoroutine_DownloadAssetGroupWithLoadAsset(new List<string> { asset }, callback, isProgress);
	}

	public void StartCoroutine_LoadAssetGroupAsync(List<string> assetList, Action callback, bool isProgress = true)
	{
		if (assetList == null || assetList.Count == 0)
		{
			callback?.Invoke();
		}
		else
		{
			StartCoroutine(LoadAssetGroupAsync(assetList, callback, isProgress));
		}
	}

	public void StartCoroutine_LoadAssetGroupAsync(string asset, Action callback, bool isProgress = true)
	{
		StartCoroutine(LoadAssetGroupAsync(new List<string> { asset }, callback, isProgress));
	}

	public void StartCoroutine_LoadAssetGroupSync(List<string> assetList, Action callback, bool isProgress = true)
	{
		if (assetList == null || assetList.Count == 0)
		{
			callback?.Invoke();
		}
		else
		{
			StartCoroutine(LoadAssetGroupSync(assetList, callback, isProgress));
		}
	}

	public void StartCoroutine_LoadAssetGroupSync(string asset, Action callback, bool isProgress = true)
	{
		StartCoroutine(LoadAssetGroupSync(new List<string> { asset }, callback, isProgress));
	}

	public void RemoveAssetGroup(List<string> assetList)
	{
		for (int i = 0; i < assetList.Count; i++)
		{
			RemoveAsset(assetList[i]);
		}
	}

	public void RemoveAsset(string assetName)
	{
		Toolbox.AssetManager.UnloadAsset(assetName);
	}

	public void RemoveAssetForceCommon()
	{
		Toolbox.AssetManager.UnloadCommonAssetAll();
	}

	public void RemoveAssetCommon(string assetName)
	{
		Toolbox.AssetManager.UnloadCommonAsset(assetName);
	}

	public void RegistCommonAsset(List<string> assetList)
	{
		for (int i = 0; i < assetList.Count; i++)
		{
			Toolbox.AssetManager.RegistCommonAsset(assetList[i]);
		}
	}

	public void RemoveAssetForceTemporary()
	{
		Toolbox.AssetManager.UnloadTemporaryAssetAll();
	}

	public void RemoveAssetTemporary(string assetName)
	{
		Toolbox.AssetManager.UnloadTemporaryAsset(assetName);
	}

	public void RegistTemporaryAsset(string assetName)
	{
		Toolbox.AssetManager.RegistTemporaryAsset(assetName);
	}

	public bool ExistsAssetBundleManifest(string assetName)
	{
		if (Toolbox.AssetManager.GetAssetHandle(assetName) != null)
		{
			return true;
		}
		return false;
	}

	public bool CheckBeforeFileRequeset(string assetName)
	{
		return Toolbox.AssetManager.IsEnableAssetName(assetName);
	}

	public bool IsLoadedAssetBundle(string assetName)
	{
		if (Toolbox.AssetManager == null)
		{
			return false;
		}
		if (Toolbox.AssetManager.GetAssetBundleObject(assetName) != null)
		{
			return true;
		}
		return false;
	}

	public bool IsLoadedAssetBundleAndObjectArrayExist(string assetName)
	{
		if (IsLoadedAssetBundle(assetName))
		{
			return Toolbox.AssetManager.GetAssetBundleObject(assetName).objectArray.Count > 0;
		}
		return false;
	}

	public void UseAssetBundle(bool bEnabled)
	{
		useAssetBundle = bEnabled;
	}

	public bool IsUseAssetBundle()
	{
		return useAssetBundle;
	}

	public UnityEngine.Object LoadObject(string objectName, bool isServerResources = true, bool isIfFindLoad = false)
	{
		return LoadObject<UnityEngine.Object>(objectName, isServerResources);
	}

	public T LoadObject<T>(string objectName, bool isServerResources = true, bool isIfFindLoad = false) where T : UnityEngine.Object
	{
		if (!isServerResources)
		{
			return Resources.Load<T>(objectName);
		}
		AssetManager assetManager = Toolbox.AssetManager;
		if (assetManager != null)
		{
			UnityEngine.Object obj = assetManager.LoadObject(objectName, typeof(T), isIfFindLoad);
			if (obj != null)
			{
				return (T)obj;
			}
		}
		return Resources.Load<T>(objectName);
	}

	public UnityEngine.Object LoadObject(string assetName, string objectName, bool isServerResources = true)
	{
		return LoadObject<UnityEngine.Object>(assetName, objectName, isServerResources);
	}

	public T LoadObject<T>(string assetName, string objectName, bool isServerResources = true) where T : UnityEngine.Object
	{
		if (!isServerResources)
		{
			return Resources.Load<T>(objectName);
		}
		AssetManager assetManager = Toolbox.AssetManager;
		if (assetManager != null)
		{
			UnityEngine.Object obj = assetManager.LoadObject(assetName, objectName, typeof(T));
			if (obj != null)
			{
				return (T)obj;
			}
		}
		return Resources.Load<T>(objectName);
	}

	private void SetDownloadProcessLock(bool enable_lock)
	{
		downloadSemaphore = enable_lock;
	}

	private void SetLoadProcessLock(bool enable_lock)
	{
		loadSemaphore = enable_lock;
	}

	public IEnumerator GameInitialize()
	{
		Toolbox.BootNetwork.SetupNetwork();
		while (!Toolbox.BootNetwork.IsDoneGameStartCheck)
		{
			yield return 0;
		}
		yield return StartCoroutine(Toolbox.AssetManager.InitializeManifest(null, !Data.Load.data._userTutorial.NeedAllResource));
	}

	public static int calcTextureSize(int x)
	{
		return (int)(TextureScaleRatio * (float)x);
	}

	public static Vector2 calcTextureSize(Vector2 vec)
	{
		return vec * TextureScaleRatio;
	}

	public static int calcAtlasValue(int x, float rate)
	{
		return (int)(rate * (float)x + 0.5f);
	}

	public static void ResizeUISprite(UISprite _sprite)
	{
		_sprite.MakePixelPerfect();
		int w = calcTextureSize(_sprite.width);
		int h = calcTextureSize(_sprite.height);
		_sprite.SetDimensions(w, h);
	}

	public static void ResizeUISpriteSliced(UISprite _sprite)
	{
	}

	public static void resizeUIAtlas(UIAtlas atlas, GameObject parentObject, Material material = null)
	{
		if (atlas == null || atlas.replacement != null || QualityManager.GetAssetQualityLevel() != QualityManager.AssetQualityLevel.Level_1)
		{
			return;
		}
		string text = atlas.name;
		UIAtlas uIAtlas = UnityEngine.Object.Instantiate(atlas);
		uIAtlas.transform.parent = parentObject.transform;
		uIAtlas.name = text + "_half";
		atlas.replacement = uIAtlas;
		if (material != null)
		{
			uIAtlas.spriteMaterial = material;
		}
		List<UISpriteData> spriteList = uIAtlas.spriteList;
		if (spriteList != null)
		{
			for (int i = 0; i < spriteList.Count; i++)
			{
				UISpriteData uISpriteData = spriteList[i];
				int width = uISpriteData.width;
				int height = uISpriteData.height;
				uISpriteData.x = calcAtlasValue(uISpriteData.x, AtlasValueRatio);
				uISpriteData.y = calcAtlasValue(uISpriteData.y, AtlasValueRatio);
				uISpriteData.width = calcAtlasValue(uISpriteData.width, AtlasValueRatio);
				uISpriteData.height = calcAtlasValue(uISpriteData.height, AtlasValueRatio);
				uISpriteData.borderLeft = uISpriteData.width - calcAtlasValue(width - uISpriteData.borderLeft, AtlasValueRatio);
				uISpriteData.borderRight = calcAtlasValue(uISpriteData.borderRight, AtlasValueRatio);
				uISpriteData.borderTop = calcAtlasValue(uISpriteData.borderTop, AtlasValueRatio);
				uISpriteData.borderBottom = uISpriteData.height - calcAtlasValue(height - uISpriteData.borderBottom, AtlasValueRatio);
				uISpriteData.paddingLeft = calcAtlasValue(uISpriteData.paddingLeft, AtlasValueRatio);
				uISpriteData.paddingRight = calcAtlasValue(uISpriteData.paddingRight, AtlasValueRatio);
				uISpriteData.paddingTop = calcAtlasValue(uISpriteData.paddingTop, AtlasValueRatio);
				uISpriteData.paddingBottom = calcAtlasValue(uISpriteData.paddingBottom, AtlasValueRatio);
			}
		}
	}

	public void ClearLoadCount()
	{
		Toolbox.AssetManager.ResetDownloadCount();
	}

	public int GetDownLoadMax()
	{
		return Toolbox.AssetManager.GetDownloadMaxCount();
	}

	public int GetDownLoadCompleted()
	{
		return Toolbox.AssetManager.GetDownloadCurrentCount();
	}

	public float GetDownloadCompletedSize()
	{
		return Toolbox.AssetManager.GetDownloadCompletedSize();
	}

	public float GetDownloadMaxSize()
	{
		return Toolbox.AssetManager.GetDownloadSize(CustomPreference.IsNormalResource);
	}

	public int GetLoadingMax()
	{
		return Toolbox.AssetManager.GetLoadingMaxCount();
	}

	public int GetLoadingCompleted()
	{
		return Toolbox.AssetManager.GetLoadingCurrentCount();
	}
}
