using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players;
using Il2CppRUMBLE.Utilities;
using Il2CppSystem.Collections.Generic;
using MelonLoader;
using RumbleModUI;
using RumblePlayerOutlines;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Class1), "RumblePlayerOutlines", "1.1.0", "Evelyn", null)]
[assembly: MelonGame(null, null)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("RumblePlayerOutlines")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+503b935d86b1a67bf229b9de9c906bebab399b75")]
[assembly: AssemblyProduct("RumblePlayerOutlines")]
[assembly: AssemblyTitle("RumblePlayerOutlines")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RumblePlayerOutlines
{
	public static class ModInfo
	{
		public const string Name = "RumblePlayerOutlines";

		public const string Description = "adds outlines to other players";

		public const string Author = "Evelyn";

		public const string Version = "1.1.0";
	}
	public class Class1 : MelonMod
	{
		public static Class1 instance;

		public Shader unlitShader;

		private Mod RumblePlayerOutlines = new Mod();

		private ModSetting<int> outlineSize;

		private ModSetting<bool> outlineEnabled;

		public override void OnLateInitializeMelon()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			instance = this;
			unlitShader = Shader.Find("Universal Render Pipeline/Unlit");
			RumblePlayerOutlines.ModName = "RumblePlayerOutlines";
			RumblePlayerOutlines.ModVersion = "1.1.0";
			RumblePlayerOutlines.SetFolder("RumblePlayerOutlines");
			outlineEnabled = RumblePlayerOutlines.AddToList("Toggle outlines", true, 0, "Toggles the outlines on players", new Tags());
			outlineSize = RumblePlayerOutlines.AddToList("Outline Size", 5, "How big the outlines are", new Tags());
			RumblePlayerOutlines.GetFromFile();
			RumblePlayerOutlines.ModSaved += OnModUISaved;
			UI.instance.UI_Initialized += delegate
			{
				UI.instance.AddMod(RumblePlayerOutlines);
			};
		}

		public void OnModUISaved()
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<Player> enumerator = Singleton<PlayerManager>.instance.AllPlayers.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Player current = enumerator.Current;
				Transform parent = FindChildByName(((Component)current.Controller).transform, "Visuals");
				Transform val = FindChildByName(parent, "Outline");
				((Component)val).gameObject.SetActive((bool)((ModSetting)outlineEnabled).Value);
				foreach (Transform item in (Il2CppArrayBase<Transform>)(object)((Component)val).GetComponent<SkinnedMeshRenderer>().bones)
				{
					if (item.localScale != Vector3.zero)
					{
						item.localScale = Vector3.one * GetOutlineSize();
					}
				}
			}
		}

		public IEnumerator CreatePlayerOutline(PlayerController player)
		{
			MelonLogger.Msg("trying to create outline on player " + player.assignedPlayer.Data.GeneralData.PublicUsername);
			yield return (object)new WaitForSeconds(1f);
			Transform visuals = FindChildByName(((Component)player).transform, "Visuals");
			SkinnedMeshRenderer originalRenderer = ((Component)FindChildByName(visuals, "Renderer")).GetComponent<SkinnedMeshRenderer>();
			GameObject outline = new GameObject("Outline");
			outline.transform.SetParent(visuals);
			outline.transform.localPosition = Vector3.zero;
			outline.transform.localRotation = Quaternion.identity;
			SkinnedMeshRenderer outlineRenderer = outline.AddComponent<SkinnedMeshRenderer>();
			outlineRenderer.sharedMesh = originalRenderer.sharedMesh;
			((Renderer)outlineRenderer).material = Object.Instantiate<Material>(((Renderer)originalRenderer).material);
			((Renderer)outlineRenderer).sharedMaterial = Object.Instantiate<Material>(((Renderer)originalRenderer).sharedMaterial);
			visuals.GetChild(1);
			Transform[] outlineBones = DuplicateBones(Il2CppArrayBase<Transform>.op_Implicit((Il2CppArrayBase<Transform>)(object)originalRenderer.bones));
			outlineRenderer.bones = Il2CppReferenceArray<Transform>.op_Implicit(outlineBones);
			outlineRenderer.rootBone = outlineBones[IndexOf(outlineBones, ((Object)originalRenderer.rootBone).name + "_Outline")];
			((Renderer)outlineRenderer).material.shader = unlitShader;
			((Renderer)outlineRenderer).material.color = Color.black;
			((Renderer)outlineRenderer).material.SetFloat("_Cull", 1f);
			((Renderer)outlineRenderer).sharedMaterial.shader = unlitShader;
			((Renderer)outlineRenderer).sharedMaterial.color = Color.black;
			((Renderer)outlineRenderer).sharedMaterial.SetFloat("_Cull", 1f);
			string[] namesToCheck = new string[11]
			{
				"mouth", "face", "brow", "eye", "nose", "nazal", "head", "jaw", "lip", "hair",
				"tail"
			};
			if ((int)player.controllerType == 1)
			{
				Transform chestBone = ((Il2CppArrayBase<Transform>)(object)outlineRenderer.bones)[IndexOf(Il2CppArrayBase<Transform>.op_Implicit((Il2CppArrayBase<Transform>)(object)outlineRenderer.bones), "Bone_Chest_Outline")];
				yield return (object)new WaitForFixedUpdate();
				yield return (object)new WaitForFixedUpdate();
				yield return (object)new WaitForFixedUpdate();
				for (int i = 0; i < ((Il2CppArrayBase<Transform>)(object)outlineRenderer.bones).Length; i++)
				{
					string name = ((Object)((Il2CppArrayBase<Transform>)(object)outlineRenderer.bones)[i]).name.ToLower();
					string[] array = namesToCheck;
					foreach (string nameToCheck in array)
					{
						if (name.Contains(nameToCheck))
						{
							((Il2CppArrayBase<Transform>)(object)outlineRenderer.bones)[i].localScale = Vector3.zero;
							((Il2CppArrayBase<Transform>)(object)outlineRenderer.bones)[i].position = chestBone.position;
							break;
						}
					}
				}
			}
			MelonLogger.Msg("successfully created an outline for player " + player.assignedPlayer.Data.GeneralData.PublicUsername);
		}

		public Transform[] DuplicateBones(Transform[] bonesTarget)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			Transform[] array = (Transform[])(object)new Transform[bonesTarget.Length];
			for (int i = 0; i < bonesTarget.Length; i++)
			{
				array[i] = Object.Instantiate<Transform>(bonesTarget[i], bonesTarget[i]);
				AnnihilateChildren(array[i]);
				array[i].localPosition = Vector3.zero;
				array[i].localRotation = Quaternion.identity;
				array[i].localScale = Vector3.one * GetOutlineSize();
				((Object)array[i]).name = ((Object)bonesTarget[i]).name + "_Outline";
			}
			return array;
		}

		public int IndexOf(Transform[] array, string name)
		{
			for (int i = 0; i < array.Length; i++)
			{
				if (((Object)array[i]).name == name)
				{
					return i;
				}
			}
			return -1;
		}

		public void AnnihilateChildren(Transform obj)
		{
			for (int num = obj.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)obj.GetChild(num)).gameObject);
			}
		}

		public Transform FindChildByName(Transform parent, string name)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				if (((Object)parent.GetChild(i)).name == name)
				{
					return parent.GetChild(i);
				}
			}
			return null;
		}

		public float GetOutlineSize()
		{
			return 1f + (float)(int)((ModSetting)outlineSize).Value / 100f;
		}
	}
}
namespace RumblePlayerOutlines.Patches
{
	[HarmonyPatch(typeof(PlayerController), "Initialize", new Type[] { typeof(Player) })]
	public static class PlayerSpawnPatch
	{
		private static void Postfix(ref PlayerController __instance, ref Player player)
		{
			MelonCoroutines.Start(Class1.instance.CreatePlayerOutline(__instance));
		}
	}
}