using System;
using System.Collections;
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 BepInEx;
using BepInEx.Logging;
using Colossal.IO.AssetDatabase;
using Colossal.Json;
using Colossal.Localization;
using Colossal.UI;
using Colossal.UI.Binding;
using CustomSurfaces;
using ExtraLandscapingTools.Patches;
using Game;
using Game.Common;
using Game.Prefabs;
using Game.Rendering;
using Game.SceneFlow;
using Game.Tools;
using Game.UI;
using Game.UI.InGame;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Entities;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ExtraLandscapingTools")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("This mod aims to add features and improve existing ones for the game's landscaping tool.")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1+e38dc88a63af35685c5dd2776b08dc1dce29aa22")]
[assembly: AssemblyProduct("ExtraLandscapingTools")]
[assembly: AssemblyTitle("ExtraLandscapingTools")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.1.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 CustomSurfaces
{
	public class JSONMaterail
	{
		public Dictionary<string, float> Float = new Dictionary<string, float>();

		public Dictionary<string, Vector4> Vector = new Dictionary<string, Vector4>();
	}
}
namespace ExtraLandscapingTools
{
	public class CustomDecals
	{
		public static void CreateCustomDecals(RenderPrefab renderBasePrefab)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			Material val = renderBasePrefab.ObtainMaterial(0, true);
			string[] propertyNames = val.GetPropertyNames((MaterialPropertyType)0);
			foreach (string text in propertyNames)
			{
				Plugin.Logger.LogMessage((object)$"Float : {text} | {val.GetFloat(text)}");
			}
			string[] propertyNames2 = val.GetPropertyNames((MaterialPropertyType)2);
			foreach (string text2 in propertyNames2)
			{
				Plugin.Logger.LogMessage((object)$"Vector : {text2} | {val.GetVector(text2)}");
			}
			string[] propertyNames3 = val.GetPropertyNames((MaterialPropertyType)4);
			foreach (string text3 in propertyNames3)
			{
				Plugin.Logger.LogMessage((object)("Texture : " + text3));
			}
		}
	}
	public class ELT
	{
		public enum ELT_ExtensionType
		{
			Other,
			Surfaces,
			Decals,
			Assets
		}

		public static PrefabSystem m_PrefabSystem;

		public static RenderingSystem m_RenderingSystem;

		public static EntityManager m_EntityManager;

		public static Dictionary<string, ELT_ExtensionType> ELT_Extensions { get; private set; } = new Dictionary<string, ELT_ExtensionType>();


		internal static Stream GetEmbedded(string embeddedPath)
		{
			return Assembly.GetExecutingAssembly().GetManifestResourceStream("ExtraLandscapingTools.embedded." + embeddedPath);
		}

		public static Texture2D ResizeTexture(Texture texture, int newSize, string savePath = null)
		{
			//IL_0057: 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
			//IL_0079: 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_003b: Expected O, but got Unknown
			if (texture == null)
			{
				return null;
			}
			Texture2D val = (Texture2D)(object)((texture is Texture2D) ? texture : null);
			if (val == null)
			{
				val = new Texture2D(texture.width, texture.height, (TextureFormat)4, true);
				Graphics.CopyTexture(texture, (Texture)(object)val);
			}
			RenderTexture temporary = RenderTexture.GetTemporary(newSize, newSize);
			Graphics.Blit(texture, temporary);
			Texture2D val2 = new Texture2D(newSize, newSize, val.format, true);
			RenderTexture.active = temporary;
			val2.ReadPixels(new Rect(0f, 0f, (float)newSize, (float)newSize), 0, 0);
			val2.Apply();
			RenderTexture.active = null;
			RenderTexture.ReleaseTemporary(temporary);
			if (savePath != null)
			{
				File.WriteAllBytes(savePath, ImageConversion.EncodeToPNG(val2));
			}
			return val2;
		}

		internal static string GetIcon(PrefabBase prefab)
		{
			if (File.Exists(GameManager_Awake.resourcesIcons + "/" + ((object)prefab).GetType().Name + "/" + ((Object)prefab).name + ".svg"))
			{
				return GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/Icons/" + ((object)prefab).GetType().Name + "/" + ((Object)prefab).name + ".svg";
			}
			if (prefab is SurfacePrefab)
			{
				return "Media/Game/Icons/LotTool.svg";
			}
			if (prefab is UIAssetCategoryPrefab)
			{
				return "Media/Game/Icons/LotTool.svg";
			}
			if (prefab is UIAssetMenuPrefab)
			{
				return GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/Icons/Misc/placeholder.svg";
			}
			if (((Object)prefab).name.ToLower().Contains("decal") || ((Object)prefab).name.ToLower().Contains("roadarrow"))
			{
				return GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/Icons/Misc/placeholder.svg";
			}
			return GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/Icons/Misc/placeholder.svg";
		}

		public static void RegisterELTExtension(string extensionID, ELT_ExtensionType eLT_ExtensionType)
		{
			if (!ELT_Extensions.ContainsKey(extensionID))
			{
				ELT_Extensions.Add(extensionID, eLT_ExtensionType);
			}
		}
	}
	internal class Localization
	{
		internal static Dictionary<string, Dictionary<string, string>> localization;

		internal static void AddCustomLocal(LocaleAsset localeAsset)
		{
			if (localization == null)
			{
				LoadLocalization();
			}
			string key = localeAsset.localeId;
			if (!localization.ContainsKey(key))
			{
				key = "en-US";
			}
			foreach (string key2 in localization[key].Keys)
			{
				if (localeAsset.data.entries.ContainsKey(key2))
				{
					localeAsset.data.entries[key2] = localization[key][key2];
				}
				else
				{
					localeAsset.data.entries.Add(key2, localization[key][key2]);
				}
				if (localeAsset.data.indexCounts.ContainsKey(key2))
				{
					localeAsset.data.indexCounts[key2] = localeAsset.data.indexCounts.Count;
				}
				else
				{
					localeAsset.data.indexCounts.Add(key2, localeAsset.data.indexCounts.Count);
				}
			}
		}

		internal static void LoadLocalization()
		{
			localization = Decoder.Decode(new StreamReader(ELT.GetEmbedded("Localization.Localization.jsonc")).ReadToEnd()).Make<LocalizationJS>().Localization;
			if (CustomSurfaces.FolderToLoadSurface.Count > 0)
			{
				CustomSurfaces.LoadLocalization();
			}
		}
	}
	[Serializable]
	internal class LocalizationJS
	{
		public Dictionary<string, Dictionary<string, string>> Localization = new Dictionary<string, Dictionary<string, string>>();
	}
	public class Prefab
	{
		internal static readonly Dictionary<string, List<PrefabBase>> failedPrefabs = new Dictionary<string, List<PrefabBase>>();

		internal static UIAssetCategoryPrefab GetExistingToolCategory(PrefabSystem prefabSystem, PrefabBase prefabBase, string cat)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			PrefabBase val = default(PrefabBase);
			if (prefabSystem.TryGetPrefab(new PrefabID("UIAssetCategoryPrefab", cat), ref val))
			{
				UIAssetCategoryPrefab val2 = (UIAssetCategoryPrefab)(object)((val is UIAssetCategoryPrefab) ? val : null);
				if (val2 != null)
				{
					return val2;
				}
			}
			AddPrefabToFailedPrefabList(prefabBase, cat);
			return null;
		}

		internal static UIAssetCategoryPrefab GetOrCreateNewToolCategory(PrefabSystem prefabSystem, PrefabBase prefabBase, string menu, string cat, string behindcat = null, string iconPath = null)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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)
			PrefabBase val = default(PrefabBase);
			if (prefabSystem.TryGetPrefab(new PrefabID("UIAssetCategoryPrefab", cat), ref val))
			{
				UIAssetCategoryPrefab val2 = (UIAssetCategoryPrefab)(object)((val is UIAssetCategoryPrefab) ? val : null);
				if (val2 != null)
				{
					return val2;
				}
			}
			UIAssetCategoryPrefab val3 = null;
			if (behindcat != null)
			{
				PrefabBase val4 = default(PrefabBase);
				if (prefabSystem.TryGetPrefab(new PrefabID("UIAssetCategoryPrefab", behindcat), ref val4))
				{
					UIAssetCategoryPrefab val5 = (UIAssetCategoryPrefab)(object)((val4 is UIAssetCategoryPrefab) ? val4 : null);
					if (val5 != null)
					{
						val3 = val5;
						goto IL_0089;
					}
				}
				AddPrefabToFailedPrefabList(prefabBase, behindcat);
				return null;
			}
			goto IL_0089;
			IL_0089:
			PrefabBase val6 = default(PrefabBase);
			if (prefabSystem.TryGetPrefab(new PrefabID("UIAssetMenuPrefab", menu), ref val6))
			{
				UIAssetMenuPrefab val7 = (UIAssetMenuPrefab)(object)((val6 is UIAssetMenuPrefab) ? val6 : null);
				if (val7 != null)
				{
					UIAssetCategoryPrefab val2 = ScriptableObject.CreateInstance<UIAssetCategoryPrefab>();
					((Object)val2).name = cat;
					val2.m_Menu = val7;
					UIObject val8 = ((PrefabBase)val2).AddComponent<UIObject>();
					val8.m_Icon = iconPath ?? ELT.GetIcon((PrefabBase)(object)val2);
					if ((Object)(object)val3 != (Object)null)
					{
						val8.m_Priority = ((ComponentBase)val3).GetComponent<UIObject>().m_Priority + 1;
					}
					((ComponentBase)val8).active = true;
					val8.m_IsDebugObject = false;
					prefabSystem.AddPrefab((PrefabBase)(object)val2, (string)null, (PrefabBase)null, (ComponentBase)null);
					return val2;
				}
			}
			AddPrefabToFailedPrefabList(prefabBase, menu);
			return null;
		}

		private static void AddPrefabToFailedPrefabList(PrefabBase prefabBase, string cat)
		{
			if (failedPrefabs.ContainsKey(cat))
			{
				failedPrefabs[cat].Add(prefabBase);
				return;
			}
			failedPrefabs.Add(cat, new List<PrefabBase>());
			failedPrefabs[cat].Add(prefabBase);
		}
	}
	public class CustomSurfaces
	{
		internal static Dictionary<PrefabBase, string> SurfacesDataBase = new Dictionary<PrefabBase, string>();

		internal static List<string> FolderToLoadSurface = new List<string>();

		public static void AddCustomSurfacesFolder(string path)
		{
			if (!FolderToLoadSurface.Contains(path))
			{
				FolderToLoadSurface.Add(path);
				GameManager_InitializeThumbnails.pathToIconToLoad.Add(new DirectoryInfo(path).Parent.FullName);
			}
		}

		internal static void LoadLocalization()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (string item in FolderToLoadSurface)
			{
				string[] directories = Directory.GetDirectories(item);
				foreach (string path in directories)
				{
					if (!dictionary.ContainsKey("SubServices.NAME[" + new DirectoryInfo(path).Name + " Surfaces]"))
					{
						dictionary.Add("SubServices.NAME[" + new DirectoryInfo(path).Name + " Surfaces]", new DirectoryInfo(path).Name);
					}
					if (!dictionary.ContainsKey("Assets.SUB_SERVICE_DESCRIPTION[" + new DirectoryInfo(path).Name + " Surfaces]"))
					{
						dictionary.Add("Assets.SUB_SERVICE_DESCRIPTION[" + new DirectoryInfo(path).Name + " Surfaces]", new DirectoryInfo(path).Name);
					}
					string[] directories2 = Directory.GetDirectories(path);
					foreach (string path2 in directories2)
					{
						dictionary.Add("Assets.NAME[" + new DirectoryInfo(path2).Name + "]", new DirectoryInfo(path2).Name);
						dictionary.Add("Assets.DESCRIPTION[" + new DirectoryInfo(path2).Name + "]", new DirectoryInfo(path2).Name);
					}
				}
			}
			foreach (string key in Localization.localization.Keys)
			{
				foreach (string key2 in dictionary.Keys)
				{
					if (!Localization.localization[key].ContainsKey(key2))
					{
						Localization.localization[key].Add(key2, dictionary[key2]);
					}
				}
			}
		}

		internal static void CreateCustomSurfaces(Material material)
		{
			foreach (string item in FolderToLoadSurface)
			{
				string[] directories = Directory.GetDirectories(item);
				foreach (string path in directories)
				{
					string[] directories2 = Directory.GetDirectories(path);
					foreach (string folderPath in directories2)
					{
						CreateCustomSurface(ELT.m_PrefabSystem, folderPath, material, new DirectoryInfo(path).Name);
					}
				}
			}
		}

		private static void CreateCustomSurface(PrefabSystem prefabSystem, string folderPath, Material material, string CatName)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00b1: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Expected O, but got Unknown
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(folderPath + "\\_BaseColorMap.png"))
			{
				Plugin.Logger.LogError((object)("No _BaseColorMap.png file for the " + new DirectoryInfo(folderPath).Name + " surface in " + CatName + " category."));
				return;
			}
			SurfacePrefab val = (SurfacePrefab)ScriptableObject.CreateInstance("SurfacePrefab");
			((Object)val).name = new DirectoryInfo(folderPath).Name;
			((AreaPrefab)val).m_Color = new Color(255f, 255f, 255f, 0.05f);
			SurfacePrefab val2 = (SurfacePrefab)ScriptableObject.CreateInstance("SurfacePrefab");
			((Object)val2).name = ((Object)val).name + "_Placeholder";
			Material val3 = new Material(material);
			val3.SetVector("_BaseColor", new Vector4(1f, 1f, 1f, 1f));
			val3.SetFloat("_Metallic", 0.5f);
			val3.SetFloat("_Smoothness", 0.5f);
			val3.SetFloat("colossal_UVScale", 0.5f);
			if (File.Exists(folderPath + "\\surface.json"))
			{
				JSONMaterail jSONMaterail = Decoder.Decode(File.ReadAllText(folderPath + "\\surface.json")).Make<JSONMaterail>();
				foreach (string key in jSONMaterail.Float.Keys)
				{
					val3.SetFloat(key, jSONMaterail.Float[key]);
				}
				foreach (string key2 in jSONMaterail.Vector.Keys)
				{
					val3.SetVector(key2, jSONMaterail.Vector[key2]);
				}
			}
			try
			{
				byte[] array = File.ReadAllBytes(folderPath + "\\_BaseColorMap.png");
				Texture2D val4 = new Texture2D(1, 1);
				if (!ImageConversion.LoadImage(val4, array))
				{
					Debug.LogError((object)("[ELT] Failed to Load the BaseColorMap image for the " + ((Object)val).name + " surface."));
					return;
				}
				if (!File.Exists(folderPath + "\\icon.png"))
				{
					ELT.ResizeTexture((Texture)(object)val4, 64, folderPath + "\\icon.png");
				}
				val3.SetTexture("_BaseColorMap", (Texture)(object)val4);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)ex);
				return;
			}
			try
			{
				byte[] array = File.ReadAllBytes(folderPath + "\\_NormalMap.png");
				Texture2D val5 = new Texture2D(1, 1);
				if (ImageConversion.LoadImage(val5, array))
				{
					val3.SetTexture("_NormalMap", (Texture)(object)val5);
				}
			}
			catch
			{
			}
			try
			{
				byte[] array = File.ReadAllBytes(folderPath + "\\_MaskMap.png");
				Texture2D val6 = new Texture2D(1, 1);
				if (ImageConversion.LoadImage(val6, array))
				{
					val3.SetTexture("_MaskMap", (Texture)(object)val6);
				}
			}
			catch
			{
			}
			RenderedArea val7 = ((PrefabBase)val2).AddComponent<RenderedArea>();
			val7.m_RendererPriority = GetRendererPriorityByCat(CatName);
			val7.m_LodBias = 0f;
			val7.m_Roundness = 1f;
			val7.m_Material = val3;
			PlaceholderArea val8 = ((PrefabBase)val2).AddComponent<PlaceholderArea>();
			SpawnableArea val9 = ((PrefabBase)val).AddComponent<SpawnableArea>();
			val9.m_Placeholders = (AreaPrefab[])(object)new AreaPrefab[1];
			val9.m_Placeholders[0] = (AreaPrefab)(object)val2;
			RenderedArea val10 = ((PrefabBase)val).AddComponent<RenderedArea>();
			val10.m_RendererPriority = GetRendererPriorityByCat(CatName);
			val10.m_LodBias = 0f;
			val10.m_Roundness = 1f;
			val10.m_Material = val3;
			if (File.Exists(folderPath + "\\icon.png"))
			{
				byte[] array = File.ReadAllBytes(folderPath + "\\icon.png");
				Texture2D val11 = new Texture2D(1, 1);
				if (ImageConversion.LoadImage(val11, array) && (((Texture)val11).width > 64 || ((Texture)val11).height > 64))
				{
					ELT.ResizeTexture((Texture)(object)val11, 64, folderPath + "\\icon.png");
				}
			}
			UIObject val12 = ((PrefabBase)val).AddComponent<UIObject>();
			((ComponentBase)val12).active = true;
			val12.m_IsDebugObject = false;
			val12.m_Icon = (File.Exists(folderPath + "\\icon.png") ? (GameManager_InitializeThumbnails.COUIBaseLocation + "/CustomSurfaces/" + CatName + "/" + new DirectoryInfo(folderPath).Name + "/icon.png") : ELT.GetIcon((PrefabBase)(object)val));
			val12.m_Priority = -1;
			val12.m_Group = (UIGroupPrefab)(object)SetupUIGroupe(prefabSystem, (PrefabBase)(object)val, CatName);
			prefabSystem.AddPrefab((PrefabBase)(object)val, (string)null, (PrefabBase)null, (ComponentBase)null);
			prefabSystem.AddPrefab((PrefabBase)(object)val2, (string)null, (PrefabBase)null, (ComponentBase)null);
		}

		internal static UIAssetCategoryPrefab SetupUIGroupe(PrefabSystem prefabSystem, PrefabBase prefab, string cat = null)
		{
			if (cat == null)
			{
				cat = GetCatByRendererPriority(((ComponentBase)prefab).GetComponent<RenderedArea>().m_RendererPriority);
			}
			if (!SurfacesDataBase.ContainsKey(prefab))
			{
				SurfacesDataBase.Add(prefab, cat);
			}
			if (FolderToLoadSurface.Count > 0)
			{
				return Prefab.GetOrCreateNewToolCategory(prefabSystem, prefab, "Custom Surfaces", SurfacesDataBase[prefab] + " Surfaces");
			}
			return Prefab.GetOrCreateNewToolCategory(prefabSystem, prefab, "Landscaping", "Surfaces", "Terraforming");
		}

		internal static int GetRendererPriorityByCat(string cat)
		{
			if (1 == 0)
			{
			}
			int result = cat switch
			{
				"Ground" => -100, 
				"Grass" => -99, 
				"Sand" => -98, 
				"Concrete" => -97, 
				"Wood" => -97, 
				"Pavement" => -96, 
				"Tiles" => -95, 
				_ => -100, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static string GetCatByRendererPriority(int i)
		{
			if (1 == 0)
			{
			}
			string result = i switch
			{
				-100 => "Ground", 
				-99 => "Ground", 
				-98 => "Ground", 
				-97 => "Concrete", 
				-96 => "Concrete", 
				-95 => "Tiles", 
				_ => "Misc", 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class ELT_UI : UISystemBase
	{
		private static readonly GameObject eLT_UI_Object = new GameObject();

		internal static ELT_UI_Mono eLT_UI_Mono;

		private static GetterValueBinding<bool> showMarker;

		internal static bool isMarkerVisible = false;

		protected override void OnCreate()
		{
			//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)
			((UISystemBase)this).OnCreate();
			ELT.m_RenderingSystem = ((ComponentSystemBase)this).World.GetOrCreateSystemManaged<RenderingSystem>();
			ELT.m_EntityManager = ((ComponentSystemBase)this).EntityManager;
			eLT_UI_Mono = eLT_UI_Object.AddComponent<ELT_UI_Mono>();
			((UISystemBase)this).AddBinding((IBinding)(object)(showMarker = new GetterValueBinding<bool>("elt", "showmarker", (Func<bool>)(() => ELT.m_RenderingSystem.markersVisible), (IWriter<bool>)null, (EqualityComparer<bool>)null)));
			((UISystemBase)this).AddBinding((IBinding)(object)new TriggerBinding<bool, bool>("elt", "showmarker", (Action<bool, bool>)ShowMarker, (IReader<bool>)null, (IReader<bool>)null));
		}

		public static void ShowMarker(bool b, bool forceUpdate = false)
		{
			ELT.m_RenderingSystem.markersVisible = b;
			showMarker.Update();
		}

		internal static string GetStringFromEmbbededJSFile(string path)
		{
			return new StreamReader(ELT.GetEmbedded("UI." + path)).ReadToEnd();
		}
	}
	internal class ELT_UI_Mono : MonoBehaviour
	{
		internal void ChangeUiNextFrame(string js)
		{
			((MonoBehaviour)this).StartCoroutine(ChangeUI(js));
		}

		private IEnumerator ChangeUI(string js)
		{
			yield return (object)new WaitForEndOfFrame();
			GameManager.instance.userInterface.view.View.ExecuteScript(js);
			yield return null;
		}
	}
	[BepInPlugin("ExtraLandscapingTools", "ExtraLandscapingTools", "0.2.1")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin ExtraLandscapingTools is loaded!");
			Harmony val = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "ExtraLandscapingTools_Cities2Harmony");
			MethodBase[] array = val.GetPatchedMethods().ToArray();
			Logger.LogInfo((object)("Plugin ExtraLandscapingTools made patches! Patched methods: " + array.Length));
			MethodBase[] array2 = array;
			foreach (MethodBase methodBase in array2)
			{
				Logger.LogInfo((object)("Patched method: " + methodBase.Module.Name + ":" + methodBase.Name));
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ExtraLandscapingTools";

		public const string PLUGIN_NAME = "ExtraLandscapingTools";

		public const string PLUGIN_VERSION = "0.2.1";
	}
}
namespace ExtraLandscapingTools.Patches
{
	[HarmonyPatch(typeof(GameManager), "Awake")]
	internal class GameManager_Awake
	{
		private static readonly string PathToParent = Directory.GetParent(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)).FullName;

		public static readonly string PathToMods = Path.Combine(PathToParent, "ExtraLandscapingTools_mods");

		public static readonly string PathToCustomBrushes = Path.Combine(PathToMods, "CustomBrushes");

		public static readonly string PathToCustomSurface = Path.Combine(PathToMods, "CustomSurfaces");

		private static readonly string pathToZip = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\resources.zip";

		internal static readonly string resources = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "resources");

		internal static readonly string resourcesIcons = Path.Combine(resources, "Icons");

		internal static readonly string resourcesBrushes = Path.Combine(resources, "Brushes");

		private static void Postfix(GameSystemBase __instance)
		{
			if (File.Exists(pathToZip))
			{
				if (Directory.Exists(resources))
				{
					Directory.Delete(resources, recursive: true);
				}
				ZipFile.ExtractToDirectory(pathToZip, Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
				File.Delete(pathToZip);
			}
			if (!PrefabSystem_OnCreate.FolderToLoadBrush.Contains(resourcesBrushes) && Directory.Exists(resourcesBrushes))
			{
				PrefabSystem_OnCreate.FolderToLoadBrush.Add(resourcesBrushes);
			}
			if (!PrefabSystem_OnCreate.FolderToLoadBrush.Contains(PathToCustomBrushes) && Directory.Exists(PathToCustomBrushes))
			{
				PrefabSystem_OnCreate.FolderToLoadBrush.Add(PathToCustomBrushes);
			}
			if (!CustomSurfaces.FolderToLoadSurface.Contains(PathToCustomSurface) && Directory.Exists(PathToCustomSurface))
			{
				CustomSurfaces.FolderToLoadSurface.Add(PathToCustomSurface);
			}
		}
	}
	[HarmonyPatch(typeof(LocalizationManager), "AddLocale", new Type[] { typeof(LocaleAsset) })]
	internal class LocalizationManager_AddLocale
	{
		private static void Prefix(LocaleAsset asset)
		{
			Localization.AddCustomLocal(asset);
		}
	}
	[HarmonyPatch(typeof(GameManager), "InitializeThumbnails")]
	internal class GameManager_InitializeThumbnails
	{
		private static readonly string IconsResourceKey = "ExtraLandscapingTools".ToLower() ?? "";

		public static readonly string COUIBaseLocation = "coui://" + IconsResourceKey;

		internal static readonly List<string> pathToIconToLoad = new List<string>(1) { Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) };

		private static void Prefix(GameManager __instance)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			if (Directory.Exists(GameManager_Awake.PathToMods))
			{
				pathToIconToLoad.Add(GameManager_Awake.PathToMods);
			}
			GameUIResourceHandler val = (GameUIResourceHandler)GameManager.instance.userInterface.view.uiSystem.resourceHandler;
			if (val == null)
			{
				Debug.LogError((object)"Failed retrieving GameManager's GameUIResourceHandler instance, exiting.");
			}
			else
			{
				((DefaultResourceHandler)val).HostLocationsMap.Add(IconsResourceKey, pathToIconToLoad);
			}
		}
	}
	[HarmonyPatch(typeof(SystemOrder), "Initialize")]
	public static class SystemOrderPatch
	{
		public static void Postfix(UpdateSystem updateSystem)
		{
			updateSystem.UpdateAt<ELT_UI>((SystemUpdatePhase)22);
		}
	}
	[HarmonyPatch(typeof(ToolUISystem), "OnCreate")]
	public class ToolUISystem_OnCreate
	{
		public static ToolUISystem toolUISystem;

		public static Traverse toolUISystemTraverse;

		internal static PrefabSystem m_PrefabSystem;

		internal static EntityQuery m_BrushQuery;

		internal static ToolSystem m_ToolSystem;

		internal static Brush[] brushs;

		private static void Postfix(ToolUISystem __instance)
		{
			//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)
			toolUISystem = __instance;
			toolUISystemTraverse = Traverse.Create((object)__instance);
			m_PrefabSystem = toolUISystemTraverse.Field("m_PrefabSystem").GetValue<PrefabSystem>();
			m_BrushQuery = toolUISystemTraverse.Field("m_BrushQuery").GetValue<EntityQuery>();
			m_ToolSystem = toolUISystemTraverse.Field("m_ToolSystem").GetValue<ToolSystem>();
			brushs = toolUISystemTraverse.Method("BindBrushTypes", Array.Empty<object>()).GetValue<Brush[]>();
		}
	}
	[HarmonyPatch(typeof(ToolUISystem), "OnToolChanged", new Type[] { typeof(ToolBaseSystem) })]
	internal class ToolUISystem_OnToolChanged
	{
		internal static bool showMarker;

		private static void Postfix(ToolBaseSystem tool)
		{
			if (tool is TerrainToolSystem)
			{
				ELT_UI.eLT_UI_Mono.ChangeUiNextFrame(ELT_UI.GetStringFromEmbbededJSFile("UI.js"));
			}
			else
			{
				ELT_UI.eLT_UI_Mono.ChangeUiNextFrame(ELT_UI.GetStringFromEmbbededJSFile("REMOVE_UI.js"));
			}
			if (tool is AreaToolSystem)
			{
				ELT_UI.eLT_UI_Mono.ChangeUiNextFrame(ELT_UI.GetStringFromEmbbededJSFile("ShowMarker.js"));
				showMarker = true;
			}
			else if (showMarker)
			{
				ELT_UI.ShowMarker(b: false);
				ELT_UI.eLT_UI_Mono.ChangeUiNextFrame(ELT_UI.GetStringFromEmbbededJSFile("REMOVE_ShowMarker.js"));
				showMarker = false;
			}
		}
	}
	[HarmonyPatch(typeof(PrefabSystem), "OnCreate")]
	public class PrefabSystem_OnCreate
	{
		internal static List<string> FolderToLoadBrush = new List<string>();

		public static void Postfix(PrefabSystem __instance)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			ELT.m_PrefabSystem = __instance;
			foreach (string item in FolderToLoadBrush)
			{
				string[] files = Directory.GetFiles(item);
				foreach (string path in files)
				{
					byte[] array = File.ReadAllBytes(path);
					Texture2D val = new Texture2D(1, 1);
					if (!ImageConversion.LoadImage(val, array))
					{
						Debug.LogError((object)"Failed to Load Image");
					}
					BrushPrefab val2 = (BrushPrefab)ScriptableObject.CreateInstance("BrushPrefab");
					((Object)val2).name = Path.GetFileNameWithoutExtension(path);
					val2.m_Texture = val;
					__instance.AddPrefab((PrefabBase)(object)val2, (string)null, (PrefabBase)null, (ComponentBase)null);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PrefabSystem), "AddPrefab")]
	public class PrefabSystem_AddPrefab
	{
		private static readonly string[] removeTools = new string[2] { "Material 1", "Material 2" };

		private static string UIAssetCategoryPrefabName = "";

		private static bool setupCustomSurfaces = true;

		private static bool setupCustomDecals = true;

		public static bool Prefix(PrefabSystem __instance, PrefabBase prefab)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (Traverse.Create((object)__instance).Field("m_Entities").GetValue<Dictionary<PrefabBase, Entity>>()
				.ContainsKey(prefab))
			{
				return false;
			}
			if (prefab is UIAssetMenuPrefab && ((Object)prefab).name == "Landscaping" && CustomSurfaces.FolderToLoadSurface.Count > 0)
			{
				PrefabBase val = default(PrefabBase);
				UIAssetMenuPrefab val2;
				if (__instance.TryGetPrefab(new PrefabID("UIAssetMenuPrefab", "Custom Surfaces"), ref val))
				{
					val2 = (UIAssetMenuPrefab)(object)((val is UIAssetMenuPrefab) ? val : null);
					if (val2 != null)
					{
						goto IL_0108;
					}
				}
				val2 = ScriptableObject.CreateInstance<UIAssetMenuPrefab>();
				((Object)val2).name = "Custom Surfaces";
				UIObject val3 = ((PrefabBase)val2).AddComponent<UIObject>();
				val3.m_Icon = ELT.GetIcon((PrefabBase)(object)val2);
				val3.m_Priority = ((ComponentBase)prefab).GetComponent<UIObject>().m_Priority + 1;
				((ComponentBase)val3).active = true;
				val3.m_IsDebugObject = false;
				val3.m_Group = ((ComponentBase)prefab).GetComponent<UIObject>().m_Group;
				__instance.AddPrefab((PrefabBase)(object)val2, (string)null, (PrefabBase)null, (ComponentBase)null);
			}
			goto IL_0108;
			IL_0108:
			try
			{
				if (Prefab.failedPrefabs.ContainsKey(UIAssetCategoryPrefabName))
				{
					string uIAssetCategoryPrefabName = UIAssetCategoryPrefabName;
					UIAssetCategoryPrefabName = "";
					PrefabBase[] array = (PrefabBase[])(object)new PrefabBase[Prefab.failedPrefabs[uIAssetCategoryPrefabName].Count];
					Prefab.failedPrefabs[uIAssetCategoryPrefabName].CopyTo(array);
					PrefabBase[] array2 = array;
					foreach (PrefabBase val4 in array2)
					{
						Prefab.failedPrefabs[uIAssetCategoryPrefabName].Remove(val4);
						__instance.AddPrefab(val4, (string)null, (PrefabBase)null, (ComponentBase)null);
					}
				}
				if (removeTools.Contains(((Object)prefab).name) || (!(prefab is TerraformingPrefab) && !(prefab is SurfacePrefab) && !(prefab is StaticObjectPrefab)) || prefab is BuildingPrefab || prefab is BuildingExtensionPrefab)
				{
					UIAssetMenuPrefab val5 = (UIAssetMenuPrefab)(object)((prefab is UIAssetMenuPrefab) ? prefab : null);
					if (val5 != null && Prefab.failedPrefabs.ContainsKey(((Object)val5).name))
					{
						UIAssetCategoryPrefabName = ((Object)val5).name;
					}
					else
					{
						UIAssetCategoryPrefab val6 = (UIAssetCategoryPrefab)(object)((prefab is UIAssetCategoryPrefab) ? prefab : null);
						if (val6 != null && Prefab.failedPrefabs.ContainsKey(((Object)val6).name))
						{
							UIAssetCategoryPrefabName = ((Object)val6).name;
						}
					}
					return true;
				}
				if (prefab is StaticObjectPrefab && !((Object)prefab).name.ToLower().Contains("decal") && !((Object)prefab).name.ToLower().Contains("roadarrow"))
				{
					return true;
				}
				StaticObjectPrefab val7 = (StaticObjectPrefab)(object)((prefab is StaticObjectPrefab) ? prefab : null);
				if (val7 != null && (((Object)prefab).name.ToLower().Contains("decal") || ((Object)prefab).name.ToLower().Contains("roadarrow")))
				{
					if (((Object)prefab).name.ToLower().Contains("invisible"))
					{
						return true;
					}
					if (setupCustomDecals)
					{
						RenderPrefabBase mesh = ((ObjectGeometryPrefab)val7).m_Meshes[0].m_Mesh;
						RenderPrefab val8 = (RenderPrefab)(object)((mesh is RenderPrefab) ? mesh : null);
						if (val8 != null)
						{
							setupCustomDecals = false;
						}
					}
				}
				SpawnableArea component = ((ComponentBase)prefab).GetComponent<SpawnableArea>();
				if (prefab is SurfacePrefab && (Object)(object)component == (Object)null)
				{
					return true;
				}
				if (prefab is SurfacePrefab && (Object)(object)component != (Object)null && setupCustomSurfaces)
				{
					setupCustomSurfaces = false;
					try
					{
						CustomSurfaces.CreateCustomSurfaces(((ComponentBase)prefab).GetComponent<RenderedArea>().m_Material);
					}
					catch (Exception ex)
					{
						Plugin.Logger.LogWarning((object)ex);
					}
				}
				UIObject val9 = ((ComponentBase)prefab).GetComponent<UIObject>();
				if ((Object)(object)val9 == (Object)null)
				{
					val9 = prefab.AddComponent<UIObject>();
					((ComponentBase)val9).active = true;
					val9.m_IsDebugObject = false;
					val9.m_Icon = ELT.GetIcon(prefab);
					val9.m_Priority = 1;
				}
				if (prefab is TerraformingPrefab)
				{
					val9.m_Group = (UIGroupPrefab)(((object)Prefab.GetExistingToolCategory(__instance, prefab, "Terraforming")) ?? ((object)val9.m_Group));
				}
				else if (prefab is SurfacePrefab)
				{
					UIObject val10 = val9;
					if (val10.m_Group == null)
					{
						val10.m_Group = (UIGroupPrefab)(object)CustomSurfaces.SetupUIGroupe(__instance, prefab);
					}
				}
				else if (((Object)prefab).name.ToLower().Contains("decal"))
				{
					val9.m_Group = (UIGroupPrefab)(((object)Prefab.GetOrCreateNewToolCategory(__instance, prefab, "Landscaping", "Decals", "Pathways")) ?? ((object)val9.m_Group));
				}
				else if (((Object)prefab).name.ToLower().Contains("roadarrow"))
				{
					val9.m_Group = (UIGroupPrefab)(((object)Prefab.GetOrCreateNewToolCategory(__instance, prefab, "Landscaping", "Decals", "Pathways")) ?? ((object)val9.m_Group));
				}
				else
				{
					UIObject val10 = val9;
					if (val10.m_Group == null)
					{
						val10.m_Group = (UIGroupPrefab)(object)Prefab.GetOrCreateNewToolCategory(__instance, prefab, "Landscaping", "[ELT] Failed Prefab, IF you see this tab, repport it, it's a bug.");
					}
				}
				if ((Object)(object)val9.m_Group == (Object)null)
				{
					return false;
				}
			}
			catch (Exception ex2)
			{
				Plugin.Logger.LogError((object)ex2);
			}
			return true;
		}
	}
}