using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("UltraFumos")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Replaces various Ultrakill things with fumos")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+408f5de5849d4781f958b6a5cbea2c492ae0f3b4")]
[assembly: AssemblyProduct("UltraFumos")]
[assembly: AssemblyTitle("UltraFumos")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FumoSkull
{
	[BepInPlugin("UltraFumosTeam.UltraFumos", "UltraFumos", "1.2")]
	public class FumoSkulls : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Skull), "Awake")]
		public static class FumofiySkull
		{
			public static void Postfix(Skull __instance)
			{
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Invalid comparison between Unknown and I4
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Invalid comparison between Unknown and I4
				ModifyMaterial value;
				try
				{
					value = Traverse.Create((object)__instance).Field<ModifyMaterial>("mod").Value;
				}
				catch (Exception ex)
				{
					Debug.LogError((object)$"Failed to get `mod` field of skull: {ex.GetType()} {ex.Message}");
					return;
				}
				Renderer value2;
				try
				{
					Traverse val = Traverse.Create((object)value);
					val.Method("SetValues", Array.Empty<object>()).GetValue();
					value2 = val.Field<Renderer>("rend").Value;
				}
				catch (Exception ex2)
				{
					Debug.LogError((object)$"Failed to get `rend` field of modifyMaterial: {ex2.GetType()} {ex2.Message}");
					return;
				}
				if (Object.op_Implicit((Object)(object)value2))
				{
					ItemType itemType = ((Component)__instance).GetComponent<ItemIdentifier>().itemType;
					ItemType val2 = itemType;
					string fumoType;
					Vector3 position = default(Vector3);
					if ((int)val2 != 1)
					{
						if ((int)val2 != 2)
						{
							return;
						}
						fumoType = "Reimu";
						((Vector3)(ref position))..ctor(-0.015f, 0f, 0.15f);
					}
					else
					{
						fumoType = "Cirno";
						((Vector3)(ref position))..ctor(0.05f, 0.03f, 0.1f);
					}
					value2.enabled = false;
					CreateFumo(fumoType, ((Component)value2).transform, position, Quaternion.Euler(15f, 0f, 270f), new Vector3(0.8f, 0.8f, 0.8f), value2.material.shader);
				}
				else
				{
					Debug.LogWarning((object)"renderer was null");
				}
			}
		}

		[HarmonyPatch(typeof(Grenade), "Awake")]
		public static class FumofiyRocket
		{
			public static void Postfix(Grenade __instance)
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				Renderer[] componentsInChildren = (Renderer[])(object)((Component)__instance).gameObject.GetComponentsInChildren<MeshRenderer>();
				Renderer[] array = componentsInChildren;
				if (array.Length != 0 && __instance.rocket)
				{
					for (int i = 0; i < array.Length; i++)
					{
						array[i].enabled = false;
					}
					CreateFumo("Sakuya", ((Component)__instance).transform, new Vector3(0f, 0f, 2f), Quaternion.Euler(0f, 0f, 90f), new Vector3(10f, 10f, 10f), array[0].material.shader);
				}
			}
		}

		[HarmonyPatch(typeof(Torch), "Start")]
		public static class FumofiyTorch
		{
			public static void Prefix(Torch __instance)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				Renderer componentInChildren = (Renderer)(object)((Component)__instance).gameObject.GetComponentInChildren<MeshRenderer>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.enabled = false;
					CreateFumo("YuYu", ((Component)((Component)componentInChildren).transform.parent).transform, new Vector3(0f, 0.1f, 0f), Quaternion.Euler(270f, 270f, 0f), new Vector3(1f, 1f, 1f) * 2.75f, componentInChildren.material.shader);
				}
			}
		}

		[HarmonyPatch(typeof(Soap), "Start")]
		public static class FumofiySoap
		{
			public static void Prefix(Soap __instance)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				Renderer componentInChildren = (Renderer)(object)((Component)__instance).gameObject.GetComponentInChildren<MeshRenderer>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.enabled = false;
					CreateFumo("Koishi", ((Component)((Component)componentInChildren).transform.parent).transform, new Vector3(0f, 0.1f, 0f), Quaternion.Euler(270f, 270f, 0f), new Vector3(1f, 1f, 1f) * 2.75f, componentInChildren.material.shader);
				}
			}
		}

		public static Dictionary<string, GameObject> allFumos = new Dictionary<string, GameObject>();

		private Harmony fumo;

		public static AssetBundle fumoBundle;

		private void Awake()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			Stream manifestResourceStream = typeof(FumoSkulls).Assembly.GetManifestResourceStream("fumoskulls");
			fumoBundle = AssetBundle.LoadFromStream(manifestResourceStream);
			fumoBundle.LoadAllAssets();
			fumo = new Harmony("UltraFumosTeam.UltraFumos");
			fumo.PatchAll();
			allFumos.Add("Cirno", fumoBundle.LoadAsset<GameObject>("CirnoGO"));
			allFumos.Add("Reimu", fumoBundle.LoadAsset<GameObject>("ReimuGO"));
			allFumos.Add("YuYu", fumoBundle.LoadAsset<GameObject>("YuYuGO"));
			allFumos.Add("Koishi", fumoBundle.LoadAsset<GameObject>("KoishiGO"));
			allFumos.Add("Sakuya", fumoBundle.LoadAsset<GameObject>("SakuyaGO"));
		}

		public static void CreateFumo(string fumoType, Transform masterSkull, Vector3 position, Quaternion rotation, Vector3 scale, Shader shader)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)("Swapping " + ((Object)masterSkull).name + " to " + fumoType));
			GameObject val = allFumos[fumoType];
			GameObject val2 = Object.Instantiate<GameObject>(val, masterSkull);
			val2.SetActive(true);
			val2.transform.localRotation = rotation;
			val2.transform.localPosition = position;
			val2.transform.localScale = scale;
			Renderer[] componentsInChildren = val2.GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val3 in array)
			{
				Material[] materials = val3.materials;
				Material[] array2 = materials;
				foreach (Material val4 in array2)
				{
					val4.shader = shader;
				}
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "UltraFumos";

		public const string PLUGIN_NAME = "UltraFumos";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}