using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using REPOLib;
using REPOLib.Modules;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("MapUpgrade")]
[assembly: AssemblyDescription("R.E.P.O. Map Upgrade Mod! Originally developed by Ardot66, updated by Jettcodey.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Ardot66, Jettcodey")]
[assembly: AssemblyProduct("MapUpgrade")]
[assembly: AssemblyCopyright("")]
[assembly: ComVisible(false)]
[assembly: Guid("0bb70cc2-9b49-4a31-8adc-e4218f4f39b5")]
[assembly: AssemblyFileVersion("1.1.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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]
	[Microsoft.CodeAnalysis.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]
	[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 Ardot.Jettcodey.REPO.MapUpgrade
{
	public class MapToolChanges : MonoBehaviour
	{
		public record struct BackgroundObject(Transform Object, Vector3 OriginalScale)
		{
			[CompilerGenerated]
			private readonly bool PrintMembers(StringBuilder builder)
			{
				//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)
				builder.Append("Object = ");
				builder.Append(Object);
				builder.Append(", OriginalScale = ");
				Vector3 originalScale = OriginalScale;
				builder.Append(((object)(Vector3)(ref originalScale)).ToString());
				return true;
			}
		}

		public static MapToolChanges Instance;

		public static ConfigEntry<float> DefaultSize;

		public static ConfigEntry<float> ZoomRate;

		public MapToolController MapTool;

		public Camera MapCamera;

		public BackgroundObject[] BackgroundObjects = new BackgroundObject[3];

		public const float ZoomScale = 2f;

		public float MaxZoom = 1f;

		public bool MapEnabled = true;

		private static FieldInfo _activeField;

		private float _lastZoom = -1f;

		public static void Init()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			ZoomRate = Plugin.Config.Bind<float>("Map", "ZoomSpeed", 1f, new ConfigDescription("Controls the speed that the map is zoomed", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
			DefaultSize = Plugin.Config.Bind<float>("Map", "DefaultSize", 1f, new ConfigDescription("The starting size of the map", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
			Plugin.Harmony.Patch((MethodBase)AccessTools.Method(typeof(PlayerAvatar), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(MapToolChanges), "PlayerAwakePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void PlayerAwakePostfix(PlayerAvatar __instance)
		{
			((Component)__instance.mapToolController).gameObject.AddComponent<MapToolChanges>();
		}

		public void Awake()
		{
			MapTool = ((Component)this).GetComponent<MapToolController>();
			if (_activeField == null)
			{
				_activeField = Utils.GetField<MapToolController>("Active");
			}
			int backgroundObjectIndex = 0;
			Utils.ForObjectsInTree(((Component)Map.Instance).transform.parent, delegate(Transform transform)
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				Camera component = ((Component)transform).GetComponent<Camera>();
				if ((Object)(object)component != (Object)null)
				{
					MapCamera = component;
				}
				switch (((Object)transform).name)
				{
				case "Fog":
				case "Scanlines":
				case "Background":
					BackgroundObjects[backgroundObjectIndex] = new BackgroundObject(transform, transform.localScale);
					backgroundObjectIndex++;
					break;
				case "Completed":
					return false;
				}
				return true;
			});
			SetZoom(DefaultSize.Value);
		}

		public void Start()
		{
			if ((Object)(object)PlayerAvatar.instance != (Object)null)
			{
				Plugin.UpdatePlayerMapTool(PlayerAvatar.instance);
			}
		}

		public void Update()
		{
			if (MapEnabled && (bool)_activeField.GetValue(MapTool))
			{
				float axisRaw = Input.GetAxisRaw("Mouse ScrollWheel");
				if (Mathf.Abs(axisRaw) > 0.0001f)
				{
					float zoom = Mathf.Clamp(MapCamera.orthographicSize / 2f - axisRaw * ZoomRate.Value, 0.5f, MaxZoom);
					SetZoom(zoom);
				}
			}
		}

		public void SetMapEnabled(bool enabled)
		{
			((Renderer)MapTool.DisplayMesh).enabled = enabled;
			((Behaviour)((Component)((Component)MapTool.DisplayMesh).transform.parent).GetComponentInChildren<Light>()).enabled = enabled;
			MapEnabled = enabled;
		}

		public void SetMaxZoom(float zoom)
		{
			if (Mathf.Abs(zoom - MaxZoom) > 0.1f)
			{
				SetZoom(zoom);
			}
			MaxZoom = zoom;
		}

		public void SetZoom(float zoom)
		{
			//IL_0049: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (!(Mathf.Abs(zoom - _lastZoom) < 0.001f))
			{
				_lastZoom = zoom;
				MapCamera.orthographicSize = zoom * 2f;
				for (int i = 0; i < BackgroundObjects.Length; i++)
				{
					BackgroundObject backgroundObject = BackgroundObjects[i];
					Vector3 originalScale = backgroundObject.OriginalScale;
					backgroundObject.Object.localScale = new Vector3(originalScale.x * zoom, originalScale.y, originalScale.z * zoom);
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Ardot.Jettcodey.REPO.MapUpgrade";

		public const string PLUGIN_NAME = "Map Upgrade";

		public const string PLUGIN_VERSION = "1.2.0";
	}
	[BepInPlugin("Ardot.Jettcodey.REPO.MapUpgrade", "Map Upgrade", "1.2.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigFile Config;

		public static Harmony Harmony;

		internal static ManualLogSource Logger;

		public static ConfigEntry<bool> MapRequiresUpgrade;

		public static ConfigEntry<float> MinCost;

		public static ConfigEntry<float> MaxCost;

		public static ConfigEntry<float> MapSizeIncrease;

		public static string getPath()
		{
			return Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "mapupgrade.file");
		}

		private void Awake()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			Config = ((BaseUnityPlugin)this).Config;
			Harmony = new Harmony("Ardot.Jettcodey.REPO.MapUpgrade");
			InitConfig();
			MapToolChanges.Init();
			Logger.LogInfo((object)"Plugin Map Upgrade v1.2.0 loaded successfully.");
			Logger.LogInfo((object)"Mod originally developed by Ardot66, updated by Jettcodey!");
			BundleLoader.LoadBundle(getPath(), (Action<AssetBundle>)delegate(AssetBundle assetBundle)
			{
				string[] array = new string[1] { "Map Upgrade" };
				string[] array2 = array;
				foreach (string text in array2)
				{
					try
					{
						Item val = assetBundle.LoadAsset<Item>(text);
						if ((Object)(object)val == (Object)null)
						{
							Logger.LogError((object)("Failed loading Item asset '" + text + "' from bundle."));
						}
						else
						{
							GameObject val2 = assetBundle.LoadAsset<GameObject>(text);
							if ((Object)(object)val2 == (Object)null)
							{
								Logger.LogError((object)("Failed loading prefab for upgrade '" + text + "'. Make sure the prefab is included in the bundle."));
							}
							else
							{
								string name = (((Object)val2).name = text ?? "");
								((Object)val).name = name;
								val.itemName = text ?? "";
								Value val3 = ScriptableObject.CreateInstance<Value>();
								val3.valueMin = MinCost.Value / 4f;
								val3.valueMax = MaxCost.Value / 4f;
								val.value = val3;
								ItemAttributes val4 = val2.GetComponent<ItemAttributes>() ?? val2.AddComponent<ItemAttributes>();
								val4.item = val;
								Upgrader upgrader = val2.GetComponent<Upgrader>() ?? val2.AddComponent<Upgrader>();
								PrefabRef val5 = Items.RegisterItem(val4);
								if (val5 == null)
								{
									Logger.LogWarning((object)("Items.RegisterItem returned null for '" + text + "'. It may already be registered or there was an error."));
								}
								else
								{
									Logger.LogInfo((object)("Registered upgrade item '" + text + "'."));
								}
								Upgrades.RegisterUpgrade(text, val, (Action<PlayerAvatar, int>)null, (Action<PlayerAvatar, int>)null);
							}
						}
					}
					catch (Exception arg)
					{
						Logger.LogError((object)$"Exception while registering upgrade '{text}': {arg}");
					}
				}
			}, false);
			Config.SettingChanged += OnConfigChanged;
		}

		private void InitConfig()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			MapRequiresUpgrade = Config.Bind<bool>("Upgrade", "MapRequiresUpgrade", true, "If true, one map upgrade is required before the map can be used");
			MinCost = Config.Bind<float>("Upgrade", "MinCost", 7000f, new ConfigDescription("The minimum price of a MapUpgrade in the shop", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50000f), Array.Empty<object>()));
			MaxCost = Config.Bind<float>("Upgrade", "MaxCost", 10000f, new ConfigDescription("The maximum price of a MapUpgrade in the shop", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50000f), Array.Empty<object>()));
			MapSizeIncrease = Config.Bind<float>("Upgrade", "MapSizeIncrease", 0.5f, new ConfigDescription("The amount that the map increases in size for every map upgrade", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
		}

		private void OnConfigChanged(object sender, SettingChangedEventArgs e)
		{
			if ((e.ChangedSetting == MapSizeIncrease || e.ChangedSetting == MapRequiresUpgrade) && (Object)(object)PlayerAvatar.instance != (Object)null)
			{
				Update_MapUpgrade();
			}
		}

		public static void Update_MapUpgrade()
		{
			if (LevelGenerator.Instance.Generated && !SemiFunc.MenuLevel() && (Object)(object)PlayerAvatar.instance != (Object)null)
			{
				UpdateAllPlayersMapTool();
			}
		}

		public static void UpdateAllPlayersMapTool()
		{
			if (!((Object)(object)GameDirector.instance == (Object)null) && GameDirector.instance.PlayerList != null)
			{
				for (int i = 0; i < GameDirector.instance.PlayerList.Count; i++)
				{
					PlayerAvatar player = GameDirector.instance.PlayerList[i];
					UpdatePlayerMapTool(player);
				}
			}
		}

		public static void UpdatePlayerMapTool(PlayerAvatar player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.mapToolController == (Object)null)
			{
				return;
			}
			MapToolChanges component = ((Component)player.mapToolController).GetComponent<MapToolChanges>();
			if (!((Object)(object)component == (Object)null))
			{
				int stat = Upgrader.GetStat(player.steamID, "playerUpgradeMapUpgrade");
				int num = stat;
				if (!MapRequiresUpgrade.Value && num == 0)
				{
					num = 1;
				}
				component.SetMapEnabled(num > 0);
				component.SetMaxZoom(MapToolChanges.DefaultSize.Value + (float)(num - 1) * MapSizeIncrease.Value);
			}
		}
	}
	public class Upgrader : MonoBehaviourPunCallbacks
	{
		public ItemToggle _itemToggle;

		private PhotonView _photonView;

		private void Start()
		{
			_itemToggle = ((Component)this).GetComponent<ItemToggle>();
			_photonView = ((Component)this).GetComponent<PhotonView>();
			if (!StatsManager.instance.dictionaryOfDictionaries.ContainsKey("playerUpgradeMapUpgrade"))
			{
				StatsManager.instance.dictionaryOfDictionaries["playerUpgradeMapUpgrade"] = new Dictionary<string, int>();
			}
		}

		public static void UpdateStat(int amount, string steamId, string stat)
		{
			if (!StatsManager.instance.dictionaryOfDictionaries.ContainsKey(stat))
			{
				StatsManager.instance.dictionaryOfDictionaries[stat] = new Dictionary<string, int>();
			}
			Dictionary<string, int> dictionary = StatsManager.instance.dictionaryOfDictionaries[stat];
			if (!dictionary.ContainsKey(steamId))
			{
				dictionary[steamId] = 0;
			}
			dictionary[steamId] += amount;
			Plugin.Update_MapUpgrade();
		}

		public static int GetStat(string steamId, string upgradeName)
		{
			if (!StatsManager.instance.dictionaryOfDictionaries.ContainsKey(upgradeName))
			{
				return 0;
			}
			Dictionary<string, int> dictionary = StatsManager.instance.dictionaryOfDictionaries[upgradeName];
			int value;
			return dictionary.TryGetValue(steamId, out value) ? value : 0;
		}

		public void UpgradeMapUpgrade()
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromPhotonID(_itemToggle.playerTogglePhotonID);
			if (!((Object)(object)val == (Object)null))
			{
				string text = SemiFunc.PlayerGetSteamID(val);
				Plugin.Logger.LogInfo((object)string.Format("Your Map Upgrade level before: {0}", GetStat(text, "playerUpgradeMapUpgrade")));
				UpdateStat(1, text, "playerUpgradeMapUpgrade");
				if (SemiFunc.IsMultiplayer() && Utils.IsHost() && (Object)(object)_photonView != (Object)null)
				{
					_photonView.RPC("SyncUpgradeRPC", (RpcTarget)1, new object[2] { text, 1 });
				}
				Plugin.Logger.LogInfo((object)string.Format("Your Map Upgrade level after: {0}", GetStat(text, "playerUpgradeMapUpgrade")));
			}
		}

		[PunRPC]
		private void SyncUpgradeRPC(string steamId, int amount)
		{
			if (!StatsManager.instance.dictionaryOfDictionaries.ContainsKey("playerUpgradeMapUpgrade"))
			{
				StatsManager.instance.dictionaryOfDictionaries["playerUpgradeMapUpgrade"] = new Dictionary<string, int>();
			}
			Dictionary<string, int> dictionary = StatsManager.instance.dictionaryOfDictionaries["playerUpgradeMapUpgrade"];
			if (!dictionary.ContainsKey(steamId))
			{
				dictionary[steamId] = 0;
			}
			dictionary[steamId] += amount;
			Plugin.Update_MapUpgrade();
		}
	}
	public static class Utils
	{
		private static readonly Dictionary<Type, Dictionary<string, FieldInfo>> _fieldCache = new Dictionary<Type, Dictionary<string, FieldInfo>>();

		public static object Get<O>(this O obj, string field)
		{
			return GetField<O>(field).GetValue(obj);
		}

		public static T Get<T, O>(this O obj, string field)
		{
			return (T)obj.Get(field);
		}

		public static void Set<T>(this T obj, string field, object value)
		{
			GetField<T>(field).SetValue(obj, value);
		}

		public static FieldInfo GetField<T>(string field)
		{
			Type typeFromHandle = typeof(T);
			if (!_fieldCache.TryGetValue(typeFromHandle, out Dictionary<string, FieldInfo> value))
			{
				value = new Dictionary<string, FieldInfo>();
				_fieldCache[typeFromHandle] = value;
			}
			if (!value.TryGetValue(field, out var value2))
			{
				value2 = (value[field] = AccessTools.Field(typeFromHandle, field));
			}
			return value2;
		}

		public static bool IsHost()
		{
			return SemiFunc.IsMasterClientOrSingleplayer();
		}

		public static void ForObjectsInTree(Transform root, Predicate<Transform> action)
		{
			Stack<Transform> stack = new Stack<Transform>();
			stack.Push(root);
			while (stack.Count > 0)
			{
				Transform val = stack.Pop();
				if (action(val))
				{
					for (int num = val.childCount - 1; num >= 0; num--)
					{
						stack.Push(val.GetChild(num));
					}
				}
			}
		}
	}
}