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 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("REPOJP")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("zabuMod")]
[assembly: AssemblyTitle("zabuMod")]
[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 REPOJP.AutoMuteOn
{
	[BepInPlugin("REPOJP.AutoMuteOn", "AutoMuteOn", "4.0.0")]
	public sealed class AutoMuteOnPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <CoApplyAfterLevelGenerated>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string reason;

			public AutoMuteOnPlugin <>4__this;

			private float <delay>5__1;

			private int <retryCount>5__2;

			private float <retryInterval>5__3;

			private int <i>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Expected O, but got Unknown
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<delay>5__1 = 1f;
					try
					{
						<delay>5__1 = Mathf.Clamp(ApplyDelaySeconds.Value, 0f, 10f);
					}
					catch
					{
						<delay>5__1 = 1f;
					}
					if (<delay>5__1 > 0f)
					{
						<>2__current = (object)new WaitForSeconds(<delay>5__1);
						<>1__state = 1;
						return true;
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_00d0;
				case 2:
					<>1__state = -1;
					goto IL_00d0;
				case 3:
					<>1__state = -1;
					goto IL_01f5;
				case 4:
					{
						<>1__state = -1;
						goto IL_01f5;
					}
					IL_01f5:
					<i>5__4++;
					break;
					IL_00d0:
					<retryCount>5__2 = 20;
					<retryInterval>5__3 = 0.5f;
					try
					{
						<retryCount>5__2 = Mathf.Clamp(ApplyRetryCount.Value, 1, 120);
					}
					catch
					{
						<retryCount>5__2 = 20;
					}
					try
					{
						<retryInterval>5__3 = Mathf.Clamp(ApplyRetryIntervalSeconds.Value, 0.1f, 5f);
					}
					catch
					{
						<retryInterval>5__3 = 0.5f;
					}
					<i>5__4 = 0;
					break;
				}
				if (<i>5__4 < <retryCount>5__2 && ModEnabled != null && ModEnabled.Value)
				{
					if (!IsReadyForMainProcess())
					{
						<>2__current = (object)new WaitForSeconds(<retryInterval>5__3);
						<>1__state = 3;
						return true;
					}
					if (!TrySetToggleMute(value: true))
					{
						<>2__current = (object)new WaitForSeconds(<retryInterval>5__3);
						<>1__state = 4;
						return true;
					}
					WriteInfo("Auto mute applied reason=" + reason + " retry=" + <i>5__4);
				}
				<>4__this.applyCoroutine = null;
				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 const string PluginGuid = "REPOJP.AutoMuteOn";

		public const string PluginName = "AutoMuteOn";

		public const string PluginVersion = "4.0.0";

		internal static AutoMuteOnPlugin Instance;

		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> ModEnabled;

		internal static ConfigEntry<float> ApplyDelaySeconds;

		internal static ConfigEntry<int> ApplyRetryCount;

		internal static ConfigEntry<float> ApplyRetryIntervalSeconds;

		internal static ConfigEntry<bool> EnableLog;

		private Harmony harmony;

		private Coroutine applyCoroutine;

		private static FieldInfo toggleMuteField;

		private void Awake()
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			try
			{
				((Component)this).transform.parent = null;
				((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failure: Persist setup\n" + ex));
			}
			ModEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable this mod. このMODを有効化");
			ApplyDelaySeconds = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ApplyDelaySeconds", 1f, new ConfigDescription("Delay after level generation before applying toggle mute. レベル生成後にトグルミュートを適用するまでの待機秒数", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			ApplyRetryCount = ((BaseUnityPlugin)this).Config.Bind<int>("General", "ApplyRetryCount", 20, new ConfigDescription("Retry count after level generation. レベル生成後の再試行回数", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 120), Array.Empty<object>()));
			ApplyRetryIntervalSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ApplyRetryIntervalSeconds", 0.5f, new ConfigDescription("Retry interval seconds after level generation. レベル生成後の再試行間隔秒数", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>()));
			EnableLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableLog", true, "Enable log output. ログ出力有効化");
			harmony = new Harmony("REPOJP.AutoMuteOn");
			harmony.PatchAll();
			WriteInfo("Loaded AutoMuteOn v4.0.0 safe mode");
		}

		private void OnDestroy()
		{
			if (applyCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(applyCoroutine);
				applyCoroutine = null;
			}
			try
			{
				if (harmony != null)
				{
					harmony.UnpatchSelf();
					harmony = null;
				}
			}
			catch
			{
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		internal void ScheduleApplyAfterLevelGenerated(string reason)
		{
			if (ModEnabled != null && ModEnabled.Value)
			{
				if (applyCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(applyCoroutine);
					applyCoroutine = null;
				}
				applyCoroutine = ((MonoBehaviour)this).StartCoroutine(CoApplyAfterLevelGenerated(reason));
			}
		}

		[IteratorStateMachine(typeof(<CoApplyAfterLevelGenerated>d__16))]
		private IEnumerator CoApplyAfterLevelGenerated(string reason)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoApplyAfterLevelGenerated>d__16(0)
			{
				<>4__this = this,
				reason = reason
			};
		}

		private static bool IsReadyForMainProcess()
		{
			try
			{
				if ((Object)(object)LevelGenerator.Instance == (Object)null)
				{
					return false;
				}
				if (!LevelGenerator.Instance.Generated)
				{
					return false;
				}
			}
			catch
			{
				return false;
			}
			try
			{
				if ((Object)(object)RunManager.instance == (Object)null)
				{
					return false;
				}
				if ((Object)(object)StatsManager.instance == (Object)null)
				{
					return false;
				}
				if ((Object)(object)PunManager.instance == (Object)null)
				{
					return false;
				}
			}
			catch
			{
				return false;
			}
			try
			{
				if (SemiFunc.RunIsShop())
				{
					return false;
				}
			}
			catch
			{
			}
			try
			{
				if (SemiFunc.RunIsLevel() || SemiFunc.RunIsArena() || SemiFunc.RunIsTutorial())
				{
					return true;
				}
			}
			catch
			{
				return false;
			}
			return false;
		}

		private static bool TrySetToggleMute(bool value)
		{
			DataDirector val = null;
			try
			{
				val = DataDirector.instance;
			}
			catch
			{
				val = null;
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			FieldInfo fieldInfo = GetToggleMuteField();
			if (fieldInfo == null)
			{
				WriteWarning("DataDirector.toggleMute field not found");
				return false;
			}
			try
			{
				object value2 = fieldInfo.GetValue(val);
				bool flag = false;
				if (value2 is bool)
				{
					flag = (bool)value2;
				}
				if (flag != value)
				{
					fieldInfo.SetValue(val, value);
				}
				return true;
			}
			catch (Exception ex)
			{
				WriteError("Failure: Set toggleMute\n" + ex);
				return false;
			}
		}

		private static FieldInfo GetToggleMuteField()
		{
			if (toggleMuteField != null)
			{
				return toggleMuteField;
			}
			try
			{
				toggleMuteField = AccessTools.Field(typeof(DataDirector), "toggleMute");
			}
			catch
			{
				toggleMuteField = null;
			}
			return toggleMuteField;
		}

		internal static void WriteInfo(string message)
		{
			if (Log != null && (EnableLog == null || EnableLog.Value))
			{
				Log.LogInfo((object)message);
			}
		}

		internal static void WriteWarning(string message)
		{
			if (Log != null && (EnableLog == null || EnableLog.Value))
			{
				Log.LogWarning((object)message);
			}
		}

		internal static void WriteError(string message)
		{
			if (Log != null && (EnableLog == null || EnableLog.Value))
			{
				Log.LogError((object)message);
			}
		}
	}
	[HarmonyPatch(typeof(LevelGenerator), "GenerateDone")]
	internal static class LevelGenerator_GenerateDone_Patch
	{
		private static void Postfix()
		{
			try
			{
				if ((Object)(object)AutoMuteOnPlugin.Instance != (Object)null)
				{
					AutoMuteOnPlugin.Instance.ScheduleApplyAfterLevelGenerated("LevelGenerator.GenerateDone");
				}
			}
			catch (Exception ex)
			{
				AutoMuteOnPlugin.WriteError("Failure: GenerateDone patch\n" + ex);
			}
		}
	}
}