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.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using CSync.Extensions;
using CSync.Lib;
using LethalLib.Modules;
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("Mayberry.UpdatedPlushies")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.0.0.0")]
[assembly: AssemblyInformationalVersion("0.0.0+f8a7966ba1ab2b305e27572acfe3378e4e94f7f9")]
[assembly: AssemblyProduct("UpdatedPlushies")]
[assembly: AssemblyTitle("Mayberry.UpdatedPlushies")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.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 UpdatedPlushies
{
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct DefaultPlushieConfig
	{
	}
	internal class PlushieConfig : SyncedConfig2<PlushieConfig>
	{
		private static readonly (string, LevelTypes)[] moons = new(string, LevelTypes)[11]
		{
			("Experimentation", (LevelTypes)4),
			("Assurance", (LevelTypes)8),
			("Vow", (LevelTypes)16),
			("Offense", (LevelTypes)32),
			("March", (LevelTypes)64),
			("Adamance", (LevelTypes)2048),
			("Rend", (LevelTypes)128),
			("Dine", (LevelTypes)256),
			("Titan", (LevelTypes)512),
			("Artifice", (LevelTypes)4096),
			("Embrion", (LevelTypes)8192)
		};

		private readonly Dictionary<string, (int, int, bool, float, bool, Dictionary<LevelTypes, int>)> defaultConfigs = new Dictionary<string, (int, int, bool, float, bool, Dictionary<LevelTypes, int>)>
		{
			{
				"Bracken Plushie",
				(20, 70, false, 5f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)4,
						3
					},
					{
						(LevelTypes)8,
						2
					},
					{
						(LevelTypes)16,
						12
					},
					{
						(LevelTypes)32,
						1
					},
					{
						(LevelTypes)64,
						9
					},
					{
						(LevelTypes)2048,
						4
					},
					{
						(LevelTypes)128,
						6
					},
					{
						(LevelTypes)256,
						4
					},
					{
						(LevelTypes)512,
						5
					},
					{
						(LevelTypes)4096,
						4
					},
					{
						(LevelTypes)8192,
						1
					}
				})
			},
			{
				"Bunker Spider Plushie",
				(30, 50, false, 7f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)4,
						12
					},
					{
						(LevelTypes)8,
						11
					},
					{
						(LevelTypes)16,
						7
					},
					{
						(LevelTypes)32,
						10
					},
					{
						(LevelTypes)64,
						10
					},
					{
						(LevelTypes)2048,
						8
					},
					{
						(LevelTypes)128,
						5
					},
					{
						(LevelTypes)256,
						3
					},
					{
						(LevelTypes)512,
						5
					},
					{
						(LevelTypes)4096,
						4
					},
					{
						(LevelTypes)8192,
						4
					}
				})
			},
			{
				"Coil-Head Plushie",
				(50, 70, false, 8f, true, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)16,
						1
					},
					{
						(LevelTypes)32,
						6
					},
					{
						(LevelTypes)64,
						2
					},
					{
						(LevelTypes)2048,
						2
					},
					{
						(LevelTypes)128,
						5
					},
					{
						(LevelTypes)256,
						3
					},
					{
						(LevelTypes)512,
						5
					},
					{
						(LevelTypes)4096,
						4
					},
					{
						(LevelTypes)8192,
						4
					}
				})
			},
			{
				"Eyeless Dog Plushie",
				(30, 60, false, 7f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)4,
						12
					},
					{
						(LevelTypes)8,
						9
					},
					{
						(LevelTypes)16,
						1
					},
					{
						(LevelTypes)32,
						10
					},
					{
						(LevelTypes)64,
						5
					},
					{
						(LevelTypes)2048,
						5
					},
					{
						(LevelTypes)128,
						11
					},
					{
						(LevelTypes)256,
						9
					},
					{
						(LevelTypes)512,
						12
					},
					{
						(LevelTypes)4096,
						5
					},
					{
						(LevelTypes)8192,
						1
					}
				})
			},
			{
				"Forest Keeper Plushie",
				(50, 80, true, 12f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)4,
						1
					},
					{
						(LevelTypes)8,
						1
					},
					{
						(LevelTypes)16,
						12
					},
					{
						(LevelTypes)32,
						2
					},
					{
						(LevelTypes)64,
						8
					},
					{
						(LevelTypes)2048,
						4
					},
					{
						(LevelTypes)128,
						9
					},
					{
						(LevelTypes)256,
						11
					},
					{
						(LevelTypes)512,
						6
					},
					{
						(LevelTypes)4096,
						6
					},
					{
						(LevelTypes)8192,
						1
					}
				})
			},
			{
				"Jester Plushie",
				(50, 90, false, 9f, true, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)64,
						1
					},
					{
						(LevelTypes)2048,
						1
					},
					{
						(LevelTypes)128,
						7
					},
					{
						(LevelTypes)256,
						3
					},
					{
						(LevelTypes)512,
						6
					},
					{
						(LevelTypes)4096,
						4
					}
				})
			},
			{
				"Hoarding Bug Plushie",
				(10, 30, false, 4f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)4,
						6
					},
					{
						(LevelTypes)8,
						12
					},
					{
						(LevelTypes)16,
						10
					},
					{
						(LevelTypes)32,
						4
					},
					{
						(LevelTypes)64,
						6
					},
					{
						(LevelTypes)2048,
						8
					},
					{
						(LevelTypes)256,
						4
					},
					{
						(LevelTypes)512,
						3
					},
					{
						(LevelTypes)4096,
						4
					},
					{
						(LevelTypes)8192,
						15
					}
				})
			},
			{
				"Comedy Masked Plushie",
				(30, 60, false, 5f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)8,
						1
					},
					{
						(LevelTypes)2048,
						1
					},
					{
						(LevelTypes)128,
						5
					},
					{
						(LevelTypes)256,
						1
					},
					{
						(LevelTypes)512,
						4
					},
					{
						(LevelTypes)4096,
						4
					}
				})
			},
			{
				"Tragedy Masked Plushie",
				(40, 50, false, 5f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)8,
						1
					},
					{
						(LevelTypes)2048,
						1
					},
					{
						(LevelTypes)128,
						3
					},
					{
						(LevelTypes)256,
						3
					},
					{
						(LevelTypes)512,
						4
					},
					{
						(LevelTypes)4096,
						4
					}
				})
			},
			{
				"Nutcracker Plushie",
				(30, 80, false, 8f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)4,
						1
					},
					{
						(LevelTypes)8,
						1
					},
					{
						(LevelTypes)32,
						1
					},
					{
						(LevelTypes)64,
						1
					},
					{
						(LevelTypes)2048,
						1
					},
					{
						(LevelTypes)128,
						12
					},
					{
						(LevelTypes)256,
						3
					},
					{
						(LevelTypes)512,
						6
					},
					{
						(LevelTypes)4096,
						4
					},
					{
						(LevelTypes)8192,
						4
					}
				})
			},
			{
				"Thumper Plushie",
				(30, 60, true, 10f, false, new Dictionary<LevelTypes, int>
				{
					{
						(LevelTypes)4,
						3
					},
					{
						(LevelTypes)8,
						4
					},
					{
						(LevelTypes)16,
						2
					},
					{
						(LevelTypes)32,
						13
					},
					{
						(LevelTypes)64,
						12
					},
					{
						(LevelTypes)2048,
						10
					},
					{
						(LevelTypes)256,
						2
					},
					{
						(LevelTypes)512,
						5
					},
					{
						(LevelTypes)4096,
						4
					},
					{
						(LevelTypes)8192,
						5
					}
				})
			}
		};

		[DataMember]
		public SyncedEntry<int> MinValue { get; private set; }

		[DataMember]
		public SyncedEntry<int> MaxValue { get; private set; }

		[DataMember]
		public SyncedEntry<bool> IsTwoHanded { get; private set; }

		[DataMember]
		public SyncedEntry<float> CarryWeight { get; private set; }

		[DataMember]
		public SyncedEntry<bool> IsConductive { get; private set; }

		[DataMember]
		public Dictionary<LevelTypes, SyncedEntry<int>> SpawnWeights { get; private set; } = new Dictionary<LevelTypes, SyncedEntry<int>>();


		public PlushieConfig(ConfigFile configFile, string name)
			: base("Mayberry.UpdatedPlushies")
		{
			//IL_0776: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0780: Unknown result type (might be due to invalid IL or missing references)
			//IL_0790: Unknown result type (might be due to invalid IL or missing references)
			string text = name + " Settings";
			(int, int, bool, float, bool, Dictionary<LevelTypes, int>) tuple = defaultConfigs[name];
			int item = tuple.Item1;
			int item2 = tuple.Item2;
			bool item3 = tuple.Item3;
			float item4 = tuple.Item4;
			bool item5 = tuple.Item5;
			Dictionary<LevelTypes, int> item6 = tuple.Item6;
			MinValue = SyncedBindingExtensions.BindSyncedEntry<int>(configFile, text, name + " Minimum Value", item, "The lowest sell value the " + name + " can appear with, in $.");
			MaxValue = SyncedBindingExtensions.BindSyncedEntry<int>(configFile, text, name + " Maximum Value", item2, "The highest sell value the " + name + " can appear with, in $.");
			IsTwoHanded = SyncedBindingExtensions.BindSyncedEntry<bool>(configFile, text, name + " Is Two-Handed", item3, "If true, " + name + " will require two hands to carry.");
			CarryWeight = SyncedBindingExtensions.BindSyncedEntry<float>(configFile, text, name + " Carry Weight", item4, "The carry weight of " + name + ", in lb.");
			IsConductive = SyncedBindingExtensions.BindSyncedEntry<bool>(configFile, text, name + " Is Conductive", item5, "If true, " + name + " will attract lightning.");
			(string, LevelTypes)[] array = moons;
			for (int i = 0; i < array.Length; i++)
			{
				var (text2, key) = array[i];
				item6.TryGetValue(key, out var value);
				SpawnWeights.Add(key, SyncedBindingExtensions.BindSyncedEntry<int>(configFile, text, name + " " + text2 + " Spawn Weight", value, "The weight for a " + name + " to spawn on " + text2 + ". The higher this value is, the more often the item will appear. Set to 0 to make the item never appear on " + text2 + "."));
			}
		}
	}
	[BepInPlugin("Mayberry.UpdatedPlushies", "UpdatedPlushies", "0.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class UpdatedPlushies : BaseUnityPlugin
	{
		public void Awake()
		{
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Begin loading Mayberry.UpdatedPlushies");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading monster plushie asset bundle");
			string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "monsterplushies");
			AssetBundle val = AssetBundle.LoadFromFile(text);
			(string, Item)[] array = new(string, Item)[11]
			{
				("Bracken Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Bracken Plush/BrackenPlush.asset")),
				("Bunker Spider Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Bunkspid/BunkspidItem.asset")),
				("Coil-Head Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Coil head/CoilHeadPlush.asset")),
				("Eyeless Dog Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Eyeless dog/EyelessDog.asset")),
				("Forest Keeper Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Giant/Forest keeper plushie.asset")),
				("Jester Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Jester/jesterplushie.asset")),
				("Hoarding Bug Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Lootbug/lootbugPlush.asset")),
				("Comedy Masked Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Masked/comedyplushitem.asset")),
				("Tragedy Masked Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Masked/Tragedyplushitem.asset")),
				("Nutcracker Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Nutcracker/Nutcracker.asset")),
				("Thumper Plushie", val.LoadAsset<Item>("Assets/MY STUFF/Thumper/Thumper.asset"))
			};
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Finished loading monster plushie asset bundle");
			(string, Item)[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				var (text2, val2) = array2[i];
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Registering " + text2));
				PlushieConfig plushieConfig = new PlushieConfig(((BaseUnityPlugin)this).Config, text2);
				NetworkPrefabs.RegisterNetworkPrefab(val2.spawnPrefab);
				Utilities.FixMixerGroups(val2.spawnPrefab);
				val2.minValue = (int)((double)SyncedEntry<int>.op_Implicit(plushieConfig.MinValue) / 0.4);
				val2.maxValue = (int)((double)SyncedEntry<int>.op_Implicit(plushieConfig.MaxValue) / 0.4);
				val2.twoHanded = SyncedEntry<bool>.op_Implicit(plushieConfig.IsTwoHanded);
				val2.twoHandedAnimation = SyncedEntry<bool>.op_Implicit(plushieConfig.IsTwoHanded);
				val2.weight = SyncedEntry<float>.op_Implicit(plushieConfig.CarryWeight) / 105f + 1f;
				val2.isConductiveMetal = SyncedEntry<bool>.op_Implicit(plushieConfig.IsConductive);
				foreach (var (val5, val6) in plushieConfig.SpawnWeights)
				{
					if (SyncedEntry<int>.op_Implicit(val6) > 0)
					{
						((BaseUnityPlugin)this).Logger.LogInfo((object)$"Registering {text2} on {val5} with a spawn weight of {val6.Value}");
						Items.RegisterScrap(val2, val6.Value, val5);
					}
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Finished registering " + text2));
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Mayberry.UpdatedPlushies v0.0.0 has loaded!");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "Mayberry.UpdatedPlushies";

		public const string PLUGIN_NAME = "UpdatedPlushies";

		public const string PLUGIN_VERSION = "0.0.0";
	}
}