using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using LethalLevelLoader;
using Microsoft.CodeAnalysis;
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("fiufkiscrap")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+16b8c0790801f7ecb4d36c1dfbbb59e050c95de9")]
[assembly: AssemblyProduct("fiufkiscrap")]
[assembly: AssemblyTitle("fiufkiscrap")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 fiufkiscrap
{
	public class fiufkiscrapconfig
	{
		private static readonly Dictionary<string, ConfigEntry<bool>> lookup = new Dictionary<string, ConfigEntry<bool>>(StringComparer.OrdinalIgnoreCase);

		public static ConfigEntry<bool> BookConfig { get; private set; }

		public static ConfigEntry<bool> BottleConfig { get; private set; }

		public static ConfigEntry<bool> CandleConfig { get; private set; }

		public static ConfigEntry<bool> CardboardBoxConfig { get; private set; }

		public static ConfigEntry<bool> CarTireConfig { get; private set; }

		public static ConfigEntry<bool> CartridgeConfig { get; private set; }

		public static ConfigEntry<bool> DeskLampConfig { get; private set; }

		public static ConfigEntry<bool> KeyboardConfig { get; private set; }

		public static ConfigEntry<bool> MagnetConfig { get; private set; }

		public static ConfigEntry<bool> MonitorConfig { get; private set; }

		public static ConfigEntry<bool> PillowConfig { get; private set; }

		public static ConfigEntry<bool> PottedPlantConfig { get; private set; }

		public static ConfigEntry<bool> VentCoverConfig { get; private set; }

		public fiufkiscrapconfig(ConfigFile configFile)
		{
			BookConfig = configFile.Bind<bool>("House Objects", "Spawn Book", true, (ConfigDescription)null);
			BottleConfig = configFile.Bind<bool>("House Objects", "Spawn Bottle", true, (ConfigDescription)null);
			CandleConfig = configFile.Bind<bool>("House Objects", "Spawn Candle", true, (ConfigDescription)null);
			CardboardBoxConfig = configFile.Bind<bool>("House Objects", "Spawn Cardboard Box", true, (ConfigDescription)null);
			CarTireConfig = configFile.Bind<bool>("House Objects", "Spawn Car Tire", true, (ConfigDescription)null);
			CartridgeConfig = configFile.Bind<bool>("House Objects", "Spawn Cartridge", true, (ConfigDescription)null);
			DeskLampConfig = configFile.Bind<bool>("House Objects", "Spawn Desk Lamp", true, (ConfigDescription)null);
			KeyboardConfig = configFile.Bind<bool>("House Objects", "Spawn Keyboard", true, (ConfigDescription)null);
			MagnetConfig = configFile.Bind<bool>("House Objects", "Spawn Magnet", true, (ConfigDescription)null);
			MonitorConfig = configFile.Bind<bool>("House Objects", "Spawn Monitor", true, (ConfigDescription)null);
			PillowConfig = configFile.Bind<bool>("House Objects", "Spawn Pillow", true, (ConfigDescription)null);
			PottedPlantConfig = configFile.Bind<bool>("House Objects", "Spawn Potted Plant", true, (ConfigDescription)null);
			VentCoverConfig = configFile.Bind<bool>("House Objects", "Spawn Vent Cover", true, (ConfigDescription)null);
			lookup["Book"] = BookConfig;
			lookup["Bottle"] = BottleConfig;
			lookup["Candle"] = CandleConfig;
			lookup["Cardboard Box"] = CardboardBoxConfig;
			lookup["Car Tire"] = CarTireConfig;
			lookup["Cartridge"] = CartridgeConfig;
			lookup["Desk Lamp"] = DeskLampConfig;
			lookup["Keyboard"] = KeyboardConfig;
			lookup["Magnet"] = MagnetConfig;
			lookup["Monitor"] = MonitorConfig;
			lookup["Pillow"] = PillowConfig;
			lookup["Potted Plant"] = PottedPlantConfig;
			lookup["Vent Cover"] = VentCoverConfig;
			ClearUnusedEntries(configFile);
			Plugin.Logger.LogInfo((object)"fiufki's Scrap config is loaded.");
		}

		public static bool TryGet(string itemName, out bool value)
		{
			if (lookup.TryGetValue(itemName, out var value2))
			{
				value = value2.Value;
				return true;
			}
			value = true;
			return false;
		}

		private void ClearUnusedEntries(ConfigFile configFile)
		{
			PropertyInfo property = ((object)configFile).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(configFile, null);
			dictionary.Clear();
			configFile.Save();
		}
	}
	[BepInPlugin("com.fiufki.fiufkiscrap", "fiufki's Scrap", "2.0.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGUID = "com.fiufki.fiufkiscrap";

		public const string PluginName = "fiufki's Scrap";

		public const string PluginVersion = "2.0.2";

		internal static ManualLogSource Logger;

		public static fiufkiscrapconfig ModConfig { get; private set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			ModConfig = new fiufkiscrapconfig(((BaseUnityPlugin)this).Config);
			AssetBundleLoader.AddOnExtendedModLoadedListener((Action<ExtendedMod>)OnExtendedModRegistered, "fiufki", "fiufki's Scrap");
			AssetBundleLoader.AddOnLethalBundleLoadedListener((Action<AssetBundle>)OnLethalBundleLoaded, "fiufkiscrap.lethalbundle");
			InitializeNetworkBehaviours();
			Logger.LogInfo((object)"fiufki's Scrap is loaded.");
		}

		internal static void OnExtendedModRegistered(ExtendedMod extendedmod)
		{
			if ((Object)(object)extendedmod == (Object)null)
			{
				return;
			}
			for (int num = extendedmod.ExtendedItems.Count - 1; num >= 0; num--)
			{
				ExtendedItem val = extendedmod.ExtendedItems[num];
				if (!GetConfigValueForItem(val.Item.itemName))
				{
					extendedmod.ExtendedItems.RemoveAt(num);
					Logger.LogInfo((object)("Disabled spawning of the " + val.Item.itemName + " scrap."));
				}
			}
		}

		internal static void OnLethalBundleLoaded(AssetBundle assetBundle)
		{
			if (!((Object)(object)assetBundle == (Object)null))
			{
			}
		}

		public static bool GetConfigValueForItem(string itemName)
		{
			fiufkiscrapconfig.TryGet(itemName, out var value);
			return value;
		}

		private void InitializeNetworkBehaviours()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}
	}
}