using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
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(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("WLTGKitPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("WLTGKitPlugin")]
[assembly: AssemblyTitle("WLTGKitPlugin")]
[assembly: AssemblyVersion("1.0.0.0")]
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;
		}
	}
}
namespace WLTGKitPlugin
{
	public static class KitCommand
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ConsoleEvent <>9__0_0;

			internal void <Register>b__0_0(ConsoleEventArgs args)
			{
				string[] array = args.FullLine.Trim().Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
				if (array.Length < 2)
				{
					Print("Usage: kit [list|info|spawn|create|add|remove|delete|save|reload]");
					return;
				}
				switch (array[1].ToLower())
				{
				case "list":
					CmdList();
					break;
				case "info":
					CmdInfo(array);
					break;
				case "spawn":
					CmdSpawn(array);
					break;
				case "create":
					CmdCreate(array);
					break;
				case "add":
					CmdAdd(array);
					break;
				case "remove":
					CmdRemove(array);
					break;
				case "delete":
					CmdDelete(array);
					break;
				case "save":
					CmdSave();
					break;
				case "reload":
					CmdReload();
					break;
				default:
					Print("Unknown subcommand: " + array[1]);
					break;
				}
			}
		}

		public static void Register()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					string[] array = args.FullLine.Trim().Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
					if (array.Length < 2)
					{
						Print("Usage: kit [list|info|spawn|create|add|remove|delete|save|reload]");
					}
					else
					{
						switch (array[1].ToLower())
						{
						case "list":
							CmdList();
							break;
						case "info":
							CmdInfo(array);
							break;
						case "spawn":
							CmdSpawn(array);
							break;
						case "create":
							CmdCreate(array);
							break;
						case "add":
							CmdAdd(array);
							break;
						case "remove":
							CmdRemove(array);
							break;
						case "delete":
							CmdDelete(array);
							break;
						case "save":
							CmdSave();
							break;
						case "reload":
							CmdReload();
							break;
						default:
							Print("Unknown subcommand: " + array[1]);
							break;
						}
					}
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("kit", "[list|info <kit>|spawn <kit>|create <kit> [desc]|add <kit> <prefab> [amount] [quality]|remove <kit> <prefab>|delete <kit>|save|reload]", (ConsoleEvent)obj, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static void CmdList()
		{
			List<KeyValuePair<string, KitDefinition>> list = KitManager.Instance.GetAllKits().ToList();
			if (list.Count == 0)
			{
				Print("No kits defined.");
				return;
			}
			Print($"Available kits ({list.Count}):");
			foreach (KeyValuePair<string, KitDefinition> item in list)
			{
				Print($"  {item.Key} -- {item.Value.Name} ({item.Value.Items.Count} items)");
			}
			if (KitManager.Instance.HasUnsaved)
			{
				Print("  [!] Unsaved changes. Type: kit save");
			}
		}

		private static void CmdInfo(string[] parts)
		{
			if (parts.Length < 3)
			{
				Print("Usage: kit info <kitname>");
				return;
			}
			if (!KitManager.Instance.TryGetKit(parts[2], out KitDefinition kit))
			{
				Print("Kit not found: " + parts[2]);
				return;
			}
			Print("Kit: " + kit.Name + " (" + parts[2] + ") -- " + kit.Description);
			if (kit.Items.Count == 0)
			{
				Print("  (no items)");
				return;
			}
			foreach (KitItem item in kit.Items)
			{
				Print($"  {item.Prefab} x{item.Amount} quality:{item.Quality}");
			}
		}

		private static void CmdSpawn(string[] parts)
		{
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			if (parts.Length < 3)
			{
				Print("Usage: kit spawn <kitname>");
				return;
			}
			if (!IsAdmin())
			{
				Print("Admin only.");
				return;
			}
			if (!KitManager.Instance.TryGetKit(parts[2], out KitDefinition kit))
			{
				Print("Kit not found: " + parts[2]);
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Print("No local player.");
				return;
			}
			int num = 0;
			int num2 = 0;
			foreach (KitItem item in kit.Items)
			{
				ZNetScene instance = ZNetScene.instance;
				GameObject val = ((instance != null) ? instance.GetPrefab(item.Prefab) : null);
				if ((Object)(object)val == (Object)null)
				{
					Print("  Unknown prefab: " + item.Prefab);
					num2++;
					continue;
				}
				ItemDrop component = val.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					Print("  Not an item: " + item.Prefab);
					num2++;
					continue;
				}
				Vector3 position = ((Component)localPlayer).transform.position;
				ItemData val2 = component.m_itemData.Clone();
				val2.m_quality = Mathf.Clamp(item.Quality, 1, val2.m_shared.m_maxQuality);
				val2.m_durability = val2.m_shared.m_maxDurability;
				val2.m_stack = Mathf.Clamp(item.Amount, 1, val2.m_shared.m_maxStackSize);
				ItemDrop.DropItem(val2, item.Amount, position + Vector3.up, Quaternion.identity);
				num++;
			}
			Print($"Kit spawned: {num} items at your feet" + ((num2 > 0) ? $", {num2} failed." : "."));
		}

		private static void CmdCreate(string[] parts)
		{
			if (parts.Length < 3)
			{
				Print("Usage: kit create <kitname> [description]");
				return;
			}
			if (!IsAdmin())
			{
				Print("Admin only.");
				return;
			}
			KitDefinition orCreateUnsaved = KitManager.Instance.GetOrCreateUnsaved(parts[2]);
			orCreateUnsaved.Name = ((parts.Length >= 4) ? string.Join(" ", parts, 3, parts.Length - 3) : parts[2]);
			Print("Kit created. Add items: kit add " + parts[2] + " <prefab> <amount> <quality>");
			Print("Type 'kit save' when done.");
		}

		private static void CmdAdd(string[] parts)
		{
			if (parts.Length < 4)
			{
				Print("Usage: kit add <kitname> <prefab> [amount] [quality]");
				return;
			}
			if (!IsAdmin())
			{
				Print("Admin only.");
				return;
			}
			string text = parts[2];
			string prefab = parts[3];
			int result;
			int num = ((parts.Length < 5 || !int.TryParse(parts[4], out result)) ? 1 : result);
			int result2;
			int num2 = ((parts.Length < 6 || !int.TryParse(parts[5], out result2)) ? 1 : result2);
			if ((Object)(object)ZNetScene.instance != (Object)null && (Object)(object)ZNetScene.instance.GetPrefab(prefab) == (Object)null)
			{
				Print("  Warning: prefab not found -- double-check the name.");
			}
			KitDefinition orCreateUnsaved = KitManager.Instance.GetOrCreateUnsaved(text);
			orCreateUnsaved.Items.RemoveAll((KitItem i) => string.Equals(i.Prefab, prefab, StringComparison.OrdinalIgnoreCase));
			orCreateUnsaved.Items.Add(new KitItem
			{
				Prefab = prefab,
				Amount = num,
				Quality = num2
			});
			Print($"Added {prefab} x{num} quality:{num2} to '{text}'. Type 'kit save' to save.");
		}

		private static void CmdRemove(string[] parts)
		{
			string[] parts2 = parts;
			if (parts2.Length < 4)
			{
				Print("Usage: kit remove <kitname> <prefab>");
				return;
			}
			if (!IsAdmin())
			{
				Print("Admin only.");
				return;
			}
			KitDefinition orCreateUnsaved = KitManager.Instance.GetOrCreateUnsaved(parts2[2]);
			int num = orCreateUnsaved.Items.RemoveAll((KitItem i) => string.Equals(i.Prefab, parts2[3], StringComparison.OrdinalIgnoreCase));
			Print((num > 0) ? ("Removed " + parts2[3] + " from '" + parts2[2] + "'. Type 'kit save'.") : "Item not found in kit.");
		}

		private static void CmdDelete(string[] parts)
		{
			if (parts.Length < 3)
			{
				Print("Usage: kit delete <kitname>");
			}
			else if (!IsAdmin())
			{
				Print("Admin only.");
			}
			else
			{
				Print(KitManager.Instance.DeleteKit(parts[2]) ? "Kit deleted." : ("Kit not found: " + parts[2]));
			}
		}

		private static void CmdSave()
		{
			if (!IsAdmin())
			{
				Print("Admin only.");
				return;
			}
			KitManager.Instance.Save();
			Print($"Kits saved. {KitManager.Instance.KitCount} kit(s) total.");
		}

		private static void CmdReload()
		{
			if (!IsAdmin())
			{
				Print("Admin only.");
				return;
			}
			KitManager.Instance.Reload();
			Print($"Kits reloaded. {KitManager.Instance.KitCount} kit(s).");
		}

		private static bool IsAdmin()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			return ZNet.instance.LocalPlayerIsAdminOrHost();
		}

		private static void Print(string msg)
		{
			Terminal.Log((object)msg);
			Plugin.Log.LogInfo((object)msg);
		}
	}
	public class KitItem
	{
		public string Prefab { get; set; } = "";


		public int Amount { get; set; } = 1;


		public int Quality { get; set; } = 1;

	}
	public class KitDefinition
	{
		public string Name { get; set; } = "";


		public string Description { get; set; } = "";


		public List<KitItem> Items { get; set; } = new List<KitItem>();

	}
	public class KitFile
	{
		public Dictionary<string, KitDefinition> Kits { get; set; } = new Dictionary<string, KitDefinition>();

	}
	public class KitManager
	{
		public static readonly KitManager Instance = new KitManager();

		private Dictionary<string, KitDefinition> _kits = new Dictionary<string, KitDefinition>(StringComparer.OrdinalIgnoreCase);

		private Dictionary<string, KitDefinition> _pending = new Dictionary<string, KitDefinition>(StringComparer.OrdinalIgnoreCase);

		private static string ConfigDir => Path.Combine(Paths.ConfigPath, "WLTGKitPlugin");

		private static string KitsFile => Path.Combine(ConfigDir, "kits.json");

		public int KitCount => _kits.Count;

		public bool HasUnsaved => _pending.Count > 0;

		public void Load()
		{
			Directory.CreateDirectory(ConfigDir);
			if (!File.Exists(KitsFile))
			{
				WriteDefaultKits();
			}
			Reload();
		}

		public void Reload()
		{
			try
			{
				string text = File.ReadAllText(KitsFile);
				KitFile kitFile = JsonConvert.DeserializeObject<KitFile>(text);
				if (kitFile?.Kits != null)
				{
					_kits = new Dictionary<string, KitDefinition>(kitFile.Kits, StringComparer.OrdinalIgnoreCase);
					_pending.Clear();
					Plugin.Log.LogInfo((object)$"Loaded {_kits.Count} kit(s).");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to load kits.json: " + ex.Message));
			}
		}

		public void Save()
		{
			foreach (KeyValuePair<string, KitDefinition> item in _pending)
			{
				_kits[item.Key] = item.Value;
			}
			_pending.Clear();
			KitFile kitFile = new KitFile
			{
				Kits = _kits
			};
			File.WriteAllText(KitsFile, JsonConvert.SerializeObject((object)kitFile, (Formatting)1));
			Plugin.Log.LogInfo((object)$"Saved {_kits.Count} kit(s).");
		}

		public bool TryGetKit(string name, out KitDefinition kit)
		{
			if (_pending.TryGetValue(name, out kit))
			{
				return true;
			}
			return _kits.TryGetValue(name, out kit);
		}

		public IEnumerable<KeyValuePair<string, KitDefinition>> GetAllKits()
		{
			Dictionary<string, KitDefinition> dictionary = new Dictionary<string, KitDefinition>(_kits, StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, KitDefinition> item in _pending)
			{
				dictionary[item.Key] = item.Value;
			}
			return dictionary;
		}

		public KitDefinition GetOrCreateUnsaved(string name)
		{
			if (_pending.TryGetValue(name, out KitDefinition value))
			{
				return value;
			}
			if (_kits.TryGetValue(name, out KitDefinition value2))
			{
				KitDefinition kitDefinition = JsonConvert.DeserializeObject<KitDefinition>(JsonConvert.SerializeObject((object)value2));
				_pending[name] = kitDefinition;
				return kitDefinition;
			}
			KitDefinition kitDefinition2 = new KitDefinition
			{
				Name = name,
				Description = ""
			};
			_pending[name] = kitDefinition2;
			return kitDefinition2;
		}

		public bool DeleteKit(string name)
		{
			bool flag = _pending.Remove(name);
			bool flag2 = _kits.Remove(name);
			if (flag || flag2)
			{
				Save();
				return true;
			}
			return false;
		}

		private void WriteDefaultKits()
		{
			KitFile kitFile = new KitFile
			{
				Kits = new Dictionary<string, KitDefinition>
				{
					["stam"] = new KitDefinition
					{
						Name = "Admin Stam Kit",
						Description = "Tools and stamina food",
						Items = new List<KitItem>
						{
							new KitItem
							{
								Prefab = "AtgeirIron",
								Amount = 1,
								Quality = 1
							},
							new KitItem
							{
								Prefab = "Hoe",
								Amount = 2,
								Quality = 1
							},
							new KitItem
							{
								Prefab = "PickaxeAntler",
								Amount = 2,
								Quality = 1
							},
							new KitItem
							{
								Prefab = "Hammer",
								Amount = 1,
								Quality = 1
							},
							new KitItem
							{
								Prefab = "FishingRod",
								Amount = 1,
								Quality = 1
							},
							new KitItem
							{
								Prefab = "Bread",
								Amount = 5,
								Quality = 1
							},
							new KitItem
							{
								Prefab = "FishWraps",
								Amount = 5,
								Quality = 1
							},
							new KitItem
							{
								Prefab = "OnionSoup",
								Amount = 5,
								Quality = 1
							}
						}
					},
					["starter"] = new KitDefinition
					{
						Name = "New Player Starter Kit",
						Description = "Basic bronze gear",
						Items = new List<KitItem>
						{
							new KitItem
							{
								Prefab = "SwordBronze",
								Amount = 1,
								Quality = 2
							},
							new KitItem
							{
								Prefab = "ArmorBronzeHelmet",
								Amount = 1,
								Quality = 2
							},
							new KitItem
							{
								Prefab = "ArmorBronzeChest",
								Amount = 1,
								Quality = 2
							},
							new KitItem
							{
								Prefab = "ArmorBronzeLegs",
								Amount = 1,
								Quality = 2
							},
							new KitItem
							{
								Prefab = "CookedMeat",
								Amount = 10,
								Quality = 1
							},
							new KitItem
							{
								Prefab = "MeadHealthMinor",
								Amount = 5,
								Quality = 1
							}
						}
					}
				}
			};
			File.WriteAllText(KitsFile, JsonConvert.SerializeObject((object)kitFile, (Formatting)1));
			Plugin.Log.LogInfo((object)("Created default kits.json at " + KitsFile));
		}
	}
	[BepInPlugin("com.welovetogame.kitplugin", "WLTGKitPlugin", "2.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.welovetogame.kitplugin";

		public const string PluginName = "WLTGKitPlugin";

		public const string PluginVersion = "2.0.0";

		internal static ManualLogSource Log;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"WLTGKitPlugin v2.0.0 loading...");
			KitManager.Instance.Load();
			KitCommand.Register();
			Log.LogInfo((object)string.Format("{0} loaded. {1} kit(s) ready.", "WLTGKitPlugin", KitManager.Instance.KitCount));
		}
	}
}