using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using BepInEx;
using Colossal.Localization;
using Colossal.UI.Binding;
using ExtendedHotkeys.Settings;
using ExtendedHotkeys.Systems;
using ExtendedHotkeys.Wheels;
using Game;
using Game.Audio;
using Game.Common;
using Game.Input;
using Game.Prefabs;
using Game.SceneFlow;
using Game.Tools;
using Game.UI;
using Game.UI.InGame;
using HarmonyLib;
using HookUILib.Core;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Unity.Entities;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Scripting;
using cohtml.Net;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ExtendedHotkeys")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.5.2")]
[assembly: AssemblyInformationalVersion("0.5.2+d021555aefb63fb6502743599fc2209667294017")]
[assembly: AssemblyProduct("ExtendedHotkeys")]
[assembly: AssemblyTitle("ExtendedHotkeys")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.5.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ExtendedHotkeys
{
	[BepInPlugin("ExtendedHotkeys", "ExtendedHotkeys", "0.5.2")]
	public class Plugin : BaseUnityPlugin
	{
		private void Awake()
		{
			MethodBase[] array = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "ExtendedHotkeys_Cities2Harmony").GetPatchedMethods().ToArray();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin ExtendedHotkeys is loaded! Patched methods " + array.Length));
			MethodBase[] array2 = array;
			foreach (MethodBase methodBase in array2)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Patched method: " + methodBase.Module.Name + ":" + methodBase.Name));
			}
		}
	}
	public sealed class ExtendedHotkeysUI : UIExtension
	{
		public readonly ExtensionType extensionType;

		public readonly string extensionID = "89pleasure.extendedHotkeys";

		public readonly string extensionContent;

		public ExtendedHotkeysUI()
		{
			extensionContent = ((UIExtension)this).LoadEmbeddedResource("ExtendedHotkeys.dist.extended-hotkeys-ui.transpiled.js");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ExtendedHotkeys";

		public const string PLUGIN_NAME = "ExtendedHotkeys";

		public const string PLUGIN_VERSION = "0.5.2";
	}
}
namespace ExtendedHotkeys.Wheels
{
	internal class ElevationToolWheel : WheelBase
	{
		public ProxyAction m_RightMouseClick;

		private readonly NetToolSystem m_NetToolSystem;

		public ElevationToolWheel(ToolSystem toolSystem, NetToolSystem netToolSystem, EntityQuery soundQuery, LocalSettingsItem settings)
			: base(toolSystem, soundQuery, settings)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			m_NetToolSystem = netToolSystem;
			m_RightMouseClick = InputManager.instance.FindAction("Tool", "Mouse Cancel");
			Debug.Log((object)("[ExtendedHotkeys]: " + ToString()));
		}

