using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using MenuLib;
using MenuLib.MonoBehaviors;
using MenuLib.Structs;
using Microsoft.CodeAnalysis;
using OmniShock.Core;
using OmniShock.Repo.Menu;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("addzeey.OmniShock")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("addzeey.OmniShock")]
[assembly: AssemblyTitle("addzeey.OmniShock")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 OmniShock.Repo
{
	internal readonly struct BreakObservation
	{
		internal readonly int Id;

		internal readonly float Lost;

		internal readonly float Original;

		internal readonly double Occurred;

		internal double Due => Occurred + 0.15;

		internal BreakObservation(int id, float lost, float original, double occurred)
		{
			Id = id;
			Lost = lost;
			Original = original;
			Occurred = occurred;
		}

		internal bool IsStale(double now)
		{
			return now - Due > 0.5;
		}
	}
	internal sealed class BreakObservationBuffer
	{
		internal const double CollisionWindowSeconds = 0.15;

		internal const double MaximumLatenessSeconds = 0.5;

		internal const double MaximumAgeSeconds = 0.65;

		internal const int Capacity = 128;

		private readonly Queue<BreakObservation> _observations = new Queue<BreakObservation>();

		internal bool TryAdd(int id, float lost, float original, double occurred)
		{
			if (_observations.Count >= 128 || double.IsNaN(occurred) || double.IsInfinity(occurred) || lost <= 0f || float.IsNaN(lost) || float.IsInfinity(lost) || original <= 0f || float.IsNaN(original) || float.IsInfinity(original))
			{
				return false;
			}
			_observations.Enqueue(new BreakObservation(id, lost, original, occurred));
			return true;
		}

		internal bool TryTakeReady(double now, out BreakObservation observation)
		{
			observation = default(BreakObservation);
			if (double.IsNaN(now) || double.IsInfinity(now) || _observations.Count == 0 || _observations.Peek().Due > now)
			{
				return false;
			}
			observation = _observations.Dequeue();
			return true;
		}

		internal void Clear()
		{
			_observations.Clear();
		}
	}
	internal sealed class CredentialEntry
	{
		private string _value;

		private readonly Action _changed;

		internal ConfigDefinition Definition { get; }

		internal string Value
		{
			get
			{
				return _value;
			}
			set
			{
				if (!(_value == value))
				{
					_value = value;
					_changed();
				}
			}
		}

		internal CredentialEntry(string section, string key, string value, Action changed)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			Definition = new ConfigDefinition(section, key);
			_value = value;
			_changed = changed;
		}

		public override string ToString()
		{
			return "Credential (hidden)";
		}
	}
	internal sealed class CredentialSettings
	{
		private readonly LocalCredentialStore _store;

		private CredentialSnapshot _saved;

		internal readonly CredentialEntry PiKey;

		internal readonly CredentialEntry PiId;

		internal readonly CredentialEntry OpenKey;

		internal readonly CredentialEntry OpenId;

		internal IReadOnlyList<CredentialEntry> Entries { get; }

		internal string Revision => _saved.Revision;

		internal bool IsCurrent => _store.Read().Revision == _saved.Revision;

		internal event EventHandler? Changed;

		internal CredentialSettings(ConfigFile config, ConfigEntry<bool> enabled, LocalCredentialStore store)
		{
			CredentialSettings credentialSettings = this;
			_store = store;
			_saved = store.Read();
			DiscardConfigCredential("PiShock", "ApiKey");
			DiscardConfigCredential("PiShock", "ShockerId");
			DiscardConfigCredential("OpenShock", "ApiKey");
			DiscardConfigCredential("OpenShock", "DeviceId");
			config.Save();
			PiKey = Entry("PiShock", "ApiKey");
			PiId = Entry("PiShock", "ShockerId");
			OpenKey = Entry("OpenShock", "ApiKey");
			OpenId = Entry("OpenShock", "DeviceId");
			Entries = new CredentialEntry[4] { PiKey, PiId, OpenKey, OpenId };
			void DiscardConfigCredential(string section, string key)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				ConfigDefinition val = new ConfigDefinition(section, key);
				if (!string.IsNullOrWhiteSpace(config.Bind<string>(val, string.Empty, (ConfigDescription)null).Value))
				{
					enabled.Value = false;
				}
				config.Remove(val);
			}
			CredentialEntry Entry(string section, string key)
			{
				string value;
				return new CredentialEntry(section, key, credentialSettings._saved.Values.TryGetValue(section + "/" + key, out value) ? (value ?? string.Empty) : string.Empty, delegate
				{
					credentialSettings.Changed?.Invoke(credentialSettings, EventArgs.Empty);
				});
			}
		}

		internal Dictionary<string, string> SnapshotLive()
		{
			Dictionary<string, string> dictionary = _saved.Values.ToDictionary<KeyValuePair<string, string>, string, string>((KeyValuePair<string, string> pair) => pair.Key, (KeyValuePair<string, string> pair) => pair.Value, StringComparer.Ordinal);
			foreach (CredentialEntry entry in Entries)
			{
				dictionary[entry.Definition.Section + "/" + entry.Definition.Key] = entry.Value;
			}
			return dictionary;
		}

		internal void Refresh()
		{
			CredentialSnapshot val = _store.Read();
			if (val.Revision == _saved.Revision)
			{
				return;
			}
			_saved = val;
			foreach (CredentialEntry entry in Entries)
			{
				entry.Value = (val.Values.TryGetValue(entry.Definition.Section + "/" + entry.Definition.Key, out var value) ? (value ?? string.Empty) : string.Empty);
			}
		}

		internal void Save(IReadOnlyDictionary<string, string> values)
		{
			CredentialSnapshot val = (_saved = _store.Write(values, _saved.Revision));
			foreach (CredentialEntry entry in Entries)
			{
				entry.Value = val.Values[entry.Definition.Section + "/" + entry.Definition.Key];
			}
		}
	}
	internal sealed class DiagnosticBuffer
	{
		internal const int Capacity = 256;

		internal const int PerFrameBudget = 32;

		private readonly ConcurrentQueue<string> _messages = new ConcurrentQueue<string>();

		private int _count;

		private int _dropped;

		internal void Write(string message)
		{
			if (Interlocked.Increment(ref _count) > 256)
			{
				Interlocked.Decrement(ref _count);
				Interlocked.Increment(ref _dropped);
			}
			else
			{
				_messages.Enqueue(message);
			}
		}

		internal bool TryRead(out string message)
		{
			if (!_messages.TryDequeue(out message))
			{
				return false;
			}
			Interlocked.Decrement(ref _count);
			return true;
		}

		internal int TakeDroppedCount()
		{
			return Interlocked.Exchange(ref _dropped, 0);
		}
	}
	[HarmonyPatch(typeof(PlayerHealth), "Hurt")]
	internal static class HealthLossHook
	{
		private static void Prefix(PlayerHealth __instance, out int __state)
		{
			__state = 0;
			try
			{
				__state = __instance.health;
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Health snapshot", exception);
			}
		}

		private static void Postfix(PlayerHealth __instance, int __state)
		{
			try
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.GameplayAllowed && instance.Settings.HurtEnabled.Value && Object.op_Implicit((Object)(object)__instance.playerAvatar))
				{
					int intensity = ValuablePolicy.Intensity(TriggerPolicy.HealthLost(__state, __instance.health, __instance.playerAvatar.isLocal, instance.Alive), instance.Settings.DamageMultiplier.Value, instance.Settings.Maximum.Value);
					instance.Request("Local health lost", intensity, instance.Settings.HurtDurationMs.Value);
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Health loss", exception);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAvatar), "PlayerDeathRPC")]
	internal static class DeathHook
	{
		private struct Snapshot
		{
			internal bool WasDead;

			internal bool Local;

			internal bool Allowed;
		}

		private static void Prefix(PlayerAvatar __instance, out Snapshot __state)
		{
			__state = default(Snapshot);
			try
			{
				__state = new Snapshot
				{
					WasDead = __instance.deadSet,
					Local = __instance.isLocal,
					Allowed = (Plugin.Instance?.GameplayAllowed ?? false)
				};
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Death snapshot", exception);
			}
		}

		private static void Postfix(PlayerAvatar __instance, Snapshot __state)
		{
			try
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)(object)instance == (Object)null) && TriggerPolicy.AcceptedDeath(__state.WasDead, __instance.deadSet, __state.Local, __state.Allowed))
				{
					instance.ClearGameplayState();
					if (instance.Settings.DeathEnabled.Value)
					{
						instance.Request("Local death", instance.Settings.DeathIntensity.Value, instance.Settings.DeathDurationMs.Value, acceptedDeath: true);
					}
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Local death", exception);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAvatar), "ReviveRPC")]
	internal static class ReviveHook
	{
		private static void Prefix(PlayerAvatar __instance, out bool __state)
		{
			__state = false;
			try
			{
				__state = __instance.deadSet;
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Revive snapshot", exception);
			}
		}

		private static void Postfix(PlayerAvatar __instance, bool __state)
		{
			try
			{
				if (__instance.isLocal && __state && !__instance.deadSet)
				{
					Plugin.Instance?.ClearGameplayState();
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Local revive", exception);
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObject), "GrabStarted")]
	internal static class GrabHook
	{
		private static void Postfix(PhysGrabObject __instance, PhysGrabber player)
		{
			try
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.GameplayAllowed && instance.Alive && __instance.isValuable && __instance.grabbedLocal && Object.op_Implicit((Object)(object)player) && player.isLocal)
				{
					instance.Valuables.Touch(((Object)__instance).GetInstanceID(), Time.realtimeSinceStartupAsDouble);
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Valuable grab", exception);
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObject), "GrabEnded")]
	internal static class ReleaseHook
	{
		private static void Prefix(PhysGrabObject __instance, PhysGrabber player)
		{
			try
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.GameplayAllowed && instance.Alive && __instance.isValuable && __instance.grabbedLocal && Object.op_Implicit((Object)(object)player) && player.isLocal)
				{
					instance.Valuables.Touch(((Object)__instance).GetInstanceID(), Time.realtimeSinceStartupAsDouble);
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Valuable release", exception);
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObjectImpactDetector), "OnCollisionStay")]
	internal static class EnemyContactHook
	{
		private static void Prefix(PhysGrabObjectImpactDetector __instance, Collision collision)
		{
			try
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.GameplayAllowed && instance.Alive && instance.Settings.IgnoreEnemies.Value && __instance.isValuable && Object.op_Implicit((Object)(object)__instance.physGrabObject) && collision != null)
				{
					Transform transform = collision.transform;
					if (Object.op_Implicit((Object)(object)transform) && (((Component)transform).CompareTag("Enemy") || Object.op_Implicit((Object)(object)((Component)transform).GetComponentInParent<EnemyRigidbody>())))
					{
						PhysGrabObject physGrabObject = __instance.physGrabObject;
						instance.Valuables.EnemyContact(((Object)physGrabObject).GetInstanceID(), physGrabObject.heldByLocalPlayer || physGrabObject.grabbedLocal, Time.realtimeSinceStartupAsDouble, instance.Settings.ThrownGrace.Value, instance.Settings.HitGrace.Value);
					}
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Enemy contact", exception);
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObjectImpactDetector), "BreakRPC")]
	internal static class ValuableLossHook
	{
		private struct Snapshot
		{
			internal int Id;

			internal float Loss;

			internal float Original;

			internal bool Held;

			internal bool Valid;
		}

		private static void Prefix(PhysGrabObjectImpactDetector __instance, float valueLost, bool _loseValue, PhotonMessageInfo _info, out Snapshot __state)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			__state = default(Snapshot);
			try
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.GameplayAllowed && instance.Alive && instance.Settings.BreakEnabled.Value && _loseValue && SemiFunc.MasterOnlyRPC(_info) && __instance.isValuable && Object.op_Implicit((Object)(object)__instance.valuableObject) && Object.op_Implicit((Object)(object)__instance.physGrabObject))
				{
					ValuableObject valuableObject = __instance.valuableObject;
					float num = TriggerPolicy.BreakLoss(valuableObject.dollarValueCurrent, valuableObject.dollarValueOriginal, valueLost);
					if (!(num <= 0f))
					{
						__state = new Snapshot
						{
							Id = ((Object)__instance.physGrabObject).GetInstanceID(),
							Loss = num,
							Original = valuableObject.dollarValueOriginal,
							Held = (__instance.physGrabObject.heldByLocalPlayer || __instance.physGrabObject.grabbedLocal),
							Valid = true
						};
					}
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Valuable loss snapshot", exception);
			}
		}

		private static void Postfix(Snapshot __state)
		{
			try
			{
				if (__state.Valid)
				{
					Plugin.Instance?.QueueBreak(__state.Id, __state.Loss, __state.Original, __state.Held);
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Valuable loss", exception);
			}
		}
	}
	internal sealed class ModSettings
	{
		internal readonly ConfigEntry<bool> Enabled;

		internal readonly ConfigEntry<ShockProvider> Provider;

		internal readonly ConfigEntry<int> Maximum;

		internal readonly ConfigEntry<float> Cooldown;

		internal readonly ConfigEntry<string> PiUrl;

		internal readonly ConfigEntry<string> OpenUrl;

		internal readonly ConfigFile Config;

		internal readonly CredentialSettings Credentials;

		internal readonly ConfigEntry<bool> HurtEnabled;

		internal readonly ConfigEntry<bool> DeathEnabled;

		internal readonly ConfigEntry<bool> BreakEnabled;

		internal readonly ConfigEntry<bool> IgnoreEnemies;

		internal readonly ConfigEntry<bool> Proportional;

		internal readonly ConfigEntry<float> DamageMultiplier;

		internal readonly ConfigEntry<float> LossMultiplier;

		internal readonly ConfigEntry<float> ResponsibilityWindow;

		internal readonly ConfigEntry<float> ThrownGrace;

		internal readonly ConfigEntry<float> HitGrace;

		internal readonly ConfigEntry<int> HurtDurationMs;

		internal readonly ConfigEntry<int> DeathIntensity;

		internal readonly ConfigEntry<int> DeathDurationMs;

		internal readonly ConfigEntry<int> BreakDurationMs;

		internal CredentialEntry PiKey => Credentials.PiKey;

		internal CredentialEntry PiId => Credentials.PiId;

		internal CredentialEntry OpenKey => Credentials.OpenKey;

		internal CredentialEntry OpenId => Credentials.OpenId;

		internal ModSettings(ConfigFile config, LocalCredentialStore? credentialStore = null)
		{
			Config = config;
			bool saveOnConfigSet = config.SaveOnConfigSet;
			config.SaveOnConfigSet = false;
			try
			{
				Enabled = config.Bind<bool>("General", "Enabled", false, "Enable live device requests for local gameplay triggers.");
				ConfigEntry<bool> val = config.Bind<bool>("General", "DryRun", false, "Retired; migrated to Disabled.");
				if (val.Value)
				{
					Enabled.Value = false;
				}
				config.Remove(((ConfigEntryBase)val).Definition);
				Provider = config.Bind<ShockProvider>("General", "Provider", (ShockProvider)0, "PiShock V3 or OpenShock.");
				Maximum = Bind<int>("General", "MaxIntensity", 25, 1, 100, "Absolute cap on every outgoing shock.");
				Cooldown = Bind<float>("General", "CooldownSeconds", 2f, 0f, 60f, "Minimum interval between requests. Busy/cooldown events are dropped, not queued.");
				PiUrl = config.Bind<string>("PiShock", "ApiUrl", "https://api.pishock.com", "HTTPS API base URL; do not embed credentials.");
				OpenUrl = config.Bind<string>("OpenShock", "ApiUrl", "https://api.openshock.app", "HTTPS API base URL; self-hosted endpoints supported. Do not embed credentials.");
				HurtEnabled = config.Bind<bool>("Damage", "Enabled", true, "Trigger for actual local health lost, excluding lethal hits (handled by Death).");
				DamageMultiplier = Bind<float>("Damage", "IntensityPerHealthLost", 1f, 0.01f, 100f, "Actual health lost multiplied by this value, rounded up and capped.");
				HurtDurationMs = Duration("Damage", 500);
				DeathEnabled = config.Bind<bool>("Death", "Enabled", true, "Trigger once per local death; remote deaths never trigger.");
				DeathIntensity = Bind<int>("Death", "Intensity", 25, 1, 100, "Death intensity, also limited by MaxIntensity.");
				DeathDurationMs = Duration("Death", 1000);
				BreakEnabled = config.Bind<bool>("Valuables", "Enabled", true, "Trigger for actual value lost on held or recently released valuables, including destruction.");
				Proportional = config.Bind<bool>("Valuables", "MapValueToIntensity", false, "Map value lost / original value to MaxIntensity instead of using ValueLossMultiplier.");
				LossMultiplier = Bind<float>("Valuables", "ValueLossMultiplier", 0.1f, 0.001f, 100f, "Value lost multiplied by this value, rounded up and capped.");
				ResponsibilityWindow = Bind<float>("Valuables", "ResponsibilityWindowSeconds", 15f, 1f, 120f, "How long each released valuable remains your responsibility.");
				BreakDurationMs = Duration("Valuables", 500);
				IgnoreEnemies = config.Bind<bool>("Valuables", "IgnoreHittingEnemies", true, "Suppress value-loss shocks for that item when used against enemies; does not suppress health damage.");
				ThrownGrace = Bind<float>("Valuables", "ThrownOffensiveGraceSeconds", 2f, 0f, 5f, "Released items must contact an enemy within this interval to qualify as thrown weapons.");
				HitGrace = Bind<float>("Valuables", "HitOffensiveGraceSeconds", 3f, 0f, 5f, "Suppress further damage on the SAME item after an eligible enemy contact.");
				Credentials = new CredentialSettings(config, Enabled, credentialStore ?? LocalCredentialStore.ForApplication("REPO"));
			}
			finally
			{
				config.SaveOnConfigSet = saveOnConfigSet;
			}
			ConfigEntry<T> Bind<T>(string section, string key, T value, T min, T max, string description) where T : notnull, IComparable
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				return config.Bind<T>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<T>(min, max), Array.Empty<object>()));
			}
			ConfigEntry<int> Duration(string section, int value)
			{
				return Bind<int>(section, "DurationMilliseconds", value, 300, 15000, "Duration in milliseconds. 1000 = one second, for both providers.");
			}
		}

		internal ShockConnection Connection()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			if ((int)Provider.Value == 0)
			{
				return new ShockConnection(Provider.Value, PiUrl.Value, PiKey.Value, PiId.Value);
			}
			return new ShockConnection(Provider.Value, OpenUrl.Value, OpenKey.Value, OpenId.Value);
		}
	}
	[BepInPlugin("com.github.addzeey.OmniShock", "OmniShock", "1.0.1")]
	[BepInDependency("nickklmao.menulib", "2.6.2")]
	[BepInIncompatibility("mxpuffin.REPOShock")]
	[BepInIncompatibility("gay.lilyy.ReOpenShock")]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal const string Guid = "com.github.addzeey.OmniShock";

		private readonly ShockController _controller = new ShockController((HttpMessageHandler)null, (Func<double>)null);

		private readonly DiagnosticBuffer _messages = new DiagnosticBuffer();

		private readonly BreakObservationBuffer _pendingBreaks = new BreakObservationBuffer();

		private readonly HashSet<string> _reportedHookFailures = new HashSet<string>();

		private CancellationTokenSource _scope = new CancellationTokenSource();

		private Harmony? _harmony;

		private double _nextPrune;

		private double _nextDropReport;

		private long _configurationRevision;

		private long _appliedConfigurationRevision;

		private long _gameplayRevision;

		private bool _ready;

		private bool _settingsSavePaused;

		private bool _destroyed;

		internal static Plugin? Instance { get; private set; }

		internal ModSettings Settings { get; private set; }

		internal ValuablePolicy Valuables { get; } = new ValuablePolicy();

		private bool LevelAllowed
		{
			get
			{
				if (_ready && !_destroyed && !_settingsSavePaused && ((Behaviour)this).isActiveAndEnabled && Settings.Enabled.Value && Object.op_Implicit((Object)(object)RunManager.instance) && Object.op_Implicit((Object)(object)RunManager.instance.levelCurrent) && !SemiFunc.RunIsArena() && !SemiFunc.RunIsRecording())
				{
					if (!SemiFunc.RunIsLevel())
					{
						return SemiFunc.RunIsTutorial();
					}
					return true;
				}
				return false;
			}
		}

		internal bool GameplayAllowed
		{
			get
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Invalid comparison between Unknown and I4
				if (LevelAllowed && Object.op_Implicit((Object)(object)GameDirector.instance))
				{
					return (int)GameDirector.instance.currentState == 2;
				}
				return false;
			}
		}

		internal bool Alive
		{
			get
			{
				if (Object.op_Implicit((Object)(object)PlayerAvatar.instance) && !PlayerAvatar.instance.deadSet)
				{
					return !PlayerAvatar.instance.isDisabled;
				}
				return false;
			}
		}

		private void Awake()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			try
			{
				Settings = new ModSettings(((BaseUnityPlugin)this).Config);
				Instance = this;
				_harmony = new Harmony("com.github.addzeey.OmniShock");
				_harmony.PatchAll(typeof(Plugin).Assembly);
				SceneManager.activeSceneChanged += OnSceneChanged;
				((BaseUnityPlugin)this).Config.SettingChanged += OnSettingChanged;
				Settings.Credentials.Changed += OnCredentialsChanged;
				_ready = true;
				OmniShockMenu.Register();
			}
			catch (Exception ex)
			{
				_ready = false;
				Instance = null;
				SceneManager.activeSceneChanged -= OnSceneChanged;
				((BaseUnityPlugin)this).Config.SettingChanged -= OnSettingChanged;
				if (Settings != null)
				{
					Settings.Credentials.Changed -= OnCredentialsChanged;
				}
				try
				{
					Harmony? harmony = _harmony;
					if (harmony != null)
					{
						harmony.UnpatchSelf();
					}
				}
				catch (Exception ex2)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("Hook cleanup failed (" + ex2.GetType().Name + "). Restart before using OmniShock."));
				}
				finally
				{
					_controller.Dispose();
				}
				((BaseUnityPlugin)this).Logger.LogError((object)("OmniShock hooks failed; no device requests will be sent. " + ex.GetType().Name + ": " + ex.Message));
				return;
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("OmniShock loaded. Enabled=" + Settings.Enabled.Value + ". Enabled triggers send live device requests; no remote player controls your device."));
		}

		internal void Request(string reason, int intensity, int durationMs, bool acceptedDeath = false, long? observedRevision = null)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			ApplyConfigurationChanges();
			if (observedRevision.HasValue && observedRevision.Value != _gameplayRevision)
			{
				_messages.Write("Valuable skipped: configuration or gameplay scope changed before dispatch.");
				return;
			}
			bool flag = acceptedDeath && LevelAllowed && Object.op_Implicit((Object)(object)GameDirector.instance) && (int)GameDirector.instance.currentState == 7;
			if ((GameplayAllowed || flag) && intensity > 0)
			{
				int num = Math.Clamp(Settings.Maximum.Value, 1, 100);
				intensity = Math.Clamp(intensity, 1, num);
				durationMs = Math.Clamp(durationMs, 300, 15000);
				long num2 = Interlocked.Read(in _configurationRevision);
				ShockConnection connection = Settings.Connection();
				double cooldown = Settings.Cooldown.Value;
				if (num2 != _appliedConfigurationRevision || num2 != Interlocked.Read(in _configurationRevision))
				{
					ApplyConfigurationChanges();
					_messages.Write("Request skipped: configuration changed while capturing provider settings.");
				}
				else
				{
					SendAndReportAsync(connection, intensity, durationMs, num, cooldown, reason, _scope.Token);
				}
			}
		}

		private async Task SendAndReportAsync(ShockConnection connection, int intensity, int durationMs, int maximum, double cooldown, string reason, CancellationToken token)
		{
			try
			{
				ShockOutcome val = await _controller.SendAsync(connection, intensity, durationMs, "OmniShock", maximum, cooldown, false, token).ConfigureAwait(continueOnCapturedContext: false);
				_messages.Write($"{reason}: {val}; {connection.Provider}, intensity={intensity}%, duration={durationMs}ms.");
			}
			catch (Exception ex)
			{
				_messages.Write("Device request failed (" + ex.GetType().Name + "). Check local provider configuration.");
			}
		}

		internal void QueueBreak(int id, float lost, float original, bool held)
		{
			ApplyConfigurationChanges();
			if (GameplayAllowed && Alive && Settings.BreakEnabled.Value && !(lost <= 0f) && Valuables.IsResponsible(id, held, Time.realtimeSinceStartupAsDouble, Settings.ResponsibilityWindow.Value) && !_pendingBreaks.TryAdd(id, lost, original, Time.realtimeSinceStartupAsDouble))
			{
				_messages.Write("Valuable skipped: observation buffer full or invalid timestamp.");
			}
		}

		private void Update()
		{
			try
			{
				for (int i = 0; i < 32; i++)
				{
					if (!_messages.TryRead(out string message))
					{
						break;
					}
					((BaseUnityPlugin)this).Logger.LogInfo((object)message);
				}
				if (!_ready || _destroyed || (Object)(object)Instance != (Object)(object)this)
				{
					return;
				}
				ApplyConfigurationChanges();
				double realtimeSinceStartupAsDouble = Time.realtimeSinceStartupAsDouble;
				if (realtimeSinceStartupAsDouble >= _nextDropReport)
				{
					int num = _messages.TakeDroppedCount();
					if (num > 0)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)$"OmniShock omitted {num} repeated diagnostics to keep logging bounded.");
					}
					_nextDropReport = realtimeSinceStartupAsDouble + 1.0;
				}
				for (int j = 0; j < 128; j++)
				{
					if (!_pendingBreaks.TryTakeReady(realtimeSinceStartupAsDouble, out var observation))
					{
						break;
					}
					long gameplayRevision = _gameplayRevision;
					if (observation.IsStale(realtimeSinceStartupAsDouble))
					{
						_messages.Write("Valuable skipped: collision observation became stale.");
						continue;
					}
					if (!GameplayAllowed || !Alive || !Settings.BreakEnabled.Value)
					{
						_messages.Write("Valuable skipped: gameplay/local player/event no longer eligible.");
						continue;
					}
					if (Settings.IgnoreEnemies.Value && Valuables.IsOffensive(observation.Id, observation.Occurred))
					{
						_messages.Write("Valuable skipped: this item's enemy-contact grace covers the loss.");
						continue;
					}
					int intensity = ValuablePolicy.Intensity(observation.Lost, Settings.LossMultiplier.Value, Settings.Maximum.Value, Settings.Proportional.Value, observation.Original);
					Request("Valuable value lost", intensity, Settings.BreakDurationMs.Value, acceptedDeath: false, gameplayRevision);
				}
				if (realtimeSinceStartupAsDouble >= _nextPrune)
				{
					Valuables.Prune(realtimeSinceStartupAsDouble, Math.Max(Settings.ResponsibilityWindow.Value, Settings.ThrownGrace.Value) + 1f);
					_nextPrune = realtimeSinceStartupAsDouble + 5.0;
				}
			}
			catch (Exception exception)
			{
				ReportHookFailure("Update", exception);
			}
		}

		private void OnSceneChanged(Scene previous, Scene next)
		{
			if (!_ready || _destroyed)
			{
				return;
			}
			try
			{
				OmniShockMenu.Close();
				ResetScope();
			}
			catch (Exception exception)
			{
				ReportHookFailure("Scene cleanup", exception);
			}
		}

		private void OnSettingChanged(object sender, SettingChangedEventArgs args)
		{
			Interlocked.Increment(ref _configurationRevision);
		}

		private void OnCredentialsChanged(object? sender, EventArgs args)
		{
			Interlocked.Increment(ref _configurationRevision);
		}

		private void ApplyConfigurationChanges()
		{
			long num = Interlocked.Read(in _configurationRevision);
			if (num != _appliedConfigurationRevision)
			{
				_appliedConfigurationRevision = num;
				ResetScope();
				_messages.Write("Configuration changed: cleared item observations and cancelled previous request scope.");
			}
		}

		internal void ClearGameplayState()
		{
			_gameplayRevision++;
			_pendingBreaks.Clear();
			Valuables.Clear();
		}

		internal void ResetScope()
		{
			ClearGameplayState();
			CancelScope();
			_scope = new CancellationTokenSource();
		}

		internal void PauseForSettingsSave()
		{
			_settingsSavePaused = true;
			ResetScope();
		}

		internal void ResumeAfterSettingsSave()
		{
			_settingsSavePaused = false;
		}

		private void CancelScope()
		{
			try
			{
				_scope.Cancel();
			}
			catch (AggregateException)
			{
				_messages.Write("A request cancellation callback failed; request scope was still closed.");
			}
			catch (ObjectDisposedException)
			{
				_messages.Write("Request scope was already closed.");
			}
			finally
			{
				_scope.Dispose();
			}
		}

		internal static void ReportHookFailure(string hook, Exception exception)
		{
			Plugin instance = Instance;
			if ((Object)(object)instance != (Object)null && instance._reportedHookFailures.Add(hook))
			{
				instance._messages.Write(hook + " failed (" + exception.GetType().Name + "); event skipped, game method left untouched. Repeated errors for this hook are muted.");
			}
		}

		private void OnDisable()
		{
			if (_ready && !_destroyed)
			{
				try
				{
					OmniShockMenu.Close();
					ResetScope();
				}
				catch (Exception exception)
				{
					ReportHookFailure("Disable cleanup", exception);
				}
			}
		}

		private void OnDestroy()
		{
			if (_destroyed)
			{
				return;
			}
			_destroyed = true;
			_ready = false;
			OmniShockMenu.Close();
			((BaseUnityPlugin)this).Config.SettingChanged -= OnSettingChanged;
			if (Settings != null)
			{
				Settings.Credentials.Changed -= OnCredentialsChanged;
			}
			SceneManager.activeSceneChanged -= OnSceneChanged;
			Instance = null;
			try
			{
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("OmniShock hook unload failed (" + ex.GetType().Name + "). Restart before reloading this mod."));
			}
			finally
			{
				CancelScope();
				try
				{
					_controller.Dispose();
				}
				finally
				{
					ClearGameplayState();
				}
			}
		}
	}
	internal static class TriggerPolicy
	{
		internal static int HealthLost(int before, int after, bool local, bool alive)
		{
			if (!(local && alive) || before <= after || after <= 0)
			{
				return 0;
			}
			return before - after;
		}

		internal static bool AcceptedDeath(bool wasDead, bool isDead, bool local, bool allowedBefore)
		{
			return local && allowedBefore && !wasDead && isDead;
		}

		internal static float BreakLoss(float before, float original, float requested)
		{
			if (!IsPositiveFinite(before) || !IsPositiveFinite(original) || !IsPositiveFinite(requested))
			{
				return 0f;
			}
			if (!((double)(before - requested) < (double)original * 0.15000000596046448))
			{
				return Math.Min(before, requested);
			}
			return before;
		}

		private static bool IsPositiveFinite(float value)
		{
			if (value > 0f && !float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	internal sealed class ValuablePolicy
	{
		private sealed class ItemState
		{
			internal double LastHeld;

			internal readonly List<GraceWindow> OffensiveWindows = new List<GraceWindow>();
		}

		private readonly struct GraceWindow
		{
			internal readonly double Start;

			internal readonly double End;

			internal GraceWindow(double start, double end)
			{
				Start = start;
				End = end;
			}
		}

		private const int MaximumGraceWindows = 8;

		private readonly Dictionary<int, ItemState> _items = new Dictionary<int, ItemState>();

		internal void Touch(int id, double now)
		{
			if (!_items.TryGetValue(id, out ItemState value))
			{
				value = (_items[id] = new ItemState());
			}
			value.LastHeld = now;
		}

		internal bool IsResponsible(int id, bool heldLocally, double now, double window)
		{
			if (heldLocally)
			{
				Touch(id, now);
			}
			if (_items.TryGetValue(id, out ItemState value))
			{
				return now - value.LastHeld <= window;
			}
			return false;
		}

		internal void EnemyContact(int id, bool heldLocally, double now, double thrownGrace, double hitGrace)
		{
			if (heldLocally)
			{
				Touch(id, now);
			}
			if (!_items.TryGetValue(id, out ItemState value) || (!heldLocally && now - value.LastHeld > thrownGrace))
			{
				return;
			}
			List<GraceWindow> offensiveWindows = value.OffensiveWindows;
			double num = now - 0.15;
			double num2 = now + Math.Max(0.0, hitGrace);
			if (offensiveWindows.Count > 0 && num <= offensiveWindows[offensiveWindows.Count - 1].End)
			{
				GraceWindow graceWindow = offensiveWindows[offensiveWindows.Count - 1];
				offensiveWindows[offensiveWindows.Count - 1] = new GraceWindow(graceWindow.Start, Math.Max(graceWindow.End, num2));
				return;
			}
			if (offensiveWindows.Count == 8)
			{
				offensiveWindows.RemoveAt(0);
			}
			offensiveWindows.Add(new GraceWindow(num, num2));
		}

		internal bool IsOffensive(int id, double occurred)
		{
			if (!_items.TryGetValue(id, out ItemState value))
			{
				return false;
			}
			foreach (GraceWindow offensiveWindow in value.OffensiveWindows)
			{
				if (occurred >= offensiveWindow.Start && occurred <= offensiveWindow.End)
				{
					return true;
				}
			}
			return false;
		}

		internal void Prune(double now, double window)
		{
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, ItemState> item in _items)
			{
				item.Value.OffensiveWindows.RemoveAll((GraceWindow grace) => grace.End < now - 0.65);
				if (now - item.Value.LastHeld > window && item.Value.OffensiveWindows.Count == 0)
				{
					list.Add(item.Key);
				}
			}
			foreach (int item2 in list)
			{
				_items.Remove(item2);
			}
		}

		internal void Clear()
		{
			_items.Clear();
		}

		internal static int Intensity(float amount, float multiplier, int maximum, bool proportional = false, float original = 0f)
		{
			if (float.IsNaN(amount) || float.IsInfinity(amount) || amount <= 0f || maximum <= 0 || float.IsNaN(multiplier) || float.IsInfinity(multiplier) || multiplier <= 0f)
			{
				return 0;
			}
			if (proportional && (float.IsNaN(original) || float.IsInfinity(original) || original <= 0f))
			{
				return 0;
			}
			float num = (proportional ? (amount / original * (float)maximum) : (amount * multiplier));
			return (int)Math.Min(Math.Clamp(maximum, 1, 100), Math.Ceiling(num));
		}
	}
}
namespace OmniShock.Repo.Menu
{
	internal sealed class MaskedKeyInput : MonoBehaviour
	{
		private REPOInputStringSystem? _input;

		private TMP_Text? _visible;

		private TMP_Text? _inactiveEditor;

		private SecretEdit? _edit;

		private Action<string>? _report;

		internal void Initialize(REPOInputField field, SecretEdit edit, Action<string> report)
		{
			_edit = edit;
			_report = report;
			_input = field.inputStringSystem;
			_visible = _input.inputTMP;
			_visible.richText = false;
			_inactiveEditor = Object.Instantiate<TMP_Text>(_visible, _visible.transform.parent);
			((Object)((Component)_inactiveEditor).gameObject).name = "OmniShock credential editor - never rendered";
			((Component)_inactiveEditor).gameObject.SetActive(false);
			_inactiveEditor.richText = false;
			_inactiveEditor.text = string.Empty;
			_input.inputTMP = _inactiveEditor;
			_input.placeholder = string.Empty;
			_input.SetValue(string.Empty, false);
			_input.onValueChanged = OnEdited;
			RefreshVisible();
		}

		private void OnEdited(string value)
		{
			if (_edit != null && Object.op_Implicit((Object)(object)_input))
			{
				if (!_edit.StageReplacement(value))
				{
					_input.SetValue(string.Empty, false);
					_report?.Invoke(_edit.Error);
				}
				RefreshVisible();
			}
		}

		internal void CapturePending()
		{
			if (_edit != null && Object.op_Implicit((Object)(object)_input))
			{
				string text = _input.currentValue ?? string.Empty;
				if (text.Length > 0 || _edit.HasReplacement)
				{
					OnEdited(text);
				}
			}
		}

		internal void PasteReplacement()
		{
			if (_edit != null && Object.op_Implicit((Object)(object)_input))
			{
				string text = GUIUtility.systemCopyBuffer ?? string.Empty;
				if (_edit.StageReplacement(text))
				{
					_input.SetValue(text.Trim(), false);
				}
				else
				{
					_input.SetValue(string.Empty, false);
					_report?.Invoke(_edit.Error);
				}
				RefreshVisible();
			}
		}

		internal void ClearInput()
		{
			if (Object.op_Implicit((Object)(object)_input))
			{
				_input.isFocused = false;
				_input.SetValue(string.Empty, false);
			}
			if (Object.op_Implicit((Object)(object)_inactiveEditor))
			{
				_inactiveEditor.text = string.Empty;
			}
			RefreshVisible();
		}

		private void LateUpdate()
		{
			RefreshVisible();
		}

		private void RefreshVisible()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_visible) && _edit != null)
			{
				_visible.text = (_edit.HasReplacement ? "********" : "Type or paste replacement");
				((Graphic)_visible).color = (Color)((Object.op_Implicit((Object)(object)_input) && _input.isFocused) ? new Color(1f, 0.65f, 0.2f) : Color.white);
			}
		}

		private void OnDestroy()
		{
			ClearInput();
			if (Object.op_Implicit((Object)(object)_input))
			{
				_input.onValueChanged = null;
			}
			_edit?.Reset();
			_report = null;
		}
	}
	[HarmonyPatch(typeof(REPOInputStringSystem), "Update")]
	internal static class MenuInputPrivacyPatch
	{
		private static bool Prefix(REPOInputStringSystem __instance)
		{
			try
			{
				if (!Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<OmniShockMenuPage>()))
				{
					return true;
				}
				Keyboard current = Keyboard.current;
				if (current == null || Mouse.current == null)
				{
					return false;
				}
				if (__instance.currentValue == null)
				{
					__instance.SetValue(string.Empty, false);
				}
				MaskedKeyInput component = ((Component)__instance).GetComponent<MaskedKeyInput>();
				if (!Object.op_Implicit((Object)(object)component) || !__instance.isFocused || !current.ctrlKey.isPressed)
				{
					return true;
				}
				if (((ButtonControl)current.cKey).wasPressedThisFrame || ((ButtonControl)current.xKey).wasPressedThisFrame)
				{
					return false;
				}
				if (((ButtonControl)current.vKey).wasPressedThisFrame)
				{
					component.PasteReplacement();
					return false;
				}
				return true;
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Menu input privacy", exception);
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(REPOInputStringSystem), "set_isFocused")]
	internal static class MenuInputFocusPatch
	{
		private static bool Prefix(REPOInputStringSystem __instance, bool value, ref bool ____isFocused)
		{
			try
			{
				if (value && !Object.op_Implicit((Object)(object)ChatUI.instance) && Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<OmniShockMenuPage>()))
				{
					____isFocused = true;
					REPOInputStringSystem.hasAnyFocus = true;
					return false;
				}
				return true;
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Menu input focus", exception);
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(REPOInputField), "Update")]
	internal static class MenuInputDevicePatch
	{
		private static bool Prefix(REPOInputField __instance)
		{
			try
			{
				return !Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<OmniShockMenuPage>()) || Mouse.current != null;
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Menu pointer input", exception);
				return false;
			}
		}
	}
	internal static class OmniShockMenu
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static BuilderDelegate <0>__BuildMain;

			public static BuilderDelegate <1>__BuildLobby;

			public static BuilderDelegate <2>__BuildEscape;

			public static Action <3>__Open;
		}

		private static bool _registered;

		private static OmniShockMenuPage? _page;

		internal static void Register()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			if (!_registered)
			{
				object obj = <>O.<0>__BuildMain;
				if (obj == null)
				{
					BuilderDelegate val = BuildMain;
					<>O.<0>__BuildMain = val;
					obj = (object)val;
				}
				MenuAPI.AddElementToMainMenu((BuilderDelegate)obj);
				object obj2 = <>O.<1>__BuildLobby;
				if (obj2 == null)
				{
					BuilderDelegate val2 = BuildLobby;
					<>O.<1>__BuildLobby = val2;
					obj2 = (object)val2;
				}
				MenuAPI.AddElementToLobbyMenu((BuilderDelegate)obj2);
				object obj3 = <>O.<2>__BuildEscape;
				if (obj3 == null)
				{
					BuilderDelegate val3 = BuildEscape;
					<>O.<2>__BuildEscape = val3;
					obj3 = (object)val3;
				}
				MenuAPI.AddElementToEscapeMenu((BuilderDelegate)obj3);
				_registered = true;
			}
		}

		private static void BuildMain(Transform parent)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			AddButton(parent, new Vector2(500f, 290f));
		}

		private static void BuildLobby(Transform parent)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			MenuPageLobby componentInParent = ((Component)parent).GetComponentInParent<MenuPageLobby>();
			if (Object.op_Implicit((Object)(object)componentInParent) && Object.op_Implicit((Object)(object)componentInParent.leaveButton))
			{
				Vector3 val = parent.InverseTransformPoint(((Component)componentInParent.leaveButton).transform.position);
				AddButton(parent, new Vector2(val.x + 280f, val.y));
			}
		}

		private static void BuildEscape(Transform parent)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			AddButton(parent, new Vector2(126f, 105f));
		}

		private static void AddButton(Transform parent, Vector2 position)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (Object.op_Implicit((Object)(object)parent) && !Object.op_Implicit((Object)(object)((Component)parent).GetComponentInChildren<OmniShockMenuButton>(true)))
				{
					REPOButton obj = MenuAPI.CreateREPOButton("OmniShock", (Action)Open, parent, position);
					((Component)obj).gameObject.AddComponent<OmniShockMenuButton>();
					((TMP_Text)obj.labelTMP).fontSize = 24f;
					obj.overrideButtonSize = new Vector2(100f, 26f);
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Menu entry", exception);
			}
		}

		private static void Open()
		{
			REPOPopupPage val = null;
			try
			{
				Plugin instance = Plugin.Instance;
				if (!((Object)(object)instance == (Object)null) && !Object.op_Implicit((Object)(object)_page))
				{
					val = MenuAPI.CreateREPOPopupPage("OMNISHOCK", (PresetSide)0, false, true, 6f);
					_page = ((Component)val).gameObject.AddComponent<OmniShockMenuPage>();
					_page.Initialize(instance, val);
					val.OpenPage(false);
				}
			}
			catch (Exception exception)
			{
				try
				{
					Close();
					if (Object.op_Implicit((Object)(object)val))
					{
						if (Object.op_Implicit((Object)(object)MenuManager.instance))
						{
							MenuManager.instance.PageReactivatePageUnderThisPage(val.menuPage);
							MenuManager.instance.PageRemove(val.menuPage);
						}
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
				catch (Exception exception2)
				{
					Plugin.ReportHookFailure("Settings cleanup", exception2);
				}
				finally
				{
					_page = null;
					Plugin.ReportHookFailure("Open settings", exception);
				}
			}
		}

		internal static void Close()
		{
			try
			{
				if (Object.op_Implicit((Object)(object)_page))
				{
					_page.Close();
				}
			}
			catch (Exception exception)
			{
				Plugin.ReportHookFailure("Close settings", exception);
			}
		}

		internal static void Released(OmniShockMenuPage page)
		{
			if (_page == page)
			{
				_page = null;
			}
		}
	}
	internal sealed class OmniShockMenuButton : MonoBehaviour
	{
	}
	internal sealed class OmniShockMenuPage : MonoBehaviour
	{
		private const float ContentWidth = 520f;

		private static readonly string[] Sections = new string[6] { "General", "Damage", "Death", "Valuables", "PiShock", "OpenShock" };

		private readonly List<MaskedKeyInput> _secretInputs = new List<MaskedKeyInput>();

		private readonly List<(SecretEdit Edit, REPOLabel Label)> _secretStatuses = new List<(SecretEdit, REPOLabel)>();

		private readonly List<(SettingEdit Edit, REPOInputField Field)> _textInputs = new List<(SettingEdit, REPOInputField)>();

		private readonly Dictionary<string, List<REPOScrollViewElement>> _providerRows = new Dictionary<string, List<REPOScrollViewElement>>();

		private Plugin? _plugin;

		private REPOPopupPage? _popup;

		private SettingsDraft? _draft;

		private REPOLabel? _status;

		private bool _closing;

		private bool _prompt;

		private bool _applying;

		internal void Initialize(Plugin plugin, REPOPopupPage popup)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Expected O, but got Unknown
			_plugin = plugin;
			_popup = popup;
			_draft = new SettingsDraft(plugin.Settings, null, plugin.PauseForSettingsSave, plugin.ResumeAfterSettingsSave);
			popup.maskPadding = new Padding(0f, 0f, 0f, 100f);
			WidenPage(popup);
			popup.scrollView.scrollSpeed = 3f;
			popup.onEscapePressed = new ShouldCloseMenuDelegate(HandleEscape);
			popup.AddElement((BuilderDelegate)delegate
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				_status = MenuAPI.CreateREPOLabel("Draft changes. Apply updates this session.", (Transform)(object)popup.rectTransform, FooterPosition(46f));
				((TMP_Text)_status.labelTMP).fontSize = 13f;
				((TMP_Text)_status.labelTMP).richText = false;
				((TMP_Text)_status.labelTMP).textWrappingMode = (TextWrappingModes)1;
				((TMP_Text)_status.labelTMP).overflowMode = (TextOverflowModes)0;
				((REPOElement)_status).rectTransform.sizeDelta = new Vector2(520f, 48f);
				((TMP_Text)_status.labelTMP).rectTransform.sizeDelta = ((REPOElement)_status).rectTransform.sizeDelta;
			});
			string[] sections = Sections;
			foreach (string section in sections)
			{
				int childCount = ((Transform)popup.menuScrollBox.scroller).childCount;
				AddLabel(section.ToUpperInvariant(), 17);
				foreach (SettingEdit item in _draft.Entries.Where((SettingEdit edit) => edit.Section == section))
				{
					AddSetting(item);
				}
				foreach (SecretEdit item2 in _draft.Secrets.Where((SecretEdit edit) => edit.Section == section))
				{
					AddSecret(item2);
				}
				string text = section;
				if ((!(text == "PiShock") && !(text == "OpenShock")) || 1 == 0)
				{
					continue;
				}
				List<REPOScrollViewElement> list = new List<REPOScrollViewElement>();
				for (int num2 = childCount; num2 < ((Transform)popup.menuScrollBox.scroller).childCount; num2++)
				{
					REPOScrollViewElement component = ((Component)((Transform)popup.menuScrollBox.scroller).GetChild(num2)).GetComponent<REPOScrollViewElement>();
					if (Object.op_Implicit((Object)(object)component))
					{
						list.Add(component);
					}
				}
				_providerRows.Add(section, list);
			}
			RefreshProviderVisibility();
			REPOSlider[] componentsInChildren = ((Component)this).GetComponentsInChildren<REPOSlider>(true);
			for (int num = 0; num < componentsInChildren.Length; num++)
			{
				FitControlLabel((TMP_Text)(object)componentsInChildren[num].labelTMP);
			}
			REPOToggle[] componentsInChildren2 = ((Component)this).GetComponentsInChildren<REPOToggle>(true);
			for (int num = 0; num < componentsInChildren2.Length; num++)
			{
				FitControlLabel((TMP_Text)(object)componentsInChildren2[num].labelTMP);
			}
			popup.AddElement((BuilderDelegate)delegate
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				AddFooterButton("Apply", Apply, (Transform)(object)popup.rectTransform, FooterPosition(18f));
				AddFooterButton("Back", RequestClose, (Transform)(object)popup.rectTransform, FooterPosition(18f) + new Vector2(170f, 0f));
				AddFooterButton("Disable", DisableShocks, (Transform)(object)popup.rectTransform, FooterPosition(18f) + new Vector2(340f, 0f));
			});
		}

		private static void WidenPage(REPOPopupPage popup)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = popup.maskRectTransform.rect;
			float num = 520f - ((Rect)(ref rect)).width;
			popup.maskPadding = new Padding(0f, 0f, 0f - num, 100f);
			popup.menuScrollBox.scroller.SetSizeWithCurrentAnchors((Axis)0, 520f);
			RectTransform scrollBarRectTransform = popup.scrollBarRectTransform;
			((Transform)scrollBarRectTransform).localPosition = ((Transform)scrollBarRectTransform).localPosition + new Vector3(num, 0f, 0f);
			Transform obj = ((Transform)popup.rectTransform).Find("Panel");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (val != null)
			{
				rect = val.rect;
				val.SetSizeWithCurrentAnchors((Axis)0, ((Rect)(ref rect)).width + num);
				((Transform)val).localPosition = ((Transform)val).localPosition + new Vector3(num * val.pivot.x, 0f, 0f);
			}
		}

		private static void FitControlLabel(TMP_Text label)
		{
			label.enableAutoSizing = true;
			label.fontSizeMin = 12f;
			label.fontSizeMax = 18f;
			label.textWrappingMode = (TextWrappingModes)1;
		}

		private Vector2 FooterPosition(float height)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform maskRectTransform = _popup.maskRectTransform;
			RectTransform rectTransform = _popup.rectTransform;
			Rect rect = maskRectTransform.rect;
			float xMin = ((Rect)(ref rect)).xMin;
			rect = maskRectTransform.rect;
			Vector3 val = ((Transform)rectTransform).InverseTransformPoint(((Transform)maskRectTransform).TransformPoint(new Vector3(xMin, ((Rect)(ref rect)).yMin, 0f)));
			return new Vector2(val.x, val.y - 100f + height);
		}

		private void AddFooterButton(string text, Action action, Transform parent, Vector2 position)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			REPOButton obj = MenuAPI.CreateREPOButton(text, (Action)delegate
			{
				Run(action);
			}, parent, position);
			((TMP_Text)obj.labelTMP).fontSize = 20f;
			obj.overrideButtonSize = new Vector2(85f, 24f);
		}

		private void AddLabel(string text, int size)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			_popup.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform parent)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				REPOLabel val = MenuAPI.CreateREPOLabel(text, parent, default(Vector2));
				((TMP_Text)val.labelTMP).fontSize = size;
				((TMP_Text)val.labelTMP).richText = false;
				((TMP_Text)val.labelTMP).textWrappingMode = (TextWrappingModes)1;
				((TMP_Text)val.labelTMP).overflowMode = (TextOverflowModes)0;
				Vector2 preferredValues = ((TMP_Text)val.labelTMP).GetPreferredValues(text, 520f, float.PositiveInfinity);
				((REPOElement)val).rectTransform.sizeDelta = new Vector2(520f, Math.Max(size + 6, preferredValues.y + 4f));
				((TMP_Text)val.labelTMP).rectTransform.sizeDelta = ((REPOElement)val).rectTransform.sizeDelta;
				return ((REPOElement)val).rectTransform;
			}, 0f, 0f);
		}

		private void AddSetting(SettingEdit edit)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			string label = FriendlyName(edit.Key);
			string description = edit.Entry.Description.Description;
			_popup.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform parent)
			{
				//IL_004b: 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)
				//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_034a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0350: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
				if (edit.Value is bool flag)
				{
					string text = label;
					Action<bool> obj = delegate(bool value)
					{
						edit.Value = value;
					};
					bool flag2 = flag;
					return PadControl(((REPOElement)MenuAPI.CreateREPOToggle(text, obj, parent, default(Vector2), "ON", "OFF", flag2)).rectTransform);
				}
				string key;
				if (edit.Value is int num)
				{
					AcceptableValueRange<int> val = (AcceptableValueRange<int>)(object)edit.Entry.Description.AcceptableValues;
					if (edit.Key == "DurationMilliseconds")
					{
						SliderSteps steps = new SliderSteps(val.MinValue, val.MaxValue, 500f, num, " ms");
						return PadControl(((REPOElement)CreateSteppedSlider(label, steps, num, delegate(float value)
						{
							edit.Value = (int)value;
						}, parent)).rectTransform);
					}
					string text2 = label;
					Action<int> action = delegate(int value)
					{
						edit.Value = value;
					};
					int minValue = val.MinValue;
					int maxValue = val.MaxValue;
					int num2 = num;
					key = edit.Key;
					bool flag2 = ((key == "MaxIntensity" || key == "Intensity") ? true : false);
					string text3 = (flag2 ? "%" : "");
					return PadControl(((REPOElement)MenuAPI.CreateREPOSlider(text2, string.Empty, action, parent, default(Vector2), minValue, maxValue, num2, "", text3, (BarBehavior)0)).rectTransform);
				}
				if (edit.Value is float current)
				{
					AcceptableValueRange<float> val2 = (AcceptableValueRange<float>)(object)edit.Entry.Description.AcceptableValues;
					SliderSteps steps2 = new SliderSteps(val2.MinValue, val2.MaxValue, 0.5f, current);
					return PadControl(((REPOElement)CreateSteppedSlider(label, steps2, current, delegate(float value)
					{
						edit.Value = value;
					}, parent)).rectTransform);
				}
				if (edit.Entry.SettingType.IsEnum)
				{
					Type type = edit.Entry.SettingType;
					string[] names = Enum.GetNames(type);
					return PadControl(((REPOElement)MenuAPI.CreateREPOSlider(label, string.Empty, (Action<string>)delegate(string option)
					{
						edit.Value = Enum.Parse(type, option);
						if (edit.Section == "General" && edit.Key == "Provider")
						{
							RefreshProviderVisibility();
						}
					}, parent, names, edit.Value.ToString(), default(Vector2), "", "", (BarBehavior)0)).rectTransform);
				}
				string text4 = label;
				Action<string> obj2 = delegate(string value)
				{
					edit.Value = value ?? string.Empty;
				};
				key = (string)edit.Value;
				REPOInputField val3 = MenuAPI.CreateREPOInputField(text4, obj2, parent, default(Vector2), false, "", key);
				val3.inputStringSystem.inputTMP.richText = false;
				_textInputs.Add((edit, val3));
				FitControlLabel((TMP_Text)(object)val3.labelTMP);
				return PadControl(((REPOElement)val3).rectTransform);
			}, 0f, 0f);
			if (edit.Key != "Provider" && !string.IsNullOrWhiteSpace(description))
			{
				AddLabel(description, 12);
			}
		}

		private static REPOSlider CreateSteppedSlider(string label, SliderSteps steps, float current, Action<float> changed, Transform parent)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			string text = steps.Labels[Array.IndexOf(steps.Values, current)];
			REPOSlider slider = MenuAPI.CreateREPOSlider(label, string.Empty, (Action<string>)delegate(string option)
			{
				changed(steps.ValueFor(option));
			}, parent, steps.Labels, text, default(Vector2), "", "", (BarBehavior)0);
			Button[] componentsInChildren = ((Component)slider).GetComponentsInChildren<Button>(true);
			((UnityEventBase)componentsInChildren[0].onClick).RemoveAllListeners();
			((UnityEvent)componentsInChildren[0].onClick).AddListener((UnityAction)delegate
			{
				slider.SetValue(Math.Max(0f, slider.value - 1f), true);
			});
			((UnityEventBase)componentsInChildren[1].onClick).RemoveAllListeners();
			((UnityEvent)componentsInChildren[1].onClick).AddListener((UnityAction)delegate
			{
				slider.SetValue(Math.Min(steps.Values.Length - 1, slider.value + 1f), true);
			});
			return slider;
		}

		private static RectTransform PadControl(RectTransform control)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Transform)control).parent;
			RectTransform val = (RectTransform)new GameObject("Setting row", new Type[1] { typeof(RectTransform) }).transform;
			((Transform)val).SetParent(parent, false);
			Vector2 val2 = (val.pivot = Vector2.zero);
			Vector2 anchorMin = (val.anchorMax = val2);
			val.anchorMin = anchorMin;
			Rect rect = control.rect;
			val.sizeDelta = new Vector2(520f, Math.Max(32f, ((Rect)(ref rect)).height) + 12f);
			((Transform)control).SetParent((Transform)(object)val, false);
			((Transform)control).localPosition = new Vector3(0f, 6f, 0f);
			return val;
		}

		private void AddSecret(SecretEdit edit)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			AddLabel(FriendlyName(edit.Key) + " (private)", 15);
			_popup.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform parent)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				REPOLabel val = MenuAPI.CreateREPOLabel(edit.Status, parent, default(Vector2));
				((TMP_Text)val.labelTMP).fontSize = 13f;
				((TMP_Text)val.labelTMP).richText = false;
				((TMP_Text)val.labelTMP).textWrappingMode = (TextWrappingModes)1;
				((REPOElement)val).rectTransform.sizeDelta = new Vector2(520f, 48f);
				((TMP_Text)val.labelTMP).rectTransform.sizeDelta = ((REPOElement)val).rectTransform.sizeDelta;
				_secretStatuses.Add((edit, val));
				return ((REPOElement)val).rectTransform;
			}, 0f, 0f);
			MaskedKeyInput editor = null;
			_popup.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform parent)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				Action<string> obj = delegate
				{
				};
				string empty = string.Empty;
				REPOInputField val = MenuAPI.CreateREPOInputField("Replacement", obj, parent, default(Vector2), false, "", empty);
				editor = ((Component)val).gameObject.AddComponent<MaskedKeyInput>();
				editor.Initialize(val, edit, SetStatus);
				_secretInputs.Add(editor);
				FitControlLabel((TMP_Text)(object)val.labelTMP);
				return PadControl(((REPOElement)val).rectTransform);
			}, 0f, 0f);
			_popup.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform parent)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				//IL_0033: 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_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				RectTransform val = (RectTransform)new GameObject("Credential actions", new Type[1] { typeof(RectTransform) }).transform;
				((Transform)val).SetParent(parent, false);
				Vector2 val2 = (val.pivot = Vector2.zero);
				Vector2 anchorMin = (val.anchorMax = val2);
				val.anchorMin = anchorMin;
				val.sizeDelta = new Vector2(520f, 34f);
				AddSecretButton("Paste", delegate
				{
					editor.PasteReplacement();
				}, (Transform)(object)val, 0f);
				AddSecretButton("Keep saved", delegate
				{
					edit.Reset();
					editor.ClearInput();
					SetStatus("Pending replacement/clear discarded. Saved value unchanged.");
				}, (Transform)(object)val, 120f);
				AddSecretButton("Clear saved", delegate
				{
					Confirm("Clear credential?", "The saved value is removed only when you Apply. No device requests are sent.", delegate
					{
						edit.StageClear();
						editor.ClearInput();
						SetStatus("Credential clearing staged. Apply to save it.");
					});
				}, (Transform)(object)val, 240f);
				return val;
			}, 0f, 0f);
		}

		private void AddSecretButton(string text, Action action, Transform parent, float x)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			REPOButton obj = MenuAPI.CreateREPOButton(text, (Action)delegate
			{
				Run(action);
			}, parent, new Vector2(x, 5f));
			((TMP_Text)obj.labelTMP).enableAutoSizing = false;
			((TMP_Text)obj.labelTMP).fontSize = 14f;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(106f, 24f);
			obj.overrideButtonSize = val;
			((REPOElement)obj).rectTransform.sizeDelta = val;
		}

		private void RefreshProviderVisibility()
		{
			if (_draft == null || !Object.op_Implicit((Object)(object)_popup))
			{
				return;
			}
			string text = _draft.Get<object>("General", "Provider").ToString();
			foreach (string key in _providerRows.Keys)
			{
				bool flag = key == text;
				foreach (REPOScrollViewElement item in _providerRows[key])
				{
					if (!flag)
					{
						REPOInputField[] componentsInChildren = ((Component)item).GetComponentsInChildren<REPOInputField>(true);
						for (int i = 0; i < componentsInChildren.Length; i++)
						{
							componentsInChildren[i].inputStringSystem.isFocused = false;
						}
					}
					item.visibility = flag;
				}
			}
			_popup.scrollView.UpdateElements();
		}

		private void Apply()
		{
			if (_draft == null || _applying || _prompt)
			{
				return;
			}
			foreach (var textInput in _textInputs)
			{
				textInput.Edit.Value = (textInput.Field.inputStringSystem.currentValue ?? string.Empty).Trim();
			}
			foreach (MaskedKeyInput secretInput in _secretInputs)
			{
				secretInput.CapturePending();
			}
			string text = _draft.Validate();
			if (text != null)
			{
				SetStatus(text);
			}
			else if (_draft.RequiresHardwareConfirmation)
			{
				Confirm("Apply live shock settings?", "Future gameplay can operate your device. No test shock is sent. Hardware stop controls remain your responsibility.", delegate
				{
					Commit(hardwareConfirmed: true);
				});
			}
			else
			{
				Commit(hardwareConfirmed: false);
			}
		}

		private void Commit(bool hardwareConfirmed)
		{
			if (_draft == null || _closing)
			{
				return;
			}
			_applying = true;
			try
			{
				if (_draft.TryApply(hardwareConfirmed, out string message) || _draft.CredentialsSavedOnLastApply)
				{
					foreach (MaskedKeyInput secretInput in _secretInputs)
					{
						secretInput.ClearInput();
					}
				}
				SetStatus(message);
			}
			finally
			{
				_applying = false;
			}
		}

		private void DisableShocks()
		{
			if ((Object)(object)_plugin == (Object)null)
			{
				return;
			}
			bool saveOnConfigSet = ((BaseUnityPlugin)_plugin).Config.SaveOnConfigSet;
			((BaseUnityPlugin)_plugin).Config.SaveOnConfigSet = false;
			try
			{
				_plugin.Settings.Enabled.Value = false;
				_plugin.ResetScope();
				try
				{
					((BaseUnityPlugin)_plugin).Config.Save();
					SetStatus("New shocks disabled. An accepted command cannot be recalled. Reopen to refresh settings.");
				}
				catch (Exception)
				{
					SetStatus("Shocks disabled for this session, but saving failed. Repair config permissions before restarting.");
				}
			}
			finally
			{
				((BaseUnityPlugin)_plugin).Config.SaveOnConfigSet = saveOnConfigSet;
			}
		}

		private void Confirm(string title, string message, Action accepted)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (_prompt || _closing)
			{
				return;
			}
			_prompt = true;
			REPOInputField[] componentsInChildren = ((Component)this).GetComponentsInChildren<REPOInputField>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].inputStringSystem.isFocused = false;
			}
			MenuAPI.OpenPopup(title, new Color(1f, 0.65f, 0.2f), message, (Action)delegate
			{
				Run(delegate
				{
					_prompt = false;
					accepted();
				});
			}, (Action)delegate
			{
				_prompt = false;
			});
		}

		private bool HandleEscape()
		{
			Run(RequestClose);
			return false;
		}

		private void RequestClose()
		{
			if (!_prompt)
			{
				SettingsDraft? draft = _draft;
				if (draft != null && draft.HasChanges)
				{
					Confirm("Discard unsaved changes?", "Unsaved settings and replacement credentials will be discarded.", Close);
				}
				else
				{
					Close();
				}
			}
		}

		internal void Close()
		{
			if (_closing)
			{
				return;
			}
			_closing = true;
			try
			{
				ClearSecrets();
				REPOInputField[] componentsInChildren = ((Component)this).GetComponentsInChildren<REPOInputField>();
				foreach (REPOInputField obj in componentsInChildren)
				{
					((Behaviour)obj).enabled = false;
					((Behaviour)obj.inputStringSystem).enabled = false;
				}
			}
			finally
			{
				_draft?.Dispose();
				if (Object.op_Implicit((Object)(object)_popup))
				{
					_popup.ClosePage(false);
				}
			}
		}

		private void ClearSecrets()
		{
			foreach (MaskedKeyInput secretInput in _secretInputs)
			{
				if (Object.op_Implicit((Object)(object)secretInput))
				{
					secretInput.ClearInput();
				}
			}
		}

		private void SetStatus(string message)
		{
			if (Object.op_Implicit((Object)(object)_status))
			{
				((TMP_Text)_status.labelTMP).text = message;
			}
		}

		private void Update()
		{
			if (_closing)
			{
				return;
			}
			foreach (var secretStatus in _secretStatuses)
			{
				if (Object.op_Implicit((Object)(object)secretStatus.Label))
				{
					((TMP_Text)secretStatus.Label.labelTMP).text = secretStatus.Edit.Status;
				}
			}
			SettingsDraft? draft = _draft;
			if (draft != null && draft.HasConflict)
			{
				SetStatus("Config changed elsewhere. Reopen OmniShock before applying.");
			}
		}

		private void Run(Action action)
		{
			if (_closing)
			{
				return;
			}
			try
			{
				action();
			}
			catch (Exception exception)
			{
				_prompt = false;
				SetStatus("Menu action failed. No credential contents are logged.");
				Plugin.ReportHookFailure("Configuration menu", exception);
			}
		}

		private void OnDestroy()
		{
			try
			{
				ClearSecrets();
			}
			finally
			{
				_draft?.Dispose();
				_plugin = null;
				OmniShockMenu.Released(this);
			}
		}

		private static string FriendlyName(string key)
		{
			return key switch
			{
				"ApiKey" => "API key", 
				"ApiUrl" => "API URL", 
				"ShockerId" => "Shocker ID", 
				"DeviceId" => "Device / share ID", 
				"MaxIntensity" => "Maximum intensity", 
				"DurationMilliseconds" => "Duration", 
				"CooldownSeconds" => "Cooldown (seconds)", 
				"IntensityPerHealthLost" => "Intensity per health lost", 
				"MapValueToIntensity" => "Scale by fraction of value lost", 
				"ValueLossMultiplier" => "Value loss multiplier", 
				"ResponsibilityWindowSeconds" => "Release window (s)", 
				"IgnoreHittingEnemies" => "Ignore enemy hits", 
				"ThrownOffensiveGraceSeconds" => "Thrown grace (s)", 
				"HitOffensiveGraceSeconds" => "After-hit grace (s)", 
				_ => key, 
			};
		}
	}
	internal sealed class SecretEdit
	{
		internal const int MaximumLength = 4096;

		internal const string Mask = "********";

		private readonly CredentialEntry _entry;

		private string _replacement = string.Empty;

		private bool _clear;

		internal string Section => _entry.Definition.Section;

		internal string Key => _entry.Definition.Key;

		internal bool IsConfigured => !string.IsNullOrWhiteSpace(_entry.Value);

		internal bool HasReplacement => _replacement.Length > 0;

		internal bool HasChanges
		{
			get
			{
				if (!HasReplacement)
				{
					return _clear;
				}
				return true;
			}
		}

		internal bool WillBeConfigured
		{
			get
			{
				if (!_clear)
				{
					if (!HasReplacement)
					{
						return IsConfigured;
					}
					return true;
				}
				return false;
			}
		}

		internal string? Error { get; private set; }

		internal string Status
		{
			get
			{
				if (Error == null)
				{
					if (!_clear)
					{
						if (!HasReplacement)
						{
							if (!IsConfigured)
							{
								return "No value set";
							}
							return "Value is set — hidden";
						}
						return "Replacement staged — hidden";
					}
					return "Will clear on Apply";
				}
				return "Replacement rejected — not saved";
			}
		}

		internal SecretEdit(CredentialEntry entry)
		{
			_entry = entry;
		}

		internal bool StageReplacement(string? value)
		{
			string text = (value ?? string.Empty).Trim();
			Reset();
			if (text.Length > 4096)
			{
				Error = "Credential exceeds the supported input length.";
			}
			else
			{
				switch (text)
				{
				case "********":
				case "Value is set — hidden":
				case "Key is set — hidden":
					Error = "A hidden-value placeholder is not a credential.";
					break;
				default:
				{
					string text2 = text;
					foreach (char c in text2)
					{
						if (char.IsControl(c) || char.IsWhiteSpace(c))
						{
							Error = "Credential must be one value without internal whitespace or control characters.";
							break;
						}
					}
					break;
				}
				}
			}
			if (Error != null)
			{
				return false;
			}
			_replacement = text;
			return true;
		}

		internal void StageClear()
		{
			Reset();
			_clear = true;
		}

		internal void AddWrite(Action<CredentialEntry, string> addWrite)
		{
			if (HasChanges)
			{
				addWrite(_entry, _clear ? string.Empty : _replacement);
			}
		}

		internal void Reset()
		{
			_replacement = string.Empty;
			_clear = false;
			Error = null;
		}

		public override string ToString()
		{
			return Status;
		}
	}
	internal sealed class SettingEdit
	{
		internal ConfigEntryBase Entry { get; }

		internal object Original { get; private set; }

		internal object Value { get; set; }

		internal string Section => Entry.Definition.Section;

		internal string Key => Entry.Definition.Key;

		internal bool HasChanges => !object.Equals(Original, Value);

		internal SettingEdit(ConfigEntryBase entry)
		{
			Entry = entry;
			Original = (Value = entry.BoxedValue);
		}

		internal string? Validate()
		{
			if (Value == null || Value.GetType() != Entry.SettingType)
			{
				return Section + "/" + Key + ": invalid value type.";
			}
			if (Value is float f && (float.IsNaN(f) || float.IsInfinity(f)))
			{
				return Section + "/" + Key + ": enter a finite number.";
			}
			if (Entry.SettingType.IsEnum && !Enum.IsDefined(Entry.SettingType, Value))
			{
				return Section + "/" + Key + ": choose a supported option.";
			}
			AcceptableValueBase acceptableValues = Entry.Description.AcceptableValues;
			if (acceptableValues != null && !object.Equals(acceptableValues.Clamp(Value), Value))
			{
				return Section + "/" + Key + ": value is outside the permitted range.";
			}
			if (Key == "ApiUrl" && Value is string text && (!Uri.TryCreate(text.Trim(), UriKind.Absolute, out Uri result) || result.Scheme != Uri.UriSchemeHttps || result.UserInfo.Length > 0 || result.Query.Length > 0 || result.Fragment.Length > 0))
			{
				return Section + ": API URL must use HTTPS without credentials, query, or fragment.";
			}
			return null;
		}

		internal void Accept()
		{
			object original = (Value = Entry.BoxedValue);
			Original = original;
		}

		public override string ToString()
		{
			return Section + "/" + Key;
		}
	}
	internal sealed class SettingsDraft : IDisposable
	{
		private readonly ConfigFile _config;

		private readonly Action _save;

		private readonly Action? _pauseRequests;

		private readonly Action? _resumeRequests;

		private readonly ConfigEntry<bool> _enabled;

		private readonly CredentialSettings _credentials;

		private string _credentialRevision;

		private readonly List<SettingEdit> _entries = new List<SettingEdit>();

		private readonly List<SecretEdit> _secrets = new List<SecretEdit>();

		private int _commitThread;

		private volatile bool _hasConflict;

		private bool _disposed;

		internal IReadOnlyList<SettingEdit> Entries => _entries;

		internal IReadOnlyList<SecretEdit> Secrets => _secrets;

		internal bool HasConflict
		{
			get
			{
				if (!_hasConflict)
				{
					return _credentialRevision != _credentials.Revision;
				}
				return true;
			}
		}

		internal bool HasChanges
		{
			get
			{
				if (!_entries.Any((SettingEdit entry) => entry.HasChanges))
				{
					return _secrets.Any((SecretEdit secret) => secret.HasChanges || secret.Error != null);
				}
				return true;
			}
		}

		internal bool RequiresHardwareConfirmation
		{
			get
			{
				if (HasChanges)
				{
					return Get<bool>("General", "Enabled");
				}
				return false;
			}
		}

		internal bool CredentialsSavedOnLastApply { get; private set; }

		internal SettingsDraft(ModSettings settings, Action? save = null, Action? pauseRequests = null, Action? resumeRequests = null)
		{
			_config = settings.Config;
			_save = save ?? new Action(_config.Save);
			_pauseRequests = pauseRequests;
			_resumeRequests = resumeRequests;
			_enabled = settings.Enabled;
			_credentials = settings.Credentials;
			_credentials.Refresh();
			_credentialRevision = _credentials.Revision;
			foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in from pair in (IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)_config
				orderby pair.Key.Section, pair.Key.Key
				select pair)
			{
				_entries.Add(new SettingEdit(item.Value));
			}
			foreach (CredentialEntry entry in _credentials.Entries)
			{
				_secrets.Add(new SecretEdit(entry));
			}
			_config.SettingChanged += OnSettingChanged;
			_credentials.Changed += OnCredentialsChanged;
		}

		internal T Get<T>(string section, string key)
		{
			return (T)_entries.Single((SettingEdit entry) => entry.Section == section && entry.Key == key).Value;
		}

		internal static bool IsCredential(ConfigDefinition definition)
		{
			if (definition.Section == "PiShock" || definition.Section == "OpenShock")
			{
				if (!(definition.Key == "ApiKey") && !(definition.Key == "ShockerId"))
				{
					return definition.Key == "DeviceId";
				}
				return true;
			}
			return false;
		}

		internal string? Validate()
		{
			if (_disposed)
			{
				return "This settings page is closed. Reopen OmniShock.";
			}
			if (HasConflict)
			{
				return "Config changed elsewhere. Close and reopen this page before applying.";
			}
			foreach (SettingEdit entry in _entries)
			{
				string text = entry.Validate();
				if (text != null)
				{
					return text;
				}
			}
			foreach (SecretEdit secret in _secrets)
			{
				if (secret.Error != null)
				{
					return secret.Section + "/" + secret.Key + ": " + secret.Error;
				}
			}
			try
			{
				if (!_credentials.IsCurrent)
				{
					return "Credentials changed in another profile. Close and reopen OmniShock before applying.";
				}
			}
			catch (Exception)
			{
				return "Credential storage is unavailable. Nothing was applied; check local file permissions.";
			}
			if (Get<bool>("General", "Enabled"))
			{
				string provider = Get<object>("General", "Provider").ToString();
				if (_secrets.Any((SecretEdit secret) => secret.Section == provider && !secret.WillBeConfigured))
				{
					return "Selected provider needs a key and device ID before enabling live shocks.";
				}
			}
			return null;
		}

		internal bool TryApply(bool hardwareConfirmed, out string message)
		{
			CredentialsSavedOnLastApply = false;
			string text = Validate();
			if (text != null)
			{
				message = text;
				return false;
			}
			if (RequiresHardwareConfirmation && !hardwareConfirmed)
			{
				message = "Confirm live hardware settings before applying.";
				return false;
			}
			if (!HasChanges)
			{
				message = "No changes to apply.";
				return true;
			}
			List<(ConfigEntryBase, object, object)> list = new List<(ConfigEntryBase, object, object)>();
			bool flag = Get<bool>("General", "Enabled");
			foreach (SettingEdit item in _entries.Where((SettingEdit entry) => entry.HasChanges))
			{
				if ((object)item.Entry != _enabled)
				{
					list.Add((item.Entry, item.Entry.BoxedValue, item.Value));
				}
			}
			Dictionary<string, string> credentialWrites = _credentials.SnapshotLive();
			bool flag2 = _secrets.Any((SecretEdit secret) => secret.HasChanges);
			foreach (SecretEdit secret in _secrets)
			{
				secret.AddWrite(delegate(CredentialEntry entry, string value)
				{
					credentialWrites[entry.Definition.Section + "/" + entry.Definition.Key] = value;
				});
			}
			bool saveOnConfigSet = _config.SaveOnConfigSet;
			Volatile.Write(ref _commitThread, Thread.CurrentThread.ManagedThreadId);
			_config.SaveOnConfigSet = false;
			try
			{
				_enabled.Value = false;
				_pauseRequests?.Invoke();
				foreach (var item2 in list)
				{
					item2.Item1.BoxedValue = item2.Item3;
				}
				if (HasConflict)
				{
					throw new InvalidOperationException("Concurrent configuration change.");
				}
				_save();
				if (HasConflict)
				{
					throw new InvalidOperationException("Concurrent configuration change.");
				}
				if (flag2)
				{
					_credentials.Save(credentialWrites);
					CredentialsSavedOnLastApply = true;
				}
				_credentialRevision = _credentials.Revision;
				if (HasConflict)
				{
					throw new InvalidOperationException("Concurrent configuration change.");
				}
				if (flag)
				{
					_enabled.Value = true;
					if (HasConflict)
					{
						throw new InvalidOperationException("Concurrent configuration change.");
					}
					_save();
					if (HasConflict)
					{
						throw new InvalidOperationException("Concurrent configuration change.");
					}
				}
				foreach (SettingEdit entry in _entries)
				{
					entry.Accept();
				}
				foreach (SecretEdit secret2 in _secrets)
				{
					secret2.Reset();
				}
				_resumeRequests?.Invoke();
				message = (flag ? "Saved. Shocks resumed with updated settings." : "Saved. Shocks remain disabled.");
				return true;
			}
			catch (Exception)
			{
				_enabled.Value = false;
				if (!CredentialsSavedOnLastApply)
				{
					foreach (var item3 in list)
					{
						if (object.Equals(item3.Item1.BoxedValue, item3.Item3))
						{
							item3.Item1.BoxedValue = item3.Item2;
						}
					}
				}
				else
				{
					_credentialRevision = _credentials.Revision;
					foreach (SettingEdit entry2 in _entries)
					{
						entry2.Accept();
					}
					foreach (SecretEdit secret3 in _secrets)
					{
						secret3.Reset();
					}
				}
				SettingEdit settingEdit = _entries.Single((SettingEdit entry) => (object)entry.Entry == _enabled);
				settingEdit.Value = false;
				try
				{
					_save();
					settingEdit.Accept();
					message = (CredentialsSavedOnLastApply ? "Credentials saved, but resuming failed. Shocks remain disabled; check settings before enabling." : "Save failed. Previous settings restored; shocks remain disabled. Check file permissions.");
				}
				catch (Exception)
				{
					message = (CredentialsSavedOnLastApply ? "Credentials saved; shocks disabled for this session. Config repair failed. Repair config before restarting." : "Save failed; shocks disabled for this session. Config repair failed. Repair config before restarting.");
				}
				return false;
			}
			finally
			{
				list.Clear();
				credentialWrites.Clear();
				_config.SaveOnConfigSet = saveOnConfigSet;
				Volatile.Write(ref _commitThread, 0);
			}
		}

		private void OnSettingChanged(object? sender, SettingChangedEventArgs args)
		{
			if (Thread.CurrentThread.ManagedThreadId != Volatile.Read(in _commitThread))
			{
				_hasConflict = true;
			}
		}

		private void OnCredentialsChanged(object? sender, EventArgs args)
		{
			if (Thread.CurrentThread.ManagedThreadId != Volatile.Read(in _commitThread))
			{
				_hasConflict = true;
			}
		}

		public void Dispose()
		{
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			_config.SettingChanged -= OnSettingChanged;
			_credentials.Changed -= OnCredentialsChanged;
			foreach (SecretEdit secret in _secrets)
			{
				secret.Reset();
			}
		}
	}
	internal sealed class SliderSteps
	{
		internal float[] Values { get; }

		internal string[] Labels { get; }

		internal SliderSteps(float minimum, float maximum, float step, float current, string suffix = "")
		{
			if (step <= 0f || minimum > maximum || float.IsNaN(current) || float.IsInfinity(current) || current < minimum || current > maximum)
			{
				throw new ArgumentOutOfRangeException("current");
			}
			SortedSet<float> sortedSet = new SortedSet<float>();
			int num = (int)Math.Ceiling(minimum / step);
			int num2 = (int)Math.Floor(maximum / step);
			for (int i = num; i <= num2; i++)
			{
				sortedSet.Add((float)i * step);
			}
			sortedSet.Add(current);
			Values = sortedSet.ToArray();
			Labels = Values.Select((float value) => value.ToString("0.###", CultureInfo.InvariantCulture) + suffix).ToArray();
		}

		internal float ValueFor(string label)
		{
			return Values[Array.IndexOf(Labels, label)];
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}