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 HarmonyLib;
using ItemWeights.Helpers;
using LethalCompanyInputUtils.Api;
using LethalConfig;
using LethalConfig.ConfigItems;
using Microsoft.CodeAnalysis;
using Unity.Mathematics;
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: AssemblyCompany("DarthLilo.ItemWeights")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ItemWeights")]
[assembly: AssemblyTitle("DarthLilo.ItemWeights")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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 ItemWeights
{
	[BepInPlugin("DarthLilo.ItemWeights", "ItemWeights", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ItemWeights : BaseUnityPlugin
	{
		internal static ItemWeightsKeybindHelper InputActionsInstance;

		public static ItemWeights Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static Harmony? Harmony { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			ItemWeightsConfigHelper.SetLethalConfig(((BaseUnityPlugin)this).Config);
			InputActionsInstance = new ItemWeightsKeybindHelper();
			ItemWeightsCallbacks.StartKeybindCallbacks();
			Patch();
			Logger.LogInfo((object)"DarthLilo.ItemWeights v1.0.0 has loaded!");
		}

		internal static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("DarthLilo.ItemWeights");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Finished patching!");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "DarthLilo.ItemWeights";

		public const string PLUGIN_NAME = "ItemWeights";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ItemWeights.Patches
{
	[HarmonyPatch(typeof(GrabbableObject))]
	public class GrabbableObject_patches
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void ChangeItemWeights(GrabbableObject __instance)
		{
			WeightPatch.SetItemWeight(__instance);
		}
	}
	public class WeightPatch
	{
		public static Dictionary<string, float> WeightsDict()
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>();
			string value = ItemWeightsConfigHelper.Weights.Value;
			List<string> list = value.Split(',').ToList();
			foreach (string item in list)
			{
				if (!(item == ""))
				{
					ItemWeights.Logger.LogInfo((object)item);
					string[] array = item.Split(':');
					string key = array[0];
					string s = array[1];
					dictionary[key] = float.Parse(s);
				}
			}
			return dictionary;
		}

		public static void SetItemWeight(GrabbableObject item)
		{
			string name = ((Object)item.itemProperties).name;
			if ((Object)(object)item == (Object)null)
			{
				ItemWeights.Logger.LogInfo((object)(name + " is null, skipping!"));
				return;
			}
			ItemWeights.Logger.LogInfo((object)("Updating weights for [" + name + "]"));
			if (WeightsDict().ContainsKey(name))
			{
				item.itemProperties.weight = WeightsDict()[name] / 100f + 1f;
			}
		}
	}
}
namespace ItemWeights.Helpers
{
	public static class ItemWeightsConfigHelper
	{
		public static ConfigEntry<string> Weights;

		public static void SetLethalConfig(ConfigFile config)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Weights = config.Bind<string>("Weights", "ItemWeights", "", "Create an entry in this format \"ITEMID:WEIGHT\", for example to make a shovel weigh 4 pounds you would put \"Shovel:4\". Enter values manually or use the keybind in-game!");
			TextInputFieldConfigItem val = new TextInputFieldConfigItem(Weights, true);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
			LethalConfigManager.SetModDescription("A mod for configuring weights of individual items.");
		}
	}
	public class ItemWeightsKeybindHelper : LcInputActions
	{
		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction RegisterItem { get; set; }
	}
	public static class ItemWeightsCallbacks
	{
		public static void StartKeybindCallbacks()
		{
			ItemWeights.InputActionsInstance.RegisterItem.performed += OnRegisterItemPressed;
		}

		public static void OnRegisterItemPressed(CallbackContext registerContext)
		{
			if (!((CallbackContext)(ref registerContext)).performed)
			{
				return;
			}
			GrabbableObject currentlyHeldObjectServer = GameNetworkManager.Instance.localPlayerController.currentlyHeldObjectServer;
			if (!Object.op_Implicit((Object)(object)currentlyHeldObjectServer))
			{
				return;
			}
			string name = ((Object)currentlyHeldObjectServer.itemProperties).name;
			float num = (currentlyHeldObjectServer.itemProperties.weight - 1f) * 100f;
			float num2 = math.round(num);
			string value = ItemWeightsConfigHelper.Weights.Value;
			string[] array = value.Split(",");
			string[] source = (from x in value.Split(",")
				select x.Split(":")[0]).ToArray();
			if (source.Contains(name))
			{
				HUDManager.Instance.DisplayTip("ItemWeights", "[" + name + "] is already in the config!", false, false, "LC_Tip1");
				return;
			}
			HUDManager.Instance.DisplayTip("ItemWeights", $"[{name}] has been added to the config with a weight of [{num2}]!", false, false, "LC_Tip1");
			if (value == "")
			{
				ItemWeightsConfigHelper.Weights.Value = $"{name}:{num2}";
			}
			else
			{
				ItemWeightsConfigHelper.Weights.Value = $"{value},{name}:{num2}";
			}
		}
	}
}