using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("SilksongFocusQoL")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+8bbdc76b8b2ca802848b84675715a160716bb538")]
[assembly: AssemblyProduct("SilksongFocusQoL")]
[assembly: AssemblyTitle("SilksongFocusQoL")]
[assembly: AssemblyVersion("1.0.1.0")]
[BepInPlugin("com.zlq.silksongfocusqol", "Silksong Focus QoL", "1.0.1")]
public class SilksongFocusQoL : BaseUnityPlugin
{
	private class FocusQoLBehaviour : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <TimeoutTracking>d__20 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public FocusQoLBehaviour <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Expected O, but got Unknown
				int num = <>1__state;
				FocusQoLBehaviour focusQoLBehaviour = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(focusQoLBehaviour.autoUnpauseWindow.Value);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					focusQoLBehaviour.isTrackingTime = false;
					focusQoLBehaviour.timeoutCoroutine = 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();
			}
		}

		private bool wasPausedByMod;

		private bool wasAlreadyPaused;

		private float focusLostTime;

		private bool isTrackingTime;

		private Coroutine timeoutCoroutine;

		private bool wantsToPause;

		private ConfigEntry<bool> enableAutoPause;

		private ConfigEntry<bool> enableAutoUnpause;

		private ConfigEntry<float> autoUnpauseWindow;

		private ConfigEntry<bool> enableAutoMute;

		private Type gameManagerType;

		private PropertyInfo instanceProp;

		private MethodInfo isGamePausedMethod;

		private MethodInfo pauseGameToggle;

		private ParameterInfo[] pauseMethodParameters;

		public void SetConfig(ConfigEntry<bool> enableAutoPause, ConfigEntry<bool> enableAutoUnpause, ConfigEntry<float> autoUnpauseWindow, ConfigEntry<bool> enableAutoMute)
		{
			this.enableAutoPause = enableAutoPause;
			this.enableAutoUnpause = enableAutoUnpause;
			this.autoUnpauseWindow = autoUnpauseWindow;
			this.enableAutoMute = enableAutoMute;
			CacheGameManagerMethods();
		}

		private void CacheGameManagerMethods()
		{
			gameManagerType = Type.GetType("GameManager") ?? FindTypeByName("GameManager");
			if (gameManagerType != null)
			{
				instanceProp = gameManagerType.GetProperty("instance", BindingFlags.Static | BindingFlags.Public) ?? gameManagerType.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public);
				isGamePausedMethod = gameManagerType.GetMethod("IsGamePaused", BindingFlags.Instance | BindingFlags.Public);
				pauseGameToggle = gameManagerType.GetMethod("PauseGameToggle", BindingFlags.Instance | BindingFlags.Public);
				if (pauseGameToggle != null)
				{
					pauseMethodParameters = pauseGameToggle.GetParameters();
				}
			}
		}

		private void Update()
		{
			if (wantsToPause && !IsGamePaused())
			{
				AttemptToPauseGame();
			}
		}

		private void OnApplicationFocus(bool hasFocus)
		{
			if (!((Behaviour)this).isActiveAndEnabled)
			{
				return;
			}
			try
			{
				if (!hasFocus)
				{
					focusLostTime = Time.unscaledTime;
					wasAlreadyPaused = IsGamePaused();
					if (enableAutoPause.Value)
					{
						wantsToPause = true;
						if (!wasAlreadyPaused)
						{
							AttemptToPauseGame();
						}
					}
					if (enableAutoUnpause.Value && autoUnpauseWindow.Value > 0f)
					{
						isTrackingTime = true;
						StopTrackingCoroutine();
						timeoutCoroutine = ((MonoBehaviour)this).StartCoroutine(TimeoutTracking());
					}
				}
				else
				{
					wantsToPause = false;
					StopTrackingCoroutine();
					if (enableAutoUnpause.Value && wasPausedByMod)
					{
						bool flag = true;
						if (autoUnpauseWindow.Value > 0f)
						{
							flag = isTrackingTime && Time.unscaledTime - focusLostTime <= autoUnpauseWindow.Value;
						}
						if (flag)
						{
							AttemptToUnpauseGame();
						}
					}
					wasPausedByMod = false;
					wasAlreadyPaused = false;
					isTrackingTime = false;
				}
				if (enableAutoMute.Value)
				{
					AudioListener.pause = !hasFocus;
				}
			}
			catch (Exception)
			{
			}
		}

		private void StopTrackingCoroutine()
		{
			if (timeoutCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(timeoutCoroutine);
				timeoutCoroutine = null;
			}
		}

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

		private bool IsGamePaused()
		{
			try
			{
				if (gameManagerType == null || instanceProp == null || isGamePausedMethod == null)
				{
					return false;
				}
				object value = instanceProp.GetValue(null);
				if (value == null)
				{
					return false;
				}
				return (bool)isGamePausedMethod.Invoke(value, null);
			}
			catch
			{
				return false;
			}
		}

		private void AttemptToPauseGame()
		{
			try
			{
				if (gameManagerType == null || instanceProp == null || pauseGameToggle == null)
				{
					return;
				}
				object value = instanceProp.GetValue(null);
				if (value != null && !IsGamePaused())
				{
					object obj = null;
					if (pauseMethodParameters.Length == 1 && pauseMethodParameters[0].ParameterType == typeof(bool))
					{
						obj = pauseGameToggle.Invoke(value, new object[1] { true });
					}
					else if (pauseMethodParameters.Length == 0)
					{
						obj = pauseGameToggle.Invoke(value, null);
					}
					if (obj != null && obj is IEnumerator)
					{
						((MonoBehaviour)this).StartCoroutine((IEnumerator)obj);
						wasPausedByMod = true;
					}
				}
			}
			catch
			{
			}
		}

		private void AttemptToUnpauseGame()
		{
			try
			{
				if (gameManagerType == null || instanceProp == null || pauseGameToggle == null)
				{
					return;
				}
				object value = instanceProp.GetValue(null);
				if (value != null && IsGamePaused() && wasPausedByMod)
				{
					object obj = null;
					if (pauseMethodParameters.Length == 1 && pauseMethodParameters[0].ParameterType == typeof(bool))
					{
						obj = pauseGameToggle.Invoke(value, new object[1] { false });
					}
					else if (pauseMethodParameters.Length == 0)
					{
						obj = pauseGameToggle.Invoke(value, null);
					}
					if (obj != null && obj is IEnumerator)
					{
						((MonoBehaviour)this).StartCoroutine((IEnumerator)obj);
					}
				}
			}
			catch
			{
			}
		}

		private Type FindTypeByName(string typeName)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					Type[] types = assembly.GetTypes();
					foreach (Type type in types)
					{
						if (type.Name == typeName)
						{
							return type;
						}
					}
				}
				catch (ReflectionTypeLoadException)
				{
				}
			}
			return null;
		}

		private void OnDisable()
		{
			StopTrackingCoroutine();
		}
	}

	private GameObject focusQoLBehaviourObject;

	private ConfigEntry<bool> configEnableAutoPause;

	private ConfigEntry<bool> configEnableAutoUnpause;

	private ConfigEntry<float> configAutoUnpauseWindow;

	private ConfigEntry<bool> configEnableAutoMute;

	private void Awake()
	{
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Expected O, but got Unknown
		ValidateConfig();
		configEnableAutoMute = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "EnableAutoMute", true, "Mute audio when window loses focus");
		configEnableAutoPause = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "EnableAutoPause", true, "Pause game when window loses focus");
		configEnableAutoUnpause = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "EnableAutoUnpause", true, "Unpause when focus returns");
		configAutoUnpauseWindow = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "AutoUnpauseWindow", 3f, new ConfigDescription("Time window to auto-unpause\n0 = always unpause when focus returns; >0 = only if refocus occurs within this many seconds", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 30f), Array.Empty<object>()));
		((BaseUnityPlugin)this).Config.SettingChanged += OnConfigChanged;
		focusQoLBehaviourObject = new GameObject("SilksongFocusQoLBehaviour", new Type[1] { typeof(FocusQoLBehaviour) });
		Object.DontDestroyOnLoad((Object)(object)focusQoLBehaviourObject);
		focusQoLBehaviourObject.GetComponent<FocusQoLBehaviour>().SetConfig(configEnableAutoPause, configEnableAutoUnpause, configAutoUnpauseWindow, configEnableAutoMute);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Silksong Focus QoL loaded");
	}

	private void ValidateConfig()
	{
		ConfigEntry<float> obj = configAutoUnpauseWindow;
		if (obj != null && obj.Value < 0f)
		{
			configAutoUnpauseWindow.Value = 0f;
		}
	}

	private void OnConfigChanged(object sender, SettingChangedEventArgs e)
	{
		try
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Config updated: [" + e.ChangedSetting.Definition.Section + "] " + e.ChangedSetting.Definition.Key));
			GameObject obj = focusQoLBehaviourObject;
			FocusQoLBehaviour focusQoLBehaviour = ((obj != null) ? obj.GetComponent<FocusQoLBehaviour>() : null);
			if ((Object)(object)focusQoLBehaviour != (Object)null)
			{
				focusQoLBehaviour.SetConfig(configEnableAutoPause, configEnableAutoUnpause, configAutoUnpauseWindow, configEnableAutoMute);
			}
		}
		catch (Exception arg)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)$"Error applying config change: {arg}");
		}
	}

	private void OnDestroy()
	{
		((BaseUnityPlugin)this).Config.SettingChanged -= OnConfigChanged;
		if ((Object)(object)focusQoLBehaviourObject != (Object)null)
		{
			Object.Destroy((Object)(object)focusQoLBehaviourObject);
		}
	}
}