using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MoreCompany.Cosmetics;
using TooManyEmotes.Patches;
using TooManyEmotes.UI;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ExtendedCosmetics")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("MelanieMelicious")]
[assembly: AssemblyProduct("Extended Cosmetics")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 MelMelExtendedCosmetics
{
	[Serializable]
	public class CosmeticType
	{
		public GameObject cosmetic;

		public CosmeticTypes cosmeticType;

		public string typeByPathToBone;

		public bool rigSkinnedMeshWithPlayer;

		public CosmeticCondition condition;

		public bool syncVisible = true;
	}
	public enum CosmeticTypes
	{
		Head,
		Chest,
		Waist,
		Hip,
		L_Shoulder,
		L_Upper_Arm,
		L_Lower_Arm,
		L_Hand,
		L_Thigh,
		L_Shin,
		L_Foot,
		R_Shoulder,
		R_Upper_Arm,
		R_Lower_Arm,
		R_Hand,
		R_Thigh,
		R_Shin,
		R_Foot,
		Base,
		Other
	}
	public enum CosmeticCondition
	{
		Any,
		Alive,
		Dead,
		Masked
	}
	internal class HarmonyPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(CosmeticApplication), "Awake")]
		private static void AddMelMelCosmeticManager(CosmeticApplication __instance)
		{
			((Component)__instance).gameObject.AddComponent<MelMelCosmeticManager>();
		}
	}
	public class MelMelCosmetic : MonoBehaviour
	{
		public CosmeticType[] cosmetics;

		public bool hidePlayerModel;

		internal static List<MelMelCosmetic> spawnedCosmetics = new List<MelMelCosmetic>();

		private MelMelCosmeticManager manager;

		private void Start()
		{
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			spawnedCosmetics.Add(this);
			manager = ((Component)this).GetComponentInParent<MelMelCosmeticManager>();
			SkinnedMeshRenderer val = default(SkinnedMeshRenderer);
			SkinnedMeshRenderer val2 = default(SkinnedMeshRenderer);
			for (int i = 0; i < cosmetics.Length; i++)
			{
				if (cosmetics[i].condition != CosmeticCondition.Any && ((cosmetics[i].condition == CosmeticCondition.Alive && (((Component)manager).gameObject.layer == 19 || ((Component)manager).gameObject.layer == 20)) || (cosmetics[i].condition == CosmeticCondition.Dead && ((Component)manager).gameObject.layer != 20) || (cosmetics[i].condition == CosmeticCondition.Masked && ((Component)manager).gameObject.layer != 19)))
				{
					cosmetics[i].cosmetic.SetActive(false);
					continue;
				}
				if (cosmetics[i].typeByPathToBone != string.Empty && (Object)(object)manager.spine != (Object)null && !((Object)(object)manager.spine.Find(cosmetics[i].typeByPathToBone) == (Object)null))
				{
					cosmetics[i].cosmetic.transform.SetParent(manager.spine.Find(cosmetics[i].typeByPathToBone));
					if (cosmetics[i].rigSkinnedMeshWithPlayer && !((Object)(object)manager.LOD1 == (Object)null) && ((Component)manager.LOD1).TryGetComponent<SkinnedMeshRenderer>(ref val))
					{
						SkinnedMeshRenderer componentInChildren = cosmetics[i].cosmetic.GetComponentInChildren<SkinnedMeshRenderer>();
						componentInChildren.rootBone = cosmetics[i].cosmetic.transform.parent;
						componentInChildren.bones = ((Component)manager.LOD1).GetComponent<SkinnedMeshRenderer>().bones;
					}
				}
				else
				{
					if (cosmetics[i].cosmeticType == CosmeticTypes.Other || (Object)(object)manager.cosmeticPoint[(int)cosmetics[i].cosmeticType] == (Object)null)
					{
						cosmetics[i].cosmetic.SetActive(false);
						continue;
					}
					cosmetics[i].cosmetic.transform.SetParent(manager.cosmeticPoint[(int)cosmetics[i].cosmeticType]);
					if (cosmetics[i].rigSkinnedMeshWithPlayer && !((Object)(object)manager.LOD1 == (Object)null) && ((Component)manager.LOD1).TryGetComponent<SkinnedMeshRenderer>(ref val2))
					{
						SkinnedMeshRenderer componentInChildren2 = cosmetics[i].cosmetic.GetComponentInChildren<SkinnedMeshRenderer>();
						componentInChildren2.rootBone = cosmetics[i].cosmetic.transform.parent;
						componentInChildren2.bones = val2.bones;
					}
				}
				cosmetics[i].cosmetic.transform.localPosition = Vector3.zero;
				cosmetics[i].cosmetic.transform.localRotation = Quaternion.identity;
				cosmetics[i].cosmetic.transform.localScale = Vector3.one;
			}
			if (hidePlayerModel)
			{
				SkinnedMeshRenderer val3 = default(SkinnedMeshRenderer);
				if (!((Object)(object)manager.LOD1 == (Object)null) && ((Component)manager.LOD1).TryGetComponent<SkinnedMeshRenderer>(ref val3))
				{
					((Renderer)val3).enabled = false;
				}
				if (!((Object)(object)manager.LOD2 == (Object)null) && ((Component)manager.LOD2).TryGetComponent<SkinnedMeshRenderer>(ref val3))
				{
					((Renderer)val3).enabled = false;
				}
				if (!((Object)(object)manager.LOD3 == (Object)null) && ((Component)manager.LOD3).TryGetComponent<SkinnedMeshRenderer>(ref val3))
				{
					((Renderer)val3).enabled = false;
				}
			}
		}

		private void OnDestroy()
		{
			spawnedCosmetics.Remove(this);
			CosmeticType[] array = cosmetics;
			foreach (CosmeticType cosmeticType in array)
			{
				Object.Destroy((Object)(object)cosmeticType.cosmetic);
			}
			if (hidePlayerModel && !((Object)(object)manager == (Object)null))
			{
				SkinnedMeshRenderer val = default(SkinnedMeshRenderer);
				if (!((Object)(object)manager.LOD1 == (Object)null) && ((Component)manager.LOD1).TryGetComponent<SkinnedMeshRenderer>(ref val))
				{
					((Renderer)val).enabled = true;
				}
				if (!((Object)(object)manager.LOD2 == (Object)null) && ((Component)manager.LOD2).TryGetComponent<SkinnedMeshRenderer>(ref val))
				{
					((Renderer)val).enabled = true;
				}
				if (!((Object)(object)manager.LOD3 == (Object)null) && ((Component)manager.LOD3).TryGetComponent<SkinnedMeshRenderer>(ref val))
				{
					((Renderer)val).enabled = true;
				}
			}
		}
	}
	public class MelMelCosmeticManager : MonoBehaviour
	{
		internal Transform spine;

		internal Transform[] cosmeticPoint = (Transform[])(object)new Transform[20];

		internal Transform LOD1;

		internal Transform LOD2;

		internal Transform LOD3;

		private void Awake()
		{
			spine = ((Component)this).transform.Find("spine");
			if ((Object)(object)spine == (Object)null)
			{
				spine = ((Component)this).transform;
				LOD1 = ((Component)this).transform;
			}
			else
			{
				LOD1 = ((Component)this).transform.parent.Find("LOD1");
				LOD2 = ((Component)this).transform.parent.Find("LOD2");
				LOD3 = ((Component)this).transform.parent.Find("LOD3");
			}
			cosmeticPoint[3] = spine.Find("spine.001");
			cosmeticPoint[2] = cosmeticPoint[3].Find("spine.002");
			cosmeticPoint[1] = cosmeticPoint[2].Find("spine.003");
			cosmeticPoint[0] = cosmeticPoint[1].Find("spine.004");
			cosmeticPoint[4] = cosmeticPoint[1].Find("shoulder.L");
			cosmeticPoint[5] = cosmeticPoint[4].Find("arm.L_upper");
			cosmeticPoint[6] = cosmeticPoint[5].Find("arm.L_lower");
			cosmeticPoint[7] = cosmeticPoint[6].Find("hand.L");
			cosmeticPoint[8] = spine.Find("thigh.L");
			cosmeticPoint[9] = cosmeticPoint[8].Find("shin.L");
			cosmeticPoint[10] = cosmeticPoint[9].Find("foot.L");
			cosmeticPoint[11] = cosmeticPoint[1].Find("shoulder.R");
			cosmeticPoint[12] = cosmeticPoint[11].Find("arm.R_upper");
			cosmeticPoint[13] = cosmeticPoint[12].Find("arm.R_lower");
			cosmeticPoint[14] = cosmeticPoint[13].Find("hand.R");
			cosmeticPoint[15] = spine.Find("thigh.R");
			cosmeticPoint[16] = cosmeticPoint[15].Find("shin.R");
			cosmeticPoint[17] = cosmeticPoint[16].Find("foot.R");
			cosmeticPoint[18] = spine;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("MelanieMelicious.ExtendedCosmetics", "Melanie Melicious - Extended Cosmetics", "1.1.0")]
	internal class Plugin : BaseUnityPlugin
	{
		private const string GUID = "MelanieMelicious.ExtendedCosmetics";

		private const string NAME = "Melanie Melicious - Extended Cosmetics";

		private const string VERSION = "1.1.0";

		private readonly Harmony harmony = new Harmony("MelanieMelicious.ExtendedCosmetics");

		internal static ManualLogSource mls;

		private void Awake()
		{
			mls = Logger.CreateLogSource("MelanieMelicious - Pocket Room Library");
			mls = ((BaseUnityPlugin)this).Logger;
			harmony.PatchAll(typeof(HarmonyPatches));
			if (Chainloader.PluginInfos.ContainsKey("FlipMods.TooManyEmotes"))
			{
				harmony.PatchAll(typeof(TooManyEmotePatch));
			}
		}
	}
	internal class TooManyEmotePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(ThirdPersonEmoteController), "OnStartCustomEmoteLocal")]
		private static void StartEmotePatch()
		{
			LayerChange();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ThirdPersonEmoteController), "OnStopCustomEmoteLocal")]
		private static void StopEmotePatch()
		{
			LayerChange();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AnimationPreviewer), "InitializePlayerCloneRenderObject")]
		private static void PlayerClonePatch()
		{
			LayerChange();
		}

		private static void LayerChange()
		{
			if (ThirdPersonEmoteController.firstPersonEmotesEnabled)
			{
				return;
			}
			for (int i = 0; i < MelMelCosmetic.spawnedCosmetics.Count; i++)
			{
				int layer = ((Component)MelMelCosmetic.spawnedCosmetics[i]).gameObject.layer;
				CosmeticType[] cosmetics = MelMelCosmetic.spawnedCosmetics[i].cosmetics;
				foreach (CosmeticType cosmeticType in cosmetics)
				{
					if (cosmeticType.syncVisible)
					{
						Transform[] componentsInChildren = cosmeticType.cosmetic.GetComponentsInChildren<Transform>();
						foreach (Transform val in componentsInChildren)
						{
							((Component)val).gameObject.layer = layer;
						}
					}
				}
			}
		}
	}
}