using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
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: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BigEyes")]
[assembly: AssemblyTitle("BigEyes")]
[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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 Empress.BigEyes
{
	[BepInPlugin("empress.repo.bigeyes", "Big Eyes", "1.4.1")]
	public sealed class BigEyesPlugin : BaseUnityPlugin
	{
		public const string Guid = "empress.repo.bigeyes";

		public const string Name = "Big Eyes";

		public const string Version = "1.4.1";

		internal static ManualLogSource LogS;

		internal static Harmony Harmony;

		internal static ConfigEntry<bool> C_Enable;

		internal static ConfigEntry<float> C_EyeScale;

		internal static ConfigEntry<int> C_ApplyDelayFrames;

		internal static ConfigEntry<bool> C_Debug;

		internal static ConfigEntry<float> C_MaxSearchSeconds;

		internal static ConfigEntry<bool> C_ScaleAllEyeMatches;

		internal static ConfigEntry<string> C_LeftEyeName;

		internal static ConfigEntry<string> C_RightEyeName;

		private void Awake()
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			LogS = ((BaseUnityPlugin)this).Logger;
			C_Enable = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enable", true, "Master enable for the mod.");
			C_EyeScale = ((BaseUnityPlugin)this).Config.Bind<float>("General", "EyeScale", 2f, "Uniform scale applied to eye transforms.");
			C_ApplyDelayFrames = ((BaseUnityPlugin)this).Config.Bind<int>("General", "ApplyDelayFrames", 1, "Frames to wait after PlayerAvatar.Start before applying changes.");
			C_Debug = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DebugLogs", false, "If true, prints extra search diagnostics.");
			C_MaxSearchSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("General", "MaxSearchSeconds", 5f, "How long to keep scanning hierarchy for targets before giving up.");
			C_ScaleAllEyeMatches = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ScaleAllEyeMatches", true, "Scale every transform that looks like an eye (not just L/R).");
			C_LeftEyeName = ((BaseUnityPlugin)this).Config.Bind<string>("Names", "LeftEyeName", "ANIM EYE LEFT", "Left eye Transform name (fallback).");
			C_RightEyeName = ((BaseUnityPlugin)this).Config.Bind<string>("Names", "RightEyeName", "ANIM EYE RIGHT", "Right eye Transform name (fallback).");
			Harmony = new Harmony("empress.repo.bigeyes");
			Harmony.PatchAll(typeof(Patches));
			LogS.LogInfo((object)"Big Eyes 1.4.1 loaded (eyes only).");
		}

		private void OnDestroy()
		{
			try
			{
				Harmony harmony = Harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch (Exception ex)
			{
				LogS.LogWarning((object)("Unpatch failed: " + ex.Message));
			}
		}
	}
	internal static class Util
	{
		[CompilerGenerated]
		private sealed class <EnumerateAll>d__1 : IEnumerable<Transform>, IEnumerable, IEnumerator<Transform>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Transform <>2__current;

			private int <>l__initialThreadId;

			private Transform root;

			public Transform <>3__root;

			private Stack<Transform> <stack>5__1;

			private Transform <t>5__2;

			private int <i>5__3;

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

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

			[DebuggerHidden]
			public <EnumerateAll>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)root == (Object)null)
					{
						return false;
					}
					<stack>5__1 = new Stack<Transform>();
					<stack>5__1.Push(root);
					break;
				case 1:
					<>1__state = -1;
					<i>5__3 = 0;
					while (<i>5__3 < <t>5__2.childCount)
					{
						<stack>5__1.Push(<t>5__2.GetChild(<i>5__3));
						<i>5__3++;
					}
					<t>5__2 = null;
					break;
				}
				if (<stack>5__1.Count > 0)
				{
					<t>5__2 = <stack>5__1.Pop();
					<>2__current = <t>5__2;
					<>1__state = 1;
					return true;
				}
				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();
			}

			[DebuggerHidden]
			IEnumerator<Transform> IEnumerable<Transform>.GetEnumerator()
			{
				<EnumerateAll>d__1 <EnumerateAll>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<EnumerateAll>d__ = this;
				}
				else
				{
					<EnumerateAll>d__ = new <EnumerateAll>d__1(0);
				}
				<EnumerateAll>d__.root = <>3__root;
				return <EnumerateAll>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Transform>)this).GetEnumerator();
			}
		}

		public static string Sanitize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length);
			foreach (char c in s)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
			}
			return stringBuilder.ToString();
		}

		[IteratorStateMachine(typeof(<EnumerateAll>d__1))]
		public static IEnumerable<Transform> EnumerateAll(Transform root)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateAll>d__1(-2)
			{
				<>3__root = root
			};
		}

		public static int Depth(Transform t)
		{
			int num = 0;
			Transform val = t;
			while ((Object)(object)val != (Object)null)
			{
				num++;
				val = val.parent;
			}
			return num;
		}

		public static string GetPath(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return "<null>";
			}
			Stack<string> stack = new Stack<string>();
			Transform val = t;
			while ((Object)(object)val != (Object)null)
			{
				stack.Push(((Object)val).name);
				val = val.parent;
			}
			return string.Join("/", stack.ToArray());
		}

		public static Transform PickDeepest(IList<Transform> list)
		{
			if (list == null || list.Count == 0)
			{
				return null;
			}
			Transform val = list[0];
			int num = Depth(val);
			for (int i = 1; i < list.Count; i++)
			{
				int num2 = Depth(list[i]);
				if (num2 > num)
				{
					val = list[i];
					num = num2;
				}
			}
			return val;
		}
	}
	[HarmonyPatch]
	internal static class Patches
	{
		[CompilerGenerated]
		private sealed class <ApplyRoutine>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerAvatar avatar;

			private int <delay>5__1;

			private float <timeout>5__2;

			private float <t0>5__3;

			private List<Transform> <eyes>5__4;

			private int <i>5__5;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<delay>5__1 = Mathf.Max(0, BigEyesPlugin.C_ApplyDelayFrames.Value);
					<i>5__5 = 0;
					goto IL_0074;
				case 1:
					<>1__state = -1;
					<i>5__5++;
					goto IL_0074;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0074:
					if (<i>5__5 < <delay>5__1)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<timeout>5__2 = Mathf.Max(0.1f, BigEyesPlugin.C_MaxSearchSeconds.Value);
					<t0>5__3 = Time.realtimeSinceStartup;
					<eyes>5__4 = null;
					break;
				}
				if (Time.realtimeSinceStartup - <t0>5__3 < <timeout>5__2)
				{
					if (<eyes>5__4 == null || <eyes>5__4.Count == 0)
					{
						<eyes>5__4 = ResolveEyes(avatar);
					}
					if (<eyes>5__4 == null || <eyes>5__4.Count <= 0)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
				}
				if (<eyes>5__4 != null && <eyes>5__4.Count > 0)
				{
					ScaleEyes(<eyes>5__4, BigEyesPlugin.C_EyeScale.Value);
				}
				else
				{
					BigEyesPlugin.LogS.LogWarning((object)"Eye search timed out; nothing scaled.");
				}
				Processed.Add(((Object)avatar).GetInstanceID());
				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();
			}
		}

		private static readonly HashSet<int> Processed = new HashSet<int>();

		[HarmonyPatch(typeof(PlayerAvatar), "Start")]
		[HarmonyPostfix]
		private static void PlayerAvatar_Start_Postfix(PlayerAvatar __instance)
		{
			if (BigEyesPlugin.C_Enable.Value && !((Object)(object)__instance == (Object)null))
			{
				int instanceID = ((Object)__instance).GetInstanceID();
				if (!Processed.Contains(instanceID))
				{
					((MonoBehaviour)__instance).StartCoroutine(ApplyRoutine(__instance));
				}
			}
		}

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

		private static List<Transform> ResolveEyes(PlayerAvatar avatar)
		{
			List<Transform> list = new List<Transform>(4);
			PlayerAvatarVisuals val = (((Object)(object)avatar != (Object)null) ? avatar.playerAvatarVisuals : null);
			if ((Object)(object)val == (Object)null && (Object)(object)avatar != (Object)null)
			{
				val = ((Component)avatar).GetComponentInChildren<PlayerAvatarVisuals>(true);
			}
			PlayerEyes val2 = null;
			if ((Object)(object)val != (Object)null)
			{
				val2 = (((Object)(object)val.playerEyes != (Object)null) ? val.playerEyes : ((Component)val).GetComponentInChildren<PlayerEyes>(true));
			}
			if ((Object)(object)val2 != (Object)null)
			{
				if ((Object)(object)val2.eyeLeft != (Object)null)
				{
					list.Add(val2.eyeLeft);
				}
				if ((Object)(object)val2.eyeRight != (Object)null)
				{
					list.Add(val2.eyeRight);
				}
				if (list.Count > 0)
				{
					if (BigEyesPlugin.C_Debug.Value)
					{
						for (int i = 0; i < list.Count; i++)
						{
							BigEyesPlugin.LogS.LogInfo((object)("Eyes via PlayerEyes[" + i + "] => " + Util.GetPath(list[i])));
						}
					}
					return list;
				}
			}
			Transform val3 = (((Object)(object)avatar != (Object)null) ? ((Component)avatar).transform : null);
			if ((Object)(object)val3 == (Object)null)
			{
				return list;
			}
			List<Transform> list2 = new List<Transform>();
			foreach (Transform item2 in Util.EnumerateAll(val3))
			{
				string text = Util.Sanitize(((Object)item2).name);
				if (text.Contains("eye"))
				{
					list2.Add(item2);
				}
			}
			List<Transform> list3 = new List<Transform>();
			List<Transform> list4 = new List<Transform>();
			for (int j = 0; j < list2.Count; j++)
			{
				string text2 = Util.Sanitize(((Object)list2[j]).name);
				bool flag = text2.Contains("left") || text2.EndsWith("l") || text2.Contains("_l");
				bool flag2 = text2.Contains("right") || text2.EndsWith("r") || text2.Contains("_r");
				if (flag && !flag2)
				{
					list3.Add(list2[j]);
				}
				else if (flag2 && !flag)
				{
					list4.Add(list2[j]);
				}
			}
			if (list3.Count > 0)
			{
				list.Add(Util.PickDeepest(list3));
			}
			if (list4.Count > 0)
			{
				list.Add(Util.PickDeepest(list4));
			}
			if (BigEyesPlugin.C_ScaleAllEyeMatches.Value)
			{
				for (int k = 0; k < list2.Count; k++)
				{
					Transform item = list2[k];
					if (!list.Contains(item))
					{
						list.Add(item);
					}
				}
			}
			if (BigEyesPlugin.C_Debug.Value)
			{
				for (int l = 0; l < list.Count; l++)
				{
					BigEyesPlugin.LogS.LogInfo((object)("Eye match[" + l + "] => " + Util.GetPath(list[l])));
				}
			}
			return list;
		}

		private static void ScaleEyes(List<Transform> eyes, float scale)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(0.001f, scale);
			int num2 = 0;
			for (int i = 0; i < eyes.Count; i++)
			{
				Transform val = eyes[i];
				if (!((Object)(object)val == (Object)null))
				{
					val.localScale = new Vector3(num, num, num);
					num2++;
				}
			}
			BigEyesPlugin.LogS.LogInfo((object)("Scaled " + num2 + " eye transform(s) to " + num + "."));
		}
	}
}
namespace BigEyes
{
	[BepInPlugin("Omniscye.BigEyes", "BigEyes", "1.0")]
	public class BigEyes : BaseUnityPlugin
	{
		internal static BigEyes Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
		}
	}
}