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 = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CrumpHats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0+50991cf4e6a7b4d70b9a04ba60966584af1867dc")]
[assembly: AssemblyProduct("CrumpHats")]
[assembly: AssemblyTitle("CrumpHats")]
[assembly: AssemblyVersion("1.2.0.0")]
namespace CrumpHats;

[BepInPlugin("addzeey.crumphats", "Crump Hats", "1.2.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)("[Addzeey] 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)("[Addzeey] " + name + " added."));
			return true;
		}

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

	[CompilerGenerated]
	private sealed class <LoadHatsFromDisk>d__4 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		private AssetBundleCreateRequest <createRequest>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <LoadHatsFromDisk>d__4(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<createRequest>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				Debug.Log((object)"[Addzeey] Loading hats from disk.");
				string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "crumphats");
				Debug.Log((object)("[Addzeey] Path to AssetBundle: " + text));
				<createRequest>5__2 = AssetBundle.LoadFromMemoryAsync(File.ReadAllBytes(text));
				<>2__current = <createRequest>5__2;
				<>1__state = 1;
				return true;
			}
			case 1:
				<>1__state = -1;
				assetBundle = <createRequest>5__2.assetBundle;
				Debug.Log((object)"[Addzeey] AssetBundle loaded.");
				hats = new List<HatEntry>();
				hats.Add(LoadHat("plunger"));
				hats.Add(LoadHat("nae-medic"));
				hats.Add(LoadHat("crumpet-wings"));
				hats.Add(LoadHat("mango-peak"));
				hats.Add(LoadHat("nokriss-hat"));
				hats.Add(LoadHat("flow-hat"));
				hats.Add(LoadHat("sbc-crab"));
				hats.Add(LoadHat("desert-antlers"));
				hats.Add(LoadHat("mousy-tv"));
				Debug.Log((object)"[Addzeey] Done!");
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	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("addzeey.crumphats").PatchAll(typeof(Patcher));
		((MonoBehaviour)this).StartCoroutine(LoadHatsFromDisk());
	}

	[IteratorStateMachine(typeof(<LoadHatsFromDisk>d__4))]
	private static IEnumerator LoadHatsFromDisk()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <LoadHatsFromDisk>d__4(0);
	}

	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)("[Addzeey] Loading hat '" + hatName + "'."));
		GameObject val = assetBundle.LoadAsset<GameObject>("Assets/" + hatName + ".prefab");
		Texture2D val2 = assetBundle.LoadAsset<Texture2D>("Assets/" + hatName + ".png");
		Debug.Log((object)$"[Addzeey] Loaded prefab {val} and texture {val2}");
		return new HatEntry(hatName, val, val2);
	}
}