		public override void HandleAction()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if (!m_Settings.EnableElevationWheel || m_CameraMap == null || !(m_ToolSystem.activeTool is NetToolSystem))
			{
				return;
			}
			if (IsHoldingKey((KeyCode)308))
			{
				m_RightMouseClick.shouldBeEnabled = false;
				m_IsInProgress = true;
				if (m_Settings.EnableElevationReverse ? IsZoomingIn() : IsZoomingOut())
				{
					((ToolBaseSystem)m_NetToolSystem).ElevationUp();
					ToolUXSoundSettingsData singleton = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
					AudioManager.instance.PlayUISound(singleton.m_NetElevationUpSound, 1f);
				}
				else if (m_Settings.EnableElevationReverse ? IsZoomingOut() : IsZoomingIn())
				{
					((ToolBaseSystem)m_NetToolSystem).ElevationDown();
					ToolUXSoundSettingsData singleton2 = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
					AudioManager.instance.PlayUISound(singleton2.m_NetElevationDownSound, 1f);
				}
			}
			else
			{
				m_RightMouseClick.shouldBeEnabled = true;
				m_IsInProgress = false;
			}
		}
	}
	public class NetToolWheel : WheelBase
	{
		protected readonly NetToolSystem m_NetToolSystem;

		public NetToolWheel(ToolSystem toolSystem, NetToolSystem netToolSystem, EntityQuery soundQuery, LocalSettingsItem settings)
			: base(toolSystem, soundQuery, settings)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			m_NetToolSystem = netToolSystem;
			Debug.Log((object)("[ExtendedHotkeys]: " + ToString()));
		}

		public override void HandleAction()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Invalid comparison between Unknown and I4
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected I4, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected I4, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			if (!m_Settings.EnableNetToolWheel || m_CameraMap == null || !(m_ToolSystem.activeTool is NetToolSystem))
			{
				return;
			}
			if (IsHoldingKey((KeyCode)306))
			{
				m_IsInProgress = true;
				if (m_Settings.EnableNetToolReverse ? IsZoomingOut() : IsZoomingIn())
				{
					if ((int)m_NetToolSystem.mode == 5)
					{
						m_NetToolSystem.mode = (Mode)0;
						m_View.TriggerEvent<int>("tool.selectToolMode", 0);
						ToolUXSoundSettingsData singleton = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
						AudioManager.instance.PlayUISound(singleton.m_NetStartSound, 0.5f);
					}
					else
					{
						int num = m_NetToolSystem.mode + 1;
						m_NetToolSystem.mode = (Mode)num;
						m_View.TriggerEvent<int>("tool.selectToolMode", num);
						ToolUXSoundSettingsData singleton2 = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
						AudioManager.instance.PlayUISound(singleton2.m_NetStartSound, 0.5f);
					}
				}
				else if (m_Settings.EnableNetToolReverse ? IsZoomingIn() : IsZoomingOut())
				{
					if ((int)m_NetToolSystem.mode == 0)
					{
						m_NetToolSystem.mode = (Mode)5;
						m_View.TriggerEvent<int>("tool.selectToolMode", 5);
						ToolUXSoundSettingsData singleton3 = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
						AudioManager.instance.PlayUISound(singleton3.m_NetStartSound, 0.5f);
					}
					else
					{
						int num2 = m_NetToolSystem.mode - 1;
						m_NetToolSystem.mode = (Mode)num2;
						m_View.TriggerEvent<int>("tool.selectToolMode", num2);
						ToolUXSoundSettingsData singleton4 = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
						AudioManager.instance.PlayUISound(singleton4.m_NetStartSound, 0.5f);
					}
				}
			}
			else
			{
				m_IsInProgress = false;
			}
		}
	}
	public sealed class TerrainToolBrushSizeWheel : WheelBase
	{
		private readonly TerrainToolSystem m_TerrainToolSystem;

		public TerrainToolBrushSizeWheel(ToolSystem toolSystem, TerrainToolSystem terrainToolSystem, EntityQuery soundQuery, LocalSettingsItem settings)
			: base(toolSystem, soundQuery, settings)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			m_TerrainToolSystem = terrainToolSystem;
			Debug.Log((object)("[ExtendedHotkeys]: " + ToString()));
		}

		public override void HandleAction()
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			if (!m_Settings.EnableBrushSizeWheel || m_CameraMap == null || !(m_ToolSystem.activeTool is TerrainToolSystem))
			{
				return;
			}
			if (IsHoldingKey((KeyCode)306))
			{
				m_IsInProgress = true;
				if (m_Settings.EnableBrushSizeReverse ? IsZoomingOut() : IsZoomingIn())
				{
					float brushSize = ((ToolBaseSystem)m_TerrainToolSystem).brushSize;
					if (!(brushSize < 100f))
					{
						if (!(brushSize < 500f))
						{
							if (!(brushSize < 1000f))
							{
								if (brushSize >= 1000f)
								{
									((ToolBaseSystem)m_TerrainToolSystem).brushSize = 1000f;
								}
							}
							else
							{
								TerrainToolSystem terrainToolSystem = m_TerrainToolSystem;
								((ToolBaseSystem)terrainToolSystem).brushSize = ((ToolBaseSystem)terrainToolSystem).brushSize + 100f;
							}
						}
						else
						{
							TerrainToolSystem terrainToolSystem2 = m_TerrainToolSystem;
							((ToolBaseSystem)terrainToolSystem2).brushSize = ((ToolBaseSystem)terrainToolSystem2).brushSize + 50f;
						}
					}
					else
					{
						TerrainToolSystem terrainToolSystem3 = m_TerrainToolSystem;
						((ToolBaseSystem)terrainToolSystem3).brushSize = ((ToolBaseSystem)terrainToolSystem3).brushSize + 10f;
					}
					ToolUXSoundSettingsData singleton = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
					AudioManager.instance.PlayUISound(singleton.m_NetStartSound, 0.5f);
				}
				else
				{
					if (!(m_Settings.EnableBrushSizeReverse ? IsZoomingIn() : IsZoomingOut()))
					{
						return;
					}
					float brushSize = ((ToolBaseSystem)m_TerrainToolSystem).brushSize;
					if (!(brushSize <= 10f))
					{
						if (!(brushSize < 100f))
						{
							if (!(brushSize < 500f))
							{
								if (brushSize <= 1000f)
								{
									TerrainToolSystem terrainToolSystem4 = m_TerrainToolSystem;
									((ToolBaseSystem)terrainToolSystem4).brushSize = ((ToolBaseSystem)terrainToolSystem4).brushSize - 100f;
								}
							}
							else
							{
								TerrainToolSystem terrainToolSystem5 = m_TerrainToolSystem;
								((ToolBaseSystem)terrainToolSystem5).brushSize = ((ToolBaseSystem)terrainToolSystem5).brushSize - 50f;
							}
						}
						else
						{
							TerrainToolSystem terrainToolSystem6 = m_TerrainToolSystem;
							((ToolBaseSystem)terrainToolSystem6).brushSize = ((ToolBaseSystem)terrainToolSystem6).brushSize - 10f;
						}
					}
					else
					{
						((ToolBaseSystem)m_TerrainToolSystem).brushSize = 10f;
					}
					ToolUXSoundSettingsData singleton2 = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
					AudioManager.instance.PlayUISound(singleton2.m_NetStartSound, 0.5f);
				}
			}
			else
			{
				m_IsInProgress = false;
			}
		}
	}
	public sealed class TerrainToolBrushStrengthWheel : WheelBase
	{
		private readonly TerrainToolSystem m_TerrainToolSystem;

		public TerrainToolBrushStrengthWheel(ToolSystem toolSystem, TerrainToolSystem terrainToolSystem, EntityQuery soundQuery, LocalSettingsItem settings)
			: base(toolSystem, soundQuery, settings)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			m_TerrainToolSystem = terrainToolSystem;
			Debug.Log((object)("[ExtendedHotkeys]: " + ToString()));
		}

		public override void HandleAction()
		{
			//IL_00d0: 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)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			if (!m_Settings.EnableBrushStrengthWheel || m_CameraMap == null || !(m_ToolSystem.activeTool is TerrainToolSystem))
			{
				return;
			}
			if (IsHoldingKey((KeyCode)308))
			{
				m_IsInProgress = true;
				if (m_Settings.EnableBrushStrengthReverse ? IsZoomingOut() : IsZoomingIn())
				{
					float brushStrength = ((ToolBaseSystem)m_TerrainToolSystem).brushStrength;
					if (!(brushStrength < 0.09f))
					{
						if (!(brushStrength < 1f))
						{
							if (brushStrength >= 1f)
							{
								((ToolBaseSystem)m_TerrainToolSystem).brushStrength = 1f;
							}
						}
						else
						{
							TerrainToolSystem terrainToolSystem = m_TerrainToolSystem;
							((ToolBaseSystem)terrainToolSystem).brushStrength = ((ToolBaseSystem)terrainToolSystem).brushStrength + 0.05f;
						}
					}
					else
					{
						TerrainToolSystem terrainToolSystem2 = m_TerrainToolSystem;
						((ToolBaseSystem)terrainToolSystem2).brushStrength = ((ToolBaseSystem)terrainToolSystem2).brushStrength + 0.01f;
					}
					ToolUXSoundSettingsData singleton = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
					AudioManager.instance.PlayUISound(singleton.m_NetStartSound, 0.5f);
				}
				else
				{
					if (!(m_Settings.EnableBrushStrengthReverse ? IsZoomingIn() : IsZoomingOut()))
					{
						return;
					}
					float brushStrength = ((ToolBaseSystem)m_TerrainToolSystem).brushStrength;
					if (!(brushStrength <= 0.01f))
					{
						if (!(brushStrength <= 0.1f))
						{
							if (brushStrength <= 1f)
							{
								TerrainToolSystem terrainToolSystem3 = m_TerrainToolSystem;
								((ToolBaseSystem)terrainToolSystem3).brushStrength = ((ToolBaseSystem)terrainToolSystem3).brushStrength - 0.05f;
							}
						}
						else
						{
							TerrainToolSystem terrainToolSystem4 = m_TerrainToolSystem;
							((ToolBaseSystem)terrainToolSystem4).brushStrength = ((ToolBaseSystem)terrainToolSystem4).brushStrength - 0.01f;
						}
					}
					else
					{
						((ToolBaseSystem)m_TerrainToolSystem).brushStrength = 0.01f;
					}
					ToolUXSoundSettingsData singleton2 = ((EntityQuery)(ref m_SoundQuery)).GetSingleton<ToolUXSoundSettingsData>();
					AudioManager.instance.PlayUISound(singleton2.m_NetStartSound, 0.5f);
				}
			}
			else
			{
				m_IsInProgress = false;
			}
		}
	}
	public abstract class WheelBase
	{
		protected enum WheelSensitivityFactor
		{
			Low = 1,
			Medium,
			High
		}

		protected readonly ToolSystem m_ToolSystem;

		protected EntityQuery m_SoundQuery;

		protected readonly LocalSettingsItem m_Settings;

		protected readonly View m_View;

		private readonly ProxyAction m_MouseZoomAction;

		protected readonly ProxyActionMap m_CameraMap;

		protected bool m_IsInProgress;

		public bool IsActive => m_IsInProgress;

		protected WheelBase(ToolSystem toolSystem, EntityQuery soundQuery, LocalSettingsItem settings)
		{
			//IL_000e: 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)
			m_ToolSystem = toolSystem;
			m_SoundQuery = soundQuery;
			m_Settings = settings;
			m_CameraMap = InputManager.instance.FindActionMap("Camera");
			m_MouseZoomAction = m_CameraMap.FindAction("Zoom Mouse");
			m_View = GameManager.instance.userInterface.view.View;
			m_IsInProgress = false;
		}

		public abstract void HandleAction();

		protected bool IsHoldingKey(KeyCode keyCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Input.GetKey(keyCode);
		}

		protected bool IsZoomingIn(WheelSensitivityFactor sensitivityFactor = WheelSensitivityFactor.Medium)
		{
			return m_MouseZoomAction.ReadValue<float>() < 0f - GetZoomFactor(sensitivityFactor);
		}

		protected bool IsZoomingOut(WheelSensitivityFactor sensitivityFactor = WheelSensitivityFactor.Medium)
		{
			return m_MouseZoomAction.ReadValue<float>() > GetZoomFactor(sensitivityFactor);
		}

		private static float GetZoomFactor(WheelSensitivityFactor factor)
		{
			return factor switch
			{
				WheelSensitivityFactor.Low => 0.02f, 
				WheelSensitivityFactor.High => 0.008f, 
				_ => 0.013f, 
			};
		}
	}
}
namespace ExtendedHotkeys.Systems
{
	internal class ExtendedHotkeysSystem : GameSystemBase
	{
		private GameScreenUISystem m_GameScreenUISystem;

