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;

[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("TetraCustomHats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TetraCustomHats")]
[assembly: AssemblyTitle("TetraCustomHats")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MoreCustomHats;

[BepInPlugin("tetra-byte.tetracustomhats", "Tetra's Custom Hats!", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	private class Patcher
	{
		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)("[tetra-byte] 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)("[tetra-byte] " + name + " added."));
			return true;
		}

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

		[HarmonyPatch(typeof(CharacterCustomization), "Awake")]
		[HarmonyPostfix]
		public static void CharacterCustomizationAwakePostfix(CharacterCustomization __instance)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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)$"[tetra-byte] Instanciating hats as children of {child}.");
			for (int i = 0; i < hats.Count; i++)
			{
				Renderer componentInChildren = Object.Instantiate<GameObject>(hats[i].Prefab, child.position, child.rotation, child).GetComponentInChildren<Renderer>();
				((Component)componentInChildren).gameObject.SetActive(false);
				componentInChildren.material.shader = Shader.Find("W/Character");
				__instance.refs.playerHats = CollectionExtensions.AddToArray<Renderer>(__instance.refs.playerHats, componentInChildren);
			}
		}
	}

	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)"[tetra-byte] Loading hats from disk.");
				string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "tetracustomhats");
				Debug.Log((object)("[tetra-byte] 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)"[tetra-byte] AssetBundle loaded.");
				hats = new List<HatEntry>();
				hats.Add(LoadHat("tetra"));
				hats.Add(LoadHat("vale"));
				hats.Add(LoadHat("kupo"));
				hats.Add(LoadHat("bree"));
				hats.Add(LoadHat("krix"));
				hats.Add(LoadHat("suno"));
				Debug.Log((object)"[tetra-byte] 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("tetra-byte.tetracustomhats").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 HatEntry LoadHat(string hatName)
	{
		Debug.Log((object)("[tetra-byte] Loading hat '" + hatName + "'."));
		GameObject val = assetBundle.LoadAsset<GameObject>("Assets/" + hatName + ".prefab");
		Texture2D val2 = assetBundle.LoadAsset<Texture2D>("Assets/" + hatName + ".png");
		Debug.Log((object)$"[tetra-byte] Loaded prefab {val} and texture {val2}");
		return new HatEntry(hatName, val, val2);
	}
}