using System;
using System.Collections.Generic;
using System.Diagnostics;
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.Configuration;
using BepInEx.Logging;
using CalculateScrapForQuota.Scripts;
using CalculateScrapForQuota.Utils;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;

[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: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("CalculateScrapForQuota")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A template for Lethal Company")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0")]
[assembly: AssemblyProduct("CalculateScrapForQuota")]
[assembly: AssemblyTitle("CalculateScrapForQuota")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CalculateScrapForQuota
{
	public class Config
	{
		private readonly ConfigEntry<bool> _isVerbose;

		public readonly Color highlightColor;

		private readonly ConfigEntry<string> _highlightColor;

		public bool isVerbose => _isVerbose.Value;

		public Config(ConfigFile cfg)
		{
			_isVerbose = cfg.Bind<bool>("General.Debug", "isVerbose", false, "To display plugin logs in console.");
			_highlightColor = cfg.Bind<string>("General.Settings", "highlightColor", "#00FF00", "The hex color of the highlight material.");
			ColorUtility.TryParseHtmlString(_highlightColor.Value, ref highlightColor);
		}
	}
	[BepInPlugin("CalculateScrapForQuota", "CalculateScrapForQuota", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		private static ManualLogSource _logger;

		private static Config MyConfig { get; set; }

		private void Awake()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"CalculateScrapForQuota v1.1.0 is loaded!");
			_logger = ((BaseUnityPlugin)this).Logger;
			MyConfig = new Config(((BaseUnityPlugin)this).Config);
			MaterialSwapper.swapColor = MyConfig.highlightColor;
			Harmony val = new Harmony("CalculateScrapForQuota");
			val.PatchAll(Assembly.GetExecutingAssembly());
		}

		internal static void Log(string m)
		{
			if (MyConfig.isVerbose)
			{
				_logger.LogMessage((object)m);
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "CalculateScrapForQuota";

		public const string PLUGIN_NAME = "CalculateScrapForQuota";

		public const string PLUGIN_VERSION = "1.1.0";
	}
}
namespace CalculateScrapForQuota.Utils
{
	public static class DebugUtil
	{
		private const BindingFlags FLAGS = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		public static string GetGameObjectDetails(GameObject gameObject, bool ignoreProperties = false, bool ignoreFields = false)
		{
			string text = "--- GameObject Info";
			text = text + "\nName: " + ((Object)gameObject).name;
			Component[] components = gameObject.GetComponents<Component>();
			foreach (Component val in components)
			{
				text = text + "\n  Component: " + ((object)val).GetType().Name;
				if (!ignoreProperties)
				{
					PropertyInfo[] properties = ((object)val).GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					PropertyInfo[] array = properties;
					foreach (PropertyInfo propertyInfo in array)
					{
						text += $"\n    Property: {propertyInfo.Name}, Value: {propertyInfo.GetValue(val, null)}";
					}
				}
				if (!ignoreFields)
				{
					FieldInfo[] fields = ((object)val).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					FieldInfo[] array2 = fields;
					foreach (FieldInfo fieldInfo in array2)
					{
						text += $"\n    Field: {fieldInfo.Name}, Value: {fieldInfo.GetValue(val)}";
					}
				}
			}
			return text;
		}
	}
	public class MathUtil
	{
		public static (List<T> combination, int totalValue) FindBestCombination<T>(List<T> items, int quota, Func<T, int> valueSelector)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			if (valueSelector == null)
			{
				throw new ArgumentNullException("valueSelector");
			}
			if (quota < 0)
			{
				throw new ArgumentException("Quota cannot be negative.", "quota");
			}
			int count = items.Count;
			int num = items.Sum((T item) => valueSelector(item));
			int[,] array = new int[count + 1, num + 1];
			for (int i = 0; i <= count; i++)
			{
				for (int j = 0; j <= num; j++)
				{
					if (i == 0 || j == 0)
					{
						array[i, j] = 0;
						continue;
					}
					int num2 = valueSelector(items[i - 1]);
					if (num2 <= j)
					{
						array[i, j] = Math.Max(array[i - 1, j], array[i - 1, j - num2] + num2);
					}
					else
					{
						array[i, j] = array[i - 1, j];
					}
				}
			}
			int num3 = 0;
			for (int k = quota; k <= num; k++)
			{
				if (array[count, k] >= quota)
				{
					num3 = k;
					break;
				}
			}
			List<T> list = new List<T>();
			int num4 = count;
			int num5 = num3;
			while (num4 > 0 && num5 > 0)
			{
				if (array[num4, num5] != array[num4 - 1, num5])
				{
					list.Add(items[num4 - 1]);
					num5 -= valueSelector(items[num4 - 1]);
				}
				num4--;
			}
			list.Reverse();
			return (list, num3);
		}
	}
}
namespace CalculateScrapForQuota.Scripts
{
	public static class Materials
	{
		private static Shader HDRP_LIT_SHADER = Shader.Find("HDRP/Lit");

		private static Material _highlightMaterialHDRP;

		private static Shader SRP_SHADER = Shader.Find("Standard");

		private static Material _highlightMaterialSRP;

		public static Material HighlightMaterial
		{
			get
			{
				if (Object.op_Implicit((Object)(object)HDRP_LIT_SHADER))
				{
					return HighlightMaterialHDRP;
				}
				if (Object.op_Implicit((Object)(object)SRP_SHADER))
				{
					return HighlightMaterialSRP;
				}
				throw new Exception();
			}
		}

		private static Material HighlightMaterialHDRP
		{
			get
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				if ((Object)(object)_highlightMaterialHDRP != (Object)null)
				{
					return _highlightMaterialHDRP;
				}
				_highlightMaterialHDRP = new Material(HDRP_LIT_SHADER);
				_highlightMaterialHDRP.shader = HDRP_LIT_SHADER;
				_highlightMaterialHDRP.SetFloat("_SurfaceType", 1f);
				_highlightMaterialHDRP.SetFloat("_BlendMode", 0f);
				_highlightMaterialHDRP.SetFloat("_AlphaCutoffEnable", 0f);
				_highlightMaterialHDRP.SetFloat("_DstBlend", 10f);
				_highlightMaterialHDRP.SetFloat("_ZWrite", 0f);
				_highlightMaterialHDRP.SetFloat("_TransparentZWrite", 0f);
				_highlightMaterialHDRP.SetFloat("_TransparentCullMode", 0f);
				_highlightMaterialHDRP.SetFloat("_TransparentSortPriority", 0f);
				_highlightMaterialHDRP.SetFloat("_CullModeForward", 0f);
				return _highlightMaterialHDRP;
			}
		}

		private static Material HighlightMaterialSRP
		{
			get
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				if ((Object)(object)_highlightMaterialSRP != (Object)null)
				{
					return _highlightMaterialSRP;
				}
				_highlightMaterialSRP = new Material(SRP_SHADER);
				_highlightMaterialSRP.shader = SRP_SHADER;
				_highlightMaterialSRP.SetFloat("_Mode", 3f);
				_highlightMaterialSRP.SetInt("_SrcBlend", 1);
				_highlightMaterialSRP.SetInt("_DstBlend", 10);
				_highlightMaterialSRP.SetInt("_ZWrite", 0);
				_highlightMaterialSRP.DisableKeyword("_ALPHATEST_ON");
				_highlightMaterialSRP.EnableKeyword("_ALPHABLEND_ON");
				_highlightMaterialSRP.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				_highlightMaterialSRP.renderQueue = 3000;
				return _highlightMaterialSRP;
			}
		}
	}
	public static class MaterialSwapper
	{
		private class Visuals
		{
			private readonly List<Component> _rootOtherComponents;

			private List<Transform> Transforms { get; } = new List<Transform>();


			private List<MeshFilter> MeshFilters { get; } = new List<MeshFilter>();


			private List<MeshRenderer> MeshRenderers { get; } = new List<MeshRenderer>();


			private List<SkinnedMeshRenderer> SkinnedMeshRenderers { get; } = new List<SkinnedMeshRenderer>();


			public List<Renderer> Renderers
			{
				get
				{
					List<Renderer> list = new List<Renderer>((IEnumerable<Renderer>)MeshRenderers);
					list.AddRange((IEnumerable<Renderer>)SkinnedMeshRenderers);
					return list;
				}
			}

			public Visuals(GameObject gameObject)
			{
				_rootOtherComponents = gameObject.GetComponentsInChildren<Component>().ToList();
				Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>();
				foreach (Transform item in componentsInChildren)
				{
					Transforms.Add(item);
					_rootOtherComponents.Remove((Component)(object)item);
				}
				MeshFilter[] componentsInChildren2 = gameObject.GetComponentsInChildren<MeshFilter>();
				foreach (MeshFilter item2 in componentsInChildren2)
				{
					MeshFilters.Add(item2);
					_rootOtherComponents.Remove((Component)(object)item2);
				}
				MeshRenderer[] componentsInChildren3 = gameObject.GetComponentsInChildren<MeshRenderer>();
				foreach (MeshRenderer item3 in componentsInChildren3)
				{
					MeshRenderers.Add(item3);
					_rootOtherComponents.Remove((Component)(object)item3);
				}
				SkinnedMeshRenderer[] componentsInChildren4 = gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
				foreach (SkinnedMeshRenderer item4 in componentsInChildren4)
				{
					SkinnedMeshRenderers.Add(item4);
					_rootOtherComponents.Remove((Component)(object)item4);
				}
				foreach (MeshFilter meshFilter in MeshFilters)
				{
					Plugin.Log("Preserving mesh '" + ((Object)meshFilter.mesh).name + "'");
				}
			}

			public void DestroyNonVisuals()
			{
				foreach (Component rootOtherComponent in _rootOtherComponents)
				{
					Object.Destroy((Object)(object)rootOtherComponent);
				}
				_rootOtherComponents.Clear();
			}
		}

		private class SwapObject
		{
			private readonly Visuals _rootVisuals;

			private readonly GameObject _cloneGO;

			private readonly Visuals _cloneVisuals;

			public SwapObject(GameObject original)
			{
				_cloneGO = Clone(original);
				_rootVisuals = new Visuals(original);
				_cloneVisuals = new Visuals(_cloneGO);
				CleanUpClone();
			}

			private void CleanUpClone()
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				_cloneVisuals.DestroyNonVisuals();
				foreach (Renderer renderer in _cloneVisuals.Renderers)
				{
					for (int i = 0; i < renderer.materials.Length; i++)
					{
						renderer.materials[i] = swapMaterial;
						renderer.materials[i].color = new Color(swapColor.r, swapColor.g, swapColor.b);
					}
				}
			}

			public void Swap(bool on)
			{
				foreach (Renderer renderer in _rootVisuals.Renderers)
				{
					renderer.enabled = !on;
				}
				foreach (Renderer renderer2 in _cloneVisuals.Renderers)
				{
					renderer2.enabled = on;
					renderer2.rendererPriority = (on ? 69420 : (-69420));
				}
			}

			public void Dispose()
			{
				if ((Object)(object)_cloneGO != (Object)null)
				{
					Object.Destroy((Object)(object)_cloneGO);
				}
			}
		}

		public static Material swapMaterial = Materials.HighlightMaterial;

		public static Color swapColor = Color.green;

		private static Dictionary<GameObject, SwapObject> pool = new Dictionary<GameObject, SwapObject>();

		public static void SwapOn(List<GameObject> gameObjects)
		{
			foreach (GameObject gameObject in gameObjects)
			{
				Add(gameObject);
				pool[gameObject].Swap(on: true);
			}
		}

		public static void SwapOff()
		{
			foreach (KeyValuePair<GameObject, SwapObject> item in pool)
			{
				if ((Object)(object)item.Key == (Object)null)
				{
					item.Value.Dispose();
					pool.Remove(item.Key);
				}
				else
				{
					item.Value.Swap(on: false);
				}
			}
		}

		private static void Add(GameObject original)
		{
			if (!pool.ContainsKey(original))
			{
				pool.Add(original, new SwapObject(original));
			}
		}

		public static void Clear()
		{
			SwapOff();
			foreach (SwapObject value in pool.Values)
			{
				value.Dispose();
			}
			pool.Clear();
		}

		private static GameObject Clone(GameObject parent)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(parent, parent.transform.position, parent.transform.rotation);
			val.transform.localScale = parent.transform.localScale;
			val.transform.SetParent(parent.transform);
			((Object)val).name = ((Object)parent).name + " (Clone for swap)";
			Plugin.Log("Made '" + ((Object)val).name + "' \nAnd parented it to " + ((Object)parent).name);
			return val;
		}
	}
}
namespace CalculateScrapForQuota.Patches
{
	[HarmonyPatch]
	public class GrabbableObjectPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(GrabbableObject), "EnableItemMeshes")]
		private static void EnableItemMeshes(GrabbableObject __instance, bool enable)
		{
			Plugin.Log("EnableItemMeshes() called.");
			GameObject gameObject = ((Component)__instance).gameObject;
			if (HudManagerPatch.CurrentHighlight.Contains(gameObject) && enable)
			{
				List<GameObject> list = new List<GameObject>();
				list.Add(gameObject);
				MaterialSwapper.SwapOn(list);
			}
		}
	}
	[HarmonyPatch]
	public class HudManagerPatch
	{
		public static List<GameObject> CurrentHighlight = new List<GameObject>();

		public static bool toggled = false;

		private static GameObject _textGO;

		private static TextMeshProUGUI _textMesh;

		private static GameObject shipGO => GameObject.Find("/Environment/HangarShip");

		private static GameObject valueCounterGO => GameObject.Find("/Systems/UI/Canvas/IngamePlayerHUD/BottomMiddle/ValueCounter");

		private static int unmetQuota => Math.Max(0, TimeOfDay.Instance.profitQuota - TimeOfDay.Instance.quotaFulfilled);

		private static double buyingRate => isAtCompany ? ((double)StartOfRound.Instance.companyBuyingRate) : 1.0;

		private static bool isAtCompany => StartOfRound.Instance.currentLevel.levelID == 3;

		private static bool isInShip => GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom;

		private static bool isScanning(HUDManager instance)
		{
			return (double)(float)typeof(HUDManager).GetField("playerPingingScan", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(instance) > -1.0;
		}

		private static bool canPlayerScan(HUDManager instance)
		{
			return (bool)typeof(HUDManager).GetMethod("CanPlayerScan", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(instance, null);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(HUDManager), "PingScan_performed")]
		private static void OnScan(HUDManager __instance, CallbackContext context)
		{
			Plugin.Log("OnScan() called.");
			if (!((CallbackContext)(ref context)).performed || isScanning(__instance) || !canPlayerScan(__instance) || (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null)
			{
				return;
			}
			Plugin.Log("OnScan() is valid.");
			CurrentHighlight.Clear();
			toggled = !toggled;
			if (toggled)
			{
				List<GrabbableObject> items;
				if (isInShip && !isAtCompany)
				{
					items = GetSellableGrabbablesInChildren(shipGO);
				}
				else
				{
					if (!isAtCompany)
					{
						return;
					}
					items = GetAllSellableObjects();
				}
				(List<GrabbableObject>, int) tuple = MathUtil.FindBestCombination(items, unmetQuota, ValueCalculation);
				if (tuple.Item2 >= unmetQuota)
				{
					CurrentHighlight = tuple.Item1.Select((GrabbableObject g) => ((Component)g).gameObject).ToList();
					SetupText(tuple.Item2);
					MaterialSwapper.SwapOn(CurrentHighlight);
				}
			}
			else
			{
				SetupText();
				MaterialSwapper.SwapOff();
				MaterialSwapper.Clear();
			}
			static int ValueCalculation(GrabbableObject grabbable)
			{
				return isAtCompany ? ((int)((double)grabbable.scrapValue * buyingRate)) : grabbable.scrapValue;
			}
		}

		private static List<GrabbableObject> GetAllSellableObjects()
		{
			GrabbableObject[] source = Object.FindObjectsOfType<GrabbableObject>();
			return source.Where(IsGrabbableSellable).ToList();
		}

		private static List<GrabbableObject> GetSellableGrabbablesInChildren(GameObject GO)
		{
			GrabbableObject[] componentsInChildren = GO.GetComponentsInChildren<GrabbableObject>();
			return componentsInChildren.Where(IsGrabbableSellable).ToList();
		}

		private static bool IsGrabbableSellable(GrabbableObject grabbable)
		{
			return grabbable.itemProperties.isScrap && !grabbable.isPocketed && grabbable.scrapValue > 0 && ((Object)grabbable).name != "ClipboardManual" && ((Object)grabbable).name != "StickyNoteItem" && ((Object)grabbable).name != "Gift" && ((Object)grabbable).name != "Shotgun" && ((Object)grabbable).name != "Ammo";
		}

		private static void SetupText(int totalValue = -1)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_textGO))
			{
				_textGO = Object.Instantiate<GameObject>(valueCounterGO.gameObject, valueCounterGO.transform.parent, false);
				_textGO.transform.Translate(0f, 1f, 0f);
				Vector3 localPosition = _textGO.transform.localPosition;
				_textGO.transform.localPosition = new Vector3(localPosition.x + 50f, -100f, localPosition.z);
				_textMesh = _textGO.GetComponentInChildren<TextMeshProUGUI>();
				((TMP_Text)_textMesh).fontSize = 12f;
			}
			if (totalValue > 0)
			{
				_textGO.SetActive(true);
				((TMP_Text)_textMesh).text = $"Optimal: {totalValue}";
			}
			else
			{
				_textGO.SetActive(false);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}