using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using UnityEngine;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("MoreCustomHats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MoreCustomHats")]
[assembly: AssemblyTitle("MoreCustomHats")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MoreCustomHats;

[BepInPlugin("monamiral.morecustomhats", "More custom hats", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	private class Patcher
	{
		private static readonly int SkinColor = Shader.PropertyToID("_SkinColor");

		private static PlayerCustomizationDummy lastModifiedDummy;

		public static bool CreateHatOption(Customization customization, string name, Texture2D icon)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (Array.Exists(customization.hats, (CustomizationOption hat) => ((Object)hat).name == name))
			{
				Debug.LogError((object)("[MonAmiral] Trying to add " + name + " a second time."));
				return false;
			}
			CustomizationOption val = ScriptableObject.CreateInstance<CustomizationOption>();
			val.color = Color.white;
			((Object)val).name = name;
			val.texture = (Texture)(object)icon;
			val.type = (Type)50;
			val.requiredAchievement = (ACHIEVEMENTTYPE)0;
			customization.hats = CollectionExtensions.AddToArray<CustomizationOption>(customization.hats, val);
			Debug.Log((object)("[MonAmiral] " + name + " added."));
			return true;
		}

		[HarmonyPatch(typeof(PassportManager), "Awake")]
		[HarmonyPostfix]
		public static void PassportManagerAwakePostfix(PassportManager __instance)
		{
			Customization component = ((Component)__instance).GetComponent<Customization>();
			Debug.Log((object)"[MonAmiral] Adding hat CustomizationOptions.");
			for (int i = 0; i < hats.Count; i++)
			{
				HatEntry hatEntry = hats[i];
				CreateHatOption(component, hatEntry.Name, hatEntry.Icon);
			}
			Debug.Log((object)"[MonAmiral] Done.");
		}

		[HarmonyPatch(typeof(CharacterCustomization), "Awake")]
		[HarmonyPostfix]
		public static void CharacterCustomizationAwakePostfix(CharacterCustomization __instance)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			Transform child = ((Component)__instance).transform.GetChild(0).GetChild(0).GetChild(0)
				.GetChild(2)
				.GetChild(0)
				.GetChild(0)
				.GetChild(1)
				.GetChild(1);
			Debug.Log((object)$"[MonAmiral] Instanciating CharacterCustomization hats as children of {__instance} / {child}.");
			for (int i = 0; i < hats.Count; i++)
			{
				HatEntry hatEntry = hats[i];
				GameObject obj = Object.Instantiate<GameObject>(hatEntry.Prefab, child.position, child.rotation, child);
				SetLayerRecursively(obj.transform, ((Component)child).gameObject.layer);
				Renderer componentInChildren = obj.GetComponentInChildren<Renderer>();
				((Component)componentInChildren).gameObject.SetActive(false);
				for (int j = 0; j < componentInChildren.materials.Length; j++)
				{
					componentInChildren.materials[j].shader = Shader.Find("W/Character");
				}
				Debug.Log((object)$"[MonAmiral] CharacterCustomization Hats[{__instance.refs.playerHats.Length}] = {hatEntry.Name}");
				__instance.refs.playerHats = CollectionExtensions.AddToArray<Renderer>(__instance.refs.playerHats, componentInChildren);
				__instance.refs.AllRenderers = CollectionExtensions.AddToArray<Renderer>(__instance.refs.AllRenderers, componentInChildren);
			}
		}

		[HarmonyPatch(typeof(PlayerCustomizationDummy), "UpdateDummy")]
		[HarmonyPrefix]
		public static void PlayerCustomizationDummyUpdateDummyPrefix(PlayerCustomizationDummy __instance)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)(object)lastModifiedDummy)
			{
				return;
			}
			lastModifiedDummy = __instance;
			Transform child = ((Component)__instance).transform.GetChild(0).GetChild(0).GetChild(0)
				.GetChild(2)
				.GetChild(0)
				.GetChild(0)
				.GetChild(1)
				.GetChild(1);
			Debug.Log((object)$"[MonAmiral] Instanciating PlayerCustomizationDummy hats as children of {__instance} / {child}.");
			for (int i = 0; i < hats.Count; i++)
			{
				HatEntry hatEntry = hats[i];
				GameObject obj = Object.Instantiate<GameObject>(hatEntry.Prefab, child.position, child.rotation, child);
				SetLayerRecursively(obj.transform, ((Component)child).gameObject.layer);
				Renderer componentInChildren = obj.GetComponentInChildren<Renderer>();
				((Component)componentInChildren).gameObject.SetActive(false);
				for (int j = 0; j < componentInChildren.materials.Length; j++)
				{
					componentInChildren.materials[j].shader = Shader.Find("W/Character");
				}
				Debug.Log((object)$"[MonAmiral] PlayerCustomizationDummy Hats[{__instance.refs.playerHats.Length}] = {hatEntry.Name}");
				__instance.refs.playerHats = CollectionExtensions.AddToArray<Renderer>(__instance.refs.playerHats, componentInChildren);
			}
		}

		[HarmonyPatch(typeof(CharacterCustomization), "OnPlayerDataChange")]
		[HarmonyPostfix]
		public static void CharacterCustomizationOnPlayerDataChangePostFix(CharacterCustomization __instance, ref PersistentPlayerData playerData)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.refs.PlayerRenderers[0] == (Object)null)
			{
				return;
			}
			int num = playerData.customizationData.currentSkin;
			if (__instance.useDebugColor)
			{
				num = __instance.debugColorIndex;
			}
			Color color = Singleton<Customization>.Instance.skins[num].color;
			for (int i = 0; i < __instance.refs.playerHats.Length; i++)
			{
				for (int j = 0; j < __instance.refs.playerHats[i].materials.Length; j++)
				{
					__instance.refs.playerHats[i].materials[j].SetColor(SkinColor, color);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerCustomizationDummy), "SetPlayerColor")]
		[HarmonyPostfix]
		public static void PlayerCustomizationDummySetPlayerColorPostFix(PlayerCustomizationDummy __instance, ref int index)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (index > Singleton<Customization>.Instance.skins.Length)
			{
				return;
			}
			Color color = Singleton<Customization>.Instance.skins[index].color;
			for (int i = 0; i < __instance.refs.playerHats.Length; i++)
			{
				for (int j = 0; j < __instance.refs.playerHats[i].materials.Length; j++)
				{
					__instance.refs.playerHats[i].materials[j].SetColor(SkinColor, color);
				}
			}
		}
	}

	public struct HatEntry
	{
		public string Name;

		public GameObject Prefab;

		public Texture2D Icon;

		public HatEntry(string name, GameObject prefab, Texture2D icon)
		{
			Name = name;
			Prefab = prefab;
			Icon = icon;
		}
	}

	public static AssetBundle assetBundle;

	public static List<HatEntry> hats;

	public void Awake()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		new Harmony("monamiral.morecustomhats").PatchAll(typeof(Patcher));
		((MonoBehaviour)this).StartCoroutine(LoadHatsFromDisk());
	}

	private static IEnumerator LoadHatsFromDisk()
	{
		Debug.Log((object)"[MonAmiral] Loading hats from disk.");
		string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "morecustomhats");
		Debug.Log((object)("[MonAmiral] Path to AssetBundle: " + text));
		AssetBundleCreateRequest createRequest = AssetBundle.LoadFromMemoryAsync(File.ReadAllBytes(text));
		yield return createRequest;
		assetBundle = createRequest.assetBundle;
		Debug.Log((object)"[MonAmiral] AssetBundle loaded.");
		hats = new List<HatEntry>();
		hats.Add(LoadHat("Chibidoki/chibidoki"));
		hats.Add(LoadHat("Timmy/timmyrobot"));
		hats.Add(LoadHat("Cigarette/cigarette"));
		hats.Add(LoadHat("Cigarette/cigaretteweed"));
		hats.Add(LoadHat("BuzzBall/buzzBall"));
		hats.Add(LoadHat("Gecko/gecko"));
		hats.Add(LoadHat("Fruits/applegreen"));
		hats.Add(LoadHat("Fruits/appleyellow"));
		hats.Add(LoadHat("Fruits/applered"));
		hats.Add(LoadHat("Fruits/pepperred"));
		hats.Add(LoadHat("Fruits/banana"));
		hats.Add(LoadHat("HockeyMask/hockeymask"));
		hats.Add(LoadHat("arrow/arrow"));
		hats.Add(LoadHat("DUM/dum"));
		hats.Add(LoadHat("ExtraHead/extrahead"));
		hats.Add(LoadHat("Bombzyz/reddhmis"));
		hats.Add(LoadHat("Bombzyz/yellowdhmis"));
		hats.Add(LoadHat("Bombzyz/duckdhmis"));
		hats.Add(LoadHat("Tobs/tobs"));
		hats.Add(LoadHat("Lyn/Lyn"));
		hats.Add(LoadHat("CurryPaws/CurryPaws"));
		hats.Add(LoadHat("MonAmiral/MonAmiral"));
		hats.Add(LoadHat("Deme/Deme"));
		hats.Add(LoadHat("CharborgPlush/CharborgPlush"));
		hats.Add(LoadHat("Chirpling/Chirpling"));
		hats.Add(LoadHat("PocketWaifu/FaceBunnySnout"));
		hats.Add(LoadHat("PocketWaifu/FaceMamavale"));
		hats.Add(LoadHat("PocketWaifu/FacePixelGlasses"));
		hats.Add(LoadHat("PocketWaifu/HatBear"));
		hats.Add(LoadHat("PocketWaifu/HatBeer"));
		hats.Add(LoadHat("PocketWaifu/HatBeret"));
		hats.Add(LoadHat("PocketWaifu/HatBow"));
		hats.Add(LoadHat("PocketWaifu/HatBread"));
		hats.Add(LoadHat("PocketWaifu/HatBucket"));
		hats.Add(LoadHat("PocketWaifu/HatChickEgg"));
		hats.Add(LoadHat("PocketWaifu/HatCloak"));
		hats.Add(LoadHat("PocketWaifu/HatCowboyLarge"));
		hats.Add(LoadHat("PocketWaifu/HatCowboySmall"));
		hats.Add(LoadHat("PocketWaifu/HatCrown"));
		hats.Add(LoadHat("PocketWaifu/HatFishFearMe"));
		hats.Add(LoadHat("PocketWaifu/HatFlower"));
		hats.Add(LoadHat("PocketWaifu/HatHeadphones"));
		hats.Add(LoadHat("PocketWaifu/HatPetalPal"));
		hats.Add(LoadHat("PocketWaifu/HatPetalPalBaby"));
		hats.Add(LoadHat("PocketWaifu/HatPirate"));
		hats.Add(LoadHat("PocketWaifu/HatPolice"));
		hats.Add(LoadHat("PocketWaifu/HatPombeanie"));
		hats.Add(LoadHat("PocketWaifu/HatSummerHat"));
		Debug.Log((object)"[MonAmiral] Done!");
	}

	private static void SetLayerRecursively(Transform transform, int layer)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Expected O, but got Unknown
		((Component)transform).gameObject.layer = layer;
		foreach (Transform item in transform)
		{
			SetLayerRecursively(item, layer);
		}
	}

	private static HatEntry LoadHat(string hatName)
	{
		Debug.Log((object)("[MonAmiral] Loading hat '" + hatName + "'."));
		GameObject val = assetBundle.LoadAsset<GameObject>("Assets/" + hatName + ".prefab");
		Texture2D val2 = assetBundle.LoadAsset<Texture2D>("Assets/" + hatName + ".png");
		Debug.Log((object)$"[MonAmiral] Loaded prefab {val} and texture {val2}");
		return new HatEntry(hatName, val, val2);
	}
}