		private ToolSystem m_ToolSystem;

		private NetToolSystem m_NetToolSystem;

		private TerrainToolSystem m_TerrainToolSystem;

		private ToolUXSoundSettingsData m_SoundData;

		private readonly List<WheelBase> m_Wheels = new List<WheelBase>();

		private CameraController m_CameraController;

		public LocalSettings m_LocalSettings;

		private LocalSettingsItem m_Settings;

		private bool m_LocalSettingsLoaded;

		public bool hotkeyPressed;

		public List<KeyCode> availableKeyCodes = new List<KeyCode>(7)
		{
			(KeyCode)304,
			(KeyCode)306,
			(KeyCode)308,
			(KeyCode)303,
			(KeyCode)305,
			(KeyCode)307,
			(KeyCode)32
		};

		private WheelBase ActiveWheel => m_Wheels.Find((WheelBase wheel) => wheel.IsActive);

		private bool IsAnyWheelActive => m_Wheels.Any((WheelBase wheel) => wheel.IsActive);

		[Preserve]
		public ExtendedHotkeysSystem()
		{
		}

		[Preserve]
		protected override void OnCreate()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			//IL_0074: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			((GameSystemBase)this).OnCreate();
			LoadSettings();
			m_ToolSystem = ((ComponentSystemBase)this).World.GetOrCreateSystemManaged<ToolSystem>();
			m_NetToolSystem = ((ComponentSystemBase)this).World.GetExistingSystemManaged<NetToolSystem>();
			m_TerrainToolSystem = ((ComponentSystemBase)this).World.GetExistingSystemManaged<TerrainToolSystem>();
			((ComponentSystemBase)this).World.GetOrCreateSystemManaged<ExtendedHotKeysTranslationSystem>();
			m_GameScreenUISystem = ((ComponentSystemBase)this).World.GetExistingSystemManaged<GameScreenUISystem>();
			EntityQuery entityQuery = ((ComponentSystemBase)this).GetEntityQuery((ComponentType[])(object)new ComponentType[1] { ComponentType.ReadOnly<ToolUXSoundSettingsData>() });
			CreateNetToolBindings();
			m_Wheels.Add(new NetToolWheel(m_ToolSystem, m_NetToolSystem, entityQuery, m_Settings));
			m_Wheels.Add(new ElevationToolWheel(m_ToolSystem, m_NetToolSystem, entityQuery, m_Settings));
			m_Wheels.Add(new TerrainToolBrushSizeWheel(m_ToolSystem, m_TerrainToolSystem, entityQuery, m_Settings));
			m_Wheels.Add(new TerrainToolBrushStrengthWheel(m_ToolSystem, m_TerrainToolSystem, entityQuery, m_Settings));
			Debug.Log((object)"[ExtendedHotkeys] System created!");
		}

		[Preserve]
		protected override void OnUpdate()
		{
			if (!m_LocalSettingsLoaded)
			{
				return;
			}
			CameraController cameraController = default(CameraController);
			if ((Object)(object)m_CameraController == (Object)null && CameraController.TryGet(ref cameraController))
			{
				m_CameraController = cameraController;
			}
			if (m_ToolSystem != null && (Object)(object)m_CameraController != (Object)null && InputManager.instance.mouseOnScreen)
			{
				foreach (WheelBase wheel in m_Wheels)
				{
					wheel.HandleAction();
				}
			}
			m_CameraController.inputEnabled = !IsAnyWheelActive;
		}

		private void CreateCameraMoveReplacement()
		{
		}

		private void CreateNetToolBindings()
		{
			string binding = "<Keyboard>/home";
			if (GameManager.instance.configuration.developerMode)
			{
				Debug.Log((object)"Developer mode is enabled. Set binding to END instead.");
				binding = "<Keyboard>/end";
			}
			AddBinding("ResetElevationToZero", binding, OnResetElevation);
			AddCombinedBinding("SetStraight", "<Keyboard>/q", "<keyboard>/ctrl", delegate(CallbackContext _)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				OnSetNetToolSystemMode(_, (Mode)0);
			});
			AddCombinedBinding("SetCurveTool", "<Keyboard>/w", "<keyboard>/ctrl", delegate(CallbackContext _)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				OnSetNetToolSystemMode(_, (Mode)1);
			});
			AddCombinedBinding("SetAdvCurveTool", "<Keyboard>/e", "<keyboard>/ctrl", delegate(CallbackContext _)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				OnSetNetToolSystemMode(_, (Mode)2);
			});
			AddCombinedBinding("SetContinuousMode", "<Keyboard>/r", "<keyboard>/ctrl", delegate(CallbackContext _)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				OnSetNetToolSystemMode(_, (Mode)3);
			});
			AddCombinedBinding("SetGridMode", "<Keyboard>/t", "<keyboard>/ctrl", delegate(CallbackContext _)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				OnSetNetToolSystemMode(_, (Mode)4);
			});
			AddCombinedBinding("UpdateElevationStep", "<mouse>/rightButton", "<keyboard>/leftAlt", OnElevationScroll);
		}

		private void CreateOpenToolWindowBindings()
		{
			AddBinding("OpenZoning", "<Keyboard>/e", delegate(CallbackContext _)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				OnOpenToolWindow(_, "zoning");
			});
			AddBinding("OpenRoads", "<Keyboard>/r", delegate(CallbackContext _)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				OnOpenToolWindow(_, "roads");
			});
			AddBinding("OpenTerrain", "<Keyboard>/t", delegate(CallbackContext _)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				OnOpenToolWindow(_, "terrain");
			});
		}

		private static object GetEntityPayload(string menuName)
		{
			return new
			{
				__Type = "Unity.Entities.Entity",
				index = GetEntityIndex(menuName),
				version = 1
			};
		}

		private static int GetEntityIndex(string menuName)
		{
			return menuName switch
			{
				"zoning" => 16944, 
				"areas" => 34467, 
				"specialBuildings" => 16993, 
				"roads" => 16941, 
				"power" => 16934, 
				"water" => 16943, 
				"healthcare" => 16937, 
				"garbage" => 16936, 
				"education" => 16933, 
				"fireDepartment" => 16935, 
				"policeDepartment" => 16940, 
				"publicTransport" => 16942, 
				"parks" => 16939, 
				"communication" => 16932, 
				"terrain" => 16938, 
				_ => 1, 
			};
		}

		private void LoadSettings()
		{
			try
			{
				m_LocalSettings = new LocalSettings();
				m_LocalSettings.Init();
				m_LocalSettingsLoaded = true;
				m_Settings = m_LocalSettings.Settings;
			}
			catch (Exception ex)
			{
				Debug.Log((object)("Error loading settings: " + ex.Message));
			}
		}

		private void OnOpenToolWindow(CallbackContext _, string menuName)
		{
			View view = GameManager.instance.userInterface.view.View;
			if (m_GameScreenUISystem.isMenuActive)
			{
				Debug.Log((object)"[ExtendedHotkeys]: Pause menu is active. Not opening tool window.");
				return;
			}
			object entityPayload = GetEntityPayload(menuName);
			view.TriggerEvent<object>("toolbar.selectAssetMenu", entityPayload);
		}

		private void OnSetNetToolSystemMode(CallbackContext _, Mode mode)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected I4, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (m_Settings.EnableNTMGroup && m_ToolSystem.activeTool is NetToolSystem && ((int)mode != 0 || m_Settings.EnableNTMStraight) && ((int)mode != 1 || m_Settings.EnableNTMSimpleCurve) && ((int)mode != 2 || m_Settings.EnableNTMComplexCurve) && ((int)mode != 3 || m_Settings.EnableNTMContinuous) && ((int)mode != 4 || m_Settings.EnableNTMGrid))
			{
				m_NetToolSystem.mode = mode;
				GameManager.instance.userInterface.view.View.TriggerEvent<int>("tool.selectToolMode", (int)mode);
				AudioManager.instance.PlayUISound(m_SoundData.m_NetStartSound, 1f);
			}
		}

		private void OnResetElevation(CallbackContext _)
		{
			//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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			if (m_Settings.EnableElevationReset && m_ToolSystem.activeTool is NetToolSystem)
			{
				((ComponentSystemBase)this).World.GetOrCreateSystemManaged<NetToolSystem>().elevation = 0f;
				EntityQuery entityQuery = ((ComponentSystemBase)this).GetEntityQuery((ComponentType[])(object)new ComponentType[1] { ComponentType.ReadOnly<ToolUXSoundSettingsData>() });
				ToolUXSoundSettingsData singleton = ((EntityQuery)(ref entityQuery)).GetSingleton<ToolUXSoundSettingsData>();
				AudioManager.instance.PlayUISound(singleton.m_NetStartSound, 0.5f);
			}
		}

		private void OnElevationScroll(CallbackContext _)
		{
			//IL_0077: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (m_Settings.EnableElevationStepScroll && m_ToolSystem.activeTool is NetToolSystem && !InputManager.instance.mouseOverUI)
			{
				float num = m_NetToolSystem.elevationStep / 2f;
				num = ((num < 1.25f) ? 10f : num);
				GameManager.instance.userInterface.view.View.TriggerEvent<float>("tool.setElevationStep", num);
				EntityQuery entityQuery = ((ComponentSystemBase)this).GetEntityQuery((ComponentType[])(object)new ComponentType[1] { ComponentType.ReadOnly<ToolUXSoundSettingsData>() });
				ToolUXSoundSettingsData singleton = ((EntityQuery)(ref entityQuery)).GetSingleton<ToolUXSoundSettingsData>();
				AudioManager.instance.PlayUISound(singleton.m_NetStartSound, 0.5f);
			}
		}

		private static void AddBinding(string name, string binding, Action<CallbackContext> callback)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			InputAction val = new InputAction(name, (InputActionType)0, binding, (string)null, (string)null, (string)null);
			val.performed += callback;
			val.Enable();
			Debug.Log((object)("[ExtendedHotkeys]: Added binding " + name + " with key " + binding));
		}

		private static void AddCombinedBinding(string name, string binding, string modifier, Action<CallbackContext> callback)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			InputAction val = new InputAction(name, (InputActionType)0, (string)null, (string)null, (string)null, (string)null);
			CompositeSyntax val2 = InputActionSetupExtensions.AddCompositeBinding(val, "ButtonWithOneModifier", (string)null, (string)null);
			val2 = ((CompositeSyntax)(ref val2)).With("Modifier", modifier, (string)null, (string)null);
			((CompositeSyntax)(ref val2)).With("Button", binding, (string)null, (string)null);
			val.performed += callback;
			val.Enable();
			Debug.Log((object)("[ExtendedHotkeys]: Added binding " + name + " with key combo " + modifier + " + " + binding));
		}
	}
	public class ExtendedHotKeysTranslationSystem : GameSystemBase
	{
		public string Prefix { get; set; } = "ExtendedHotkeys".Trim().ToLower();


		private string LanguageCode { get; set; }

		public string CurrentLanguageCode => LanguageCode;

		private JsonDocument Translations { get; set; }

		public static string FrameworkDescription { get; }

		protected override void OnCreate()
		{
			((GameSystemBase)this).OnCreate();
			LanguageCode = GameManager.instance.localizationManager.activeLocaleId;
			Debug.Log((object)"ExtendedHotKeysTranslationSystem created.");
			LoadCustomTranslations();
		}

		protected override void OnUpdate()
		{
		}

		public void ReloadTranslations(string locale)
		{
			LanguageCode = locale;
			Debug.Log((object)"Reloading translations.");
			LoadCustomTranslations();
		}

		private void LoadCustomTranslations()
		{
			string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "language_pack.data");
			try
			{
				if (!File.Exists(text))
				{
					Debug.Log((object)("Language pack not found at " + text + "."));
					return;
				}
				Debug.Log((object)("Language pack found at " + text + "."));
				using ZipArchive zipArchive = ZipFile.OpenRead(text);
				foreach (ZipArchiveEntry entry in zipArchive.Entries)
				{
					if (entry.FullName.StartsWith(LanguageCode) && entry.FullName.EndsWith(".json"))
					{
						using (StreamReader streamReader = new StreamReader(entry.Open(), Encoding.UTF8))
						{
							string json = streamReader.ReadToEnd();
							Translations = JsonDocument.Parse(json);
							Debug.Log((object)("Successfully loaded custom translations for " + LanguageCode + "."));
							break;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Debug.Log((object)"Failed to load custom translations.");
				Debug.Log((object)ex.Message);
			}
		}

		public string GetTranslation(string key, string fallback = "Translation missing.", params string[] vars)
		{
			if (Translations == null || !Translations.RootElement.TryGetProperty(Prefix + "." + key, out var value))
			{
				return fallback;
			}
			return HandleTranslationString(value.GetString(), fallback, vars);
		}

		public string GetLocalGameTranslation(string id, string fallback = "Translation failed.", params string[] vars)
		{
			string translation = default(string);
			if ((Object)(object)GameManager.instance == (Object)null || !GameManager.instance.localizationManager.activeDictionary.TryGetValue(id, ref translation))
			{
				return fallback;
			}
			return HandleTranslationString(translation, fallback, vars);
		}

		private string HandleTranslationString(string translation, string fallback, params string[] vars)
		{
			if (vars != null && vars.Length != 0)
			{
				if (vars.Length % 2 != 0)
				{
					Debug.Log((object)"Invalid amount of arguments. It must be a even number.");
					return fallback;
				}
				for (int i = 0; i < vars.Length; i += 2)
				{
					string text = vars[i];
					string newValue = vars[i + 1];
					translation = translation.Replace("{" + text + "}", newValue);
				}
				return translation;
			}
			return translation;
		}
	}
	internal class ExtendedHotkeysUISystem : UISystemBase
	{
		private readonly string kGroup = "extendedHotkeys";

		private ExtendedHotkeysSystem m_ExtendedHotkeysSystem;

		private ExtendedHotKeysTranslationSystem m_CustomTranslationSystem;

		private LocalSettingsItem m_Settings;

		private Dictionary<string, string> m_SettingLocalization;

		private Dictionary<SettingKey, Action> toggleActions;

		private Dictionary<SettingKey, Action> expandActions;

		protected override void OnCreate()
		{
			((UISystemBase)this).OnCreate();
			m_ExtendedHotkeysSystem = ((ComponentSystemBase)this).World.GetOrCreateSystemManaged<ExtendedHotkeysSystem>();
			m_CustomTranslationSystem = ((ComponentSystemBase)this).World.GetOrCreateSystemManaged<ExtendedHotKeysTranslationSystem>();
			m_Settings = m_ExtendedHotkeysSystem.m_LocalSettings.Settings;
			toggleActions = new Dictionary<SettingKey, Action>
			{
				{
					SettingKey.DisableMod,
					delegate
					{
						m_Settings.DisableMod = !m_Settings.DisableMod;
					}
				},
				{
					SettingKey.EnableNetToolWheel,
					delegate
					{
						m_Settings.EnableNetToolWheel = !m_Settings.EnableNetToolWheel;
					}
				},
				{
					SettingKey.EnableNetToolReverse,
					delegate
					{
						m_Settings.EnableNetToolReverse = !m_Settings.EnableNetToolReverse;
					}
				},
				{
					SettingKey.EnableElevationWheel,
					delegate
					{
						m_Settings.EnableElevationWheel = !m_Settings.EnableElevationWheel;
					}
				},
				{
					SettingKey.EnableElevationReverse,
					delegate
					{
						m_Settings.EnableElevationReverse = !m_Settings.EnableElevationReverse;
					}
				},
				{
					SettingKey.EnableBrushStrengthWheel,
					delegate
					{
						m_Settings.EnableBrushStrengthWheel = !m_Settings.EnableBrushStrengthWheel;
					}
				},
				{
					SettingKey.EnableBrushSizeWheel,
					delegate
					{
						m_Settings.EnableBrushSizeWheel = !m_Settings.EnableBrushSizeWheel;
					}
				},
				{
					SettingKey.EnableBrushStrengthReverse,
					delegate
					{
						m_Settings.EnableBrushStrengthReverse = !m_Settings.EnableBrushStrengthReverse;
					}
				},
				{
					SettingKey.EnableBrushSizeReverse,
					delegate
					{
						m_Settings.EnableBrushSizeReverse = !m_Settings.EnableBrushSizeReverse;
					}
				},
				{
					SettingKey.EnableSnappingWheel,
					delegate
					{
						m_Settings.EnableSnappingWheel = !m_Settings.EnableSnappingWheel;
					}
				},
				{
					SettingKey.EnableElevationReset,
					delegate
					{
						m_Settings.EnableElevationReset = !m_Settings.EnableElevationReset;
					}
				},
				{
					SettingKey.EnableElevationStepScroll,
					delegate
					{
						m_Settings.EnableElevationStepScroll = !m_Settings.EnableElevationStepScroll;
					}
				},
				{
					SettingKey.ExpandNTMGroup,
					delegate
					{
						m_Settings.EnableNTMGroup = !m_Settings.EnableNTMGroup;
					}
				},
				{
					SettingKey.EnableNTMStraight,
					delegate
					{
						m_Settings.EnableNTMStraight = !m_Settings.EnableNTMStraight;
					}
				},
				{
					SettingKey.EnableNTMSimpleCurve,
					delegate
					{
						m_Settings.EnableNTMSimpleCurve = !m_Settings.EnableNTMSimpleCurve;
					}
				},
				{
					SettingKey.EnableNTMComplexCurve,
					delegate
					{
						m_Settings.EnableNTMComplexCurve = !m_Settings.EnableNTMComplexCurve;
					}
				},
				{
					SettingKey.EnableNTMContinuous,
					delegate
					{
						m_Settings.EnableNTMContinuous = !m_Settings.EnableNTMContinuous;
					}
				},
				{
					SettingKey.EnableNTMGrid,
					delegate
					{
						m_Settings.EnableNTMGrid = !m_Settings.EnableNTMGrid;
					}
				}
			};
			expandActions = new Dictionary<SettingKey, Action>
			{
				{
					SettingKey.ExpandNTMGroup,
					delegate
					{
						m_Settings.ExpandNTMGroup = !m_Settings.ExpandNTMGroup;
					}
				},
				{
					SettingKey.ExpandReverseGroup,
					delegate
					{
						m_Settings.ExpandReverseGroup = !m_Settings.ExpandReverseGroup;
					}
				}
			};
			m_SettingLocalization = new Dictionary<string, string>
			{
				{
					"disableMod",
					m_CustomTranslationSystem.GetTranslation("setting.disableMod", "Disable Mod")
				},
				{
					"disableMod.description",
					m_CustomTranslationSystem.GetTranslation("setting.disableMod.description", "Disable the mod globally.")
				},
				{
					"netToolModeWheel",
					m_CustomTranslationSystem.GetTranslation("setting.netToolModeWheel", "Tool Mode Wheel")
				},
				{
					"netToolModeWheel.description",
					m_CustomTranslationSystem.GetTranslation("setting.netToolModeWheel.description", "Scroll through NetTool modes.")
				},
				{
					"elevationWheel",
					m_CustomTranslationSystem.GetTranslation("setting.elevationWheel", "Elevation Wheel")
				},
				{
					"elevationWheel.description",
					m_CustomTranslationSystem.GetTranslation("setting.elevationWheel.description", "Increase/Decrease elevation.")
				},
				{
					"brushStrength",
					m_CustomTranslationSystem.GetTranslation("setting.brushStrength", "Brush Strength Wheel")
				},
				{
					"brushStrength.description",
					m_CustomTranslationSystem.GetTranslation("setting.brushStrength.description", "Increase/Decrease brush strength.")
				},
				{
					"brushSize",
					m_CustomTranslationSystem.GetTranslation("setting.brushSize", "Brush Size Wheel")
				},
				{
					"brushSize.description",
					m_CustomTranslationSystem.GetTranslation("setting.brushSize.description", "Increase/Decrease brush size.")
				},
				{
					"snappingWheel",
					m_CustomTranslationSystem.GetTranslation("setting.snappingWheel", "Snapping Wheel")
				},
				{
					"snappingWheel.description",
					m_CustomTranslationSystem.GetTranslation("setting.snappingWheel.description", "Increase/Decrease snapping.")
				},
				{
					"reverseScroll",
					m_CustomTranslationSystem.GetTranslation("setting.reverseScroll", "Reverse scroll direction.")
				},
				{
					"reverseScroll.description",
					m_CustomTranslationSystem.GetTranslation("setting.reverseScroll.description", "Reverse scroll direction.")
				},
				{
					"elevationReset",
					m_CustomTranslationSystem.GetTranslation("setting.elevationReset", "Elevation Reset")
				},
				{
					"elevationReset.description",
					m_CustomTranslationSystem.GetTranslation("setting.elevationReset.description", "Resets elevation to ground floor.")
				},
				{
					"elevationStepScroll",
					m_CustomTranslationSystem.GetTranslation("setting.elevationStepScroll", "Elevation Step Scroll")
				},
				{
					"elevationStepScroll.description",
					m_CustomTranslationSystem.GetTranslation("", "Scroll elevation step level.")
				},
				{
					"netToolModes",
					m_CustomTranslationSystem.GetTranslation("Toolbar.TOOL_MODE_TITLE", "Tool Modes")
				},
				{
					"netToolModes.description",
					m_CustomTranslationSystem.GetTranslation("setting.netToolModes.description", "Hop through net tool modes.")
				},
				{
					"netToolModes.straight",
					m_CustomTranslationSystem.GetTranslation("Tools.TOOL_MODE[Straight]", "Straight")
				},
				{
					"netToolModes.curve",
					m_CustomTranslationSystem.GetTranslation("Tools.TOOL_MODE[SimpleCurve]", "Curve")
				},
				{
					"netToolModes.complexCurve",
					m_CustomTranslationSystem.GetTranslation("Tools.TOOL_MODE[ComplexCurve]", "Complex Curve")
				},
				{
					"netToolModes.continuous",
					m_CustomTranslationSystem.GetTranslation("Tools.TOOL_MODE[Continuous]", "Continuous")
				},
				{
					"netToolModes.grid",
					m_CustomTranslationSystem.GetTranslation("Tools.TOOL_MODE[Grid]", "Grid")
				}
			};
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<Dictionary<string, string>>(kGroup, "translations", (Func<Dictionary<string, string>>)(() => m_SettingLocalization), (IWriter<Dictionary<string, string>>)(object)ValueWriters.Nullable<IDictionary<string, string>>((IWriter<IDictionary<string, string>>)(object)new DictionaryWriter<string, string>((IWriter<string>)null, (IWriter<string>)null)), (EqualityComparer<Dictionary<string, string>>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<string>(kGroup, "version", (Func<string>)(() => "0.5.2"), (IWriter<string>)null, (EqualityComparer<string>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "disableMod", (Func<bool>)(() => m_Settings.DisableMod), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableNetToolWheel", (Func<bool>)(() => m_Settings.EnableNetToolWheel), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableNetToolReverse", (Func<bool>)(() => m_Settings.EnableNetToolReverse), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableElevationWheel", (Func<bool>)(() => m_Settings.EnableElevationWheel), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableElevationReverse", (Func<bool>)(() => m_Settings.EnableElevationReverse), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableBrushStrengthWheel", (Func<bool>)(() => m_Settings.EnableBrushStrengthWheel), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableBrushStrengthReverse", (Func<bool>)(() => m_Settings.EnableBrushStrengthReverse), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableBrushSizeWheel", (Func<bool>)(() => m_Settings.EnableBrushSizeWheel), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableBrushSizeReverse", (Func<bool>)(() => m_Settings.EnableBrushSizeReverse), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "expandReverseGroup", (Func<bool>)(() => m_Settings.ExpandReverseGroup), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableElevationReset", (Func<bool>)(() => m_Settings.EnableElevationReset), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "expandNTMGroup", (Func<bool>)(() => m_Settings.ExpandNTMGroup), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableNTMGroup", (Func<bool>)(() => m_Settings.EnableNTMGroup), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableNTMStraight", (Func<bool>)(() => m_Settings.EnableNTMStraight), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableNTMSimpleCurve", (Func<bool>)(() => m_Settings.EnableNTMSimpleCurve), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableNTMComplexCurve", (Func<bool>)(() => m_Settings.EnableNTMComplexCurve), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableNTMContinuous", (Func<bool>)(() => m_Settings.EnableNTMContinuous), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddUpdateBinding((IUpdateBinding)(object)new GetterValueBinding<bool>(kGroup, "enableNTMGrid", (Func<bool>)(() => m_Settings.EnableNTMGrid), (IWriter<bool>)null, (EqualityComparer<bool>)null));
			((UISystemBase)this).AddBinding((IBinding)(object)new TriggerBinding<int>(kGroup, "onToggle", (Action<int>)OnToggle, (IReader<int>)null));
			((UISystemBase)this).AddBinding((IBinding)(object)new TriggerBinding<int>(kGroup, "onExpand", (Action<int>)OnExpand, (IReader<int>)null));
			Debug.Log((object)"ExtendedHotkeysUISystem created.");
		}

		protected override void OnDestroy()
		{
			((UISystemBase)this).OnDestroy();
			Debug.Log((object)"ExtendedHotkeysUISystem destroyed.");
		}

		private async void OnToggle(int settingId)
		{
			if (toggleActions.TryGetValue((SettingKey)Enum.ToObject(typeof(SettingKey), settingId), out var value))
			{
				value();
				await m_ExtendedHotkeysSystem.m_LocalSettings.Save();
			}
			else
			{
				Debug.Log((object)$"Toggle Setting with Id {settingId} not found.");
			}
		}

		private async void OnExpand(int settingId)
		{
			if (expandActions.TryGetValue((SettingKey)Enum.ToObject(typeof(SettingKey), settingId), out var value))
			{
				value();
				await m_ExtendedHotkeysSystem.m_LocalSettings.Save();
			}
			else
			{
				Debug.Log((object)$"Expand setting with Id {settingId} not found.");
			}
		}
	}
}
namespace ExtendedHotkeys.Settings
{
	public class LocalSettings
	{
		public LocalSettingsItem Settings { get; private set; }

		public void Init()
		{
			Load();
		}

		public void Reload()
		{
			Load();
		}

		public async Task Save()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (directoryName == null)
			{
				return;
			}
			string path = Path.Combine(directoryName, "UserSettings.json");
			try
			{
				string value = JsonConvert.SerializeObject((object)Settings);
				await using StreamWriter writer = new StreamWriter(path, append: false, Encoding.UTF8);
				await writer.WriteAsync(value);
			}
			catch (Exception ex)
			{
				Debug.Log((object)("Error saving settings: " + ex.Message));
			}
		}

		private void Load()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (directoryName == null)
			{
				return;
			}
			string text = Path.Combine(directoryName, "UserSettings.json");
			if (!File.Exists(text))
			{
				Debug.Log((object)"No user settings found. Use default settings.");
				text = Path.Combine(directoryName, "DefaultSettings.json");
				if (!File.Exists(text))
				{
					Debug.Log((object)("Error loading settings: " + text + " does not exist."));
					return;
				}
			}
			else
			{
				Debug.Log((object)"User settings successfully loaded.");
			}
			try
			{
				LocalSettingsItem localSettingsItem = JsonConvert.DeserializeObject<LocalSettingsItem>(File.ReadAllText(text));
				if (localSettingsItem != null)
				{
					Settings = localSettingsItem;
				}
			}
			catch (Exception ex)
			{
				Debug.Log((object)("Error loading settings: " + ex.Message));
			}
		}
	}
	public class LocalSettingsItem
	{
		public string Version { get; } = "0.5.2";


		public bool DisableMod { get; set; }

		public bool EnableNetToolWheel { get; set; } = true;


		public bool EnableNetToolReverse { get; set; } = true;


		public bool EnableElevationWheel { get; set; } = true;


		public bool EnableElevationReverse { get; set; } = true;


		public bool EnableBrushStrengthWheel { get; set; } = true;


		public bool EnableBrushStrengthReverse { get; set; } = true;


		public bool EnableBrushSizeWheel { get; set; } = true;


		public bool EnableBrushSizeReverse { get; set; } = true;


		public bool EnableNetToolHotkeys { get; set; } = true;


		public bool EnableSnappingWheel { get; set; } = true;


		public bool EnableElevationReset { get; set; } = true;


		public bool EnableElevationStepScroll { get; set; } = true;


		public bool ExpandReverseGroup { get; set; }

		public bool ExpandNTMGroup { get; set; }

		public bool EnableNTMGroup { get; set; } = true;


		public bool EnableNTMStraight { get; set; } = true;


		public bool EnableNTMSimpleCurve { get; set; } = true;


		public bool EnableNTMComplexCurve { get; set; } = true;


		public bool EnableNTMContinuous { get; set; } = true;


		public bool EnableNTMGrid { get; set; } = true;


		public KeyCode NetToolKeyCode { get; set; } = (KeyCode)306;


		public KeyCode SnappingKeyCode { get; set; } = (KeyCode)304;


		public KeyCode ElevationKeyCode { get; set; } = (KeyCode)308;

	}
	public enum SettingKey
	{
		DisableMod = 0,
		EnableNetToolWheel = 1,
		EnableElevationWheel = 2,
		EnableSnappingWheel = 3,
		EnableElevationReset = 4,
		ExpandNTMGroup = 5,
		EnableNTMGroup = 5,
		EnableNTMStraight = 6,
		EnableNTMSimpleCurve = 7,
		EnableNTMComplexCurve = 8,
		EnableNTMContinuous = 9,
		EnableNTMGrid = 10,
		EnableElevationStepScroll = 12,
		EnableNetToolReverse = 13,
		EnableElevationReverse = 14,
		EnableBrushSizeWheel = 15,
		EnableBrushStrengthWheel = 16,
		EnableBrushSizeReverse = 17,
		EnableBrushStrengthReverse = 18,
		ExpandReverseGroup = 19
	}
}
namespace ExtendedHotkeys.Patches
{
	[HarmonyPatch(typeof(LocalizationManager), "SetActiveLocale")]
	internal class LocalizationManager_Patches
	{
		private static void Postfix(string localeId)
		{
			if (World.DefaultGameObjectInjectionWorld != null)
			{
				ExtendedHotKeysTranslationSystem orCreateSystemManaged = World.DefaultGameObjectInjectionWorld.GetOrCreateSystemManaged<ExtendedHotKeysTranslationSystem>();
				if (orCreateSystemManaged.CurrentLanguageCode != localeId)
				{
					orCreateSystemManaged.ReloadTranslations(localeId);
				}
			}
		}
	}
	[HarmonyPatch(typeof(SystemOrder))]
	public static class SystemOrder_Patches
	{
		[HarmonyPatch("Initialize")]
		[HarmonyPostfix]
		public static void Postfix(UpdateSystem updateSystem)
		{
			if (updateSystem != null)
			{
				updateSystem.UpdateAt<ExtendedHotKeysTranslationSystem>((SystemUpdatePhase)22);
			}
			if (updateSystem != null)
			{
				updateSystem.UpdateAt<ExtendedHotkeysUISystem>((SystemUpdatePhase)22);
			}
			if (updateSystem != null)
			{
				updateSystem.UpdateAt<ExtendedHotkeysSystem>((SystemUpdatePhase)17);
			}
		}
	}
}