using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.Json;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using ProjectM;
using ProjectM.Network;
using ProjectM.Scripting;
using StarterKit.Configs;
using StarterKit.Database;
using StarterKit.Utils;
using Stunlock.Core;
using Stunlock.Network;
using Unity.Collections;
using Unity.Entities;
using UnityEngine;
using VampireCommandFramework;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("StarterKit")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Give new Vampiries start equipment.")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+88a19ef3c3dcdf2bf647b7f8306760ebcb940a96")]
[assembly: AssemblyProduct("StarterKit")]
[assembly: AssemblyTitle("StarterKit")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.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.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace StarterKit
{
	[BepInPlugin("StarterKit", "StarterKit", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		private Harmony _harmony;

		public static ManualLogSource Logger;

		internal static Plugin Instance;

		public override void Load()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			Instance = this;
			Logger = ((BasePlugin)this).Log;
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(27, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Plugin ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("StarterKit");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" version ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("0.1.0");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is loaded!");
			}
			log.LogInfo(val);
			_harmony = new Harmony("StarterKit");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			MainConfig.ConfigInit();
			DB.LoadData();
			CommandRegistry.RegisterAll();
		}

		public override bool Unload()
		{
			CommandRegistry.UnregisterAssembly();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			return true;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "StarterKit";

		public const string PLUGIN_NAME = "StarterKit";

		public const string PLUGIN_VERSION = "0.1.0";
	}
}
namespace StarterKit.Utils
{
	internal class Helper
	{
		private static World? _serverWorld;

		public static ServerGameManager serverGameManager = Server.GetExistingSystemManaged<ServerScriptMapper>()._ServerGameManager;

		public static EntityManager EntityManager => Server.EntityManager;

		public static GameDataSystem gameData => Server.GetExistingSystemManaged<GameDataSystem>();

		public static PrefabCollectionSystem PrefabCollection => Server.GetExistingSystemManaged<PrefabCollectionSystem>();

		public static Dictionary<string, PrefabGUID> NameToGuid => PrefabCollection.NameToPrefabGuidDictionary;

		public static World Server
		{
			get
			{
				if (_serverWorld != null)
				{
					return _serverWorld;
				}
				_serverWorld = GetWorld("Server") ?? throw new Exception("There is no Server world (yet). Did you install a server mod on the client?");
				return _serverWorld;
			}
		}

		public static bool IsServer => Application.productName == "VRisingServer";

		public static void GiveStartKit(ChatCommandContext ctx, List<RecordKit> kit)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			foreach (RecordKit item in kit)
			{
				Entity val = AddItemToInventory(ctx.Event.SenderCharacterEntity, NameToGuid[item.Name], item.Amount);
				int itemSlot = InventoryUtilities.GetItemSlot(EntityManager, ctx.Event.SenderCharacterEntity, NameToGuid[item.Name], val);
				EquipEquipment(ctx.Event.SenderCharacterEntity, itemSlot);
			}
		}

		public static Entity AddItemToInventory(Entity recipient, PrefabGUID guid, int amount)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				AddItemResponse val = ((ServerGameManager)(ref serverGameManager)).TryAddInventoryItem(recipient, guid, amount);
				return val.NewEntity;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogFatal((object)ex);
			}
			return default(Entity);
		}

		public static void EquipEquipment(Entity player, int slot)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			EntityManager entityManager = Server.EntityManager;
			Entity val = ((EntityManager)(ref entityManager)).CreateEntity((ComponentType[])(object)new ComponentType[2]
			{
				ComponentType.ReadWrite<FromCharacter>(),
				ComponentType.ReadWrite<EquipItemEvent>()
			});
			entityManager = Server.EntityManager;
			PlayerCharacter componentData = ((EntityManager)(ref entityManager)).GetComponentData<PlayerCharacter>(player);
			Entity userEntity = componentData.UserEntity;
			entityManager = Server.EntityManager;
			((EntityManager)(ref entityManager)).SetComponentData<FromCharacter>(val, new FromCharacter
			{
				User = userEntity,
				Character = player
			});
			entityManager = Server.EntityManager;
			((EntityManager)(ref entityManager)).SetComponentData<EquipItemEvent>(val, new EquipItemEvent
			{
				SlotIndex = slot
			});
		}

		private static World GetWorld(string name)
		{
			Enumerator<World> enumerator = World.s_AllWorlds.GetEnumerator();
			while (enumerator.MoveNext())
			{
				World current = enumerator.Current;
				if (current.Name == name)
				{
					return current;
				}
			}
			return null;
		}
	}
}
namespace StarterKit.Hooks
{
	[HarmonyPatch(typeof(ServerBootstrapSystem), "OnUserConnected")]
	public static class OnUserConnected_Patch
	{
		public static void Postfix(ServerBootstrapSystem __instance, NetConnectionId netConnectionId)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EntityManager entityManager = ((ComponentSystemBase)__instance).EntityManager;
				int num = __instance._NetEndPointToApprovedUserIndex[netConnectionId];
				ServerClient val = ((Il2CppArrayBase<ServerClient>)(object)__instance._ApprovedUsersLookup)[num];
				Entity userEntity = val.UserEntity;
				EntityManager entityManager2 = ((ComponentSystemBase)__instance).EntityManager;
				User componentData = ((EntityManager)(ref entityManager2)).GetComponentData<User>(userEntity);
				if (!DB.UsedKits.ContainsKey(componentData.PlatformId))
				{
					DB.UsedKits.TryAdd(componentData.PlatformId, value: false);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(TriggerPersistenceSaveSystem), "TriggerSave")]
	public class TriggerPersistenceSaveSystem_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(SaveReason reason, FixedString128Bytes saveName, ServerRuntimeSettings saveConfig)
		{
			DB.SaveData();
		}
	}
}
namespace StarterKit.Database
{
	internal struct RecordKit
	{
		public string Name { get; set; }

		public int Amount { get; set; }

		public RecordKit(string name, int amount)
		{
			Name = name;
			Amount = amount;
		}
	}
	internal class DB
	{
		private static readonly string FileDirectory = Path.Combine("BepInEx", "config", "StarterKit");

		private static readonly string FileStartKits = "StartKits.json";

		private static readonly string FileUsedKits = "UsedKits.json";

		private static readonly string PathStarterKits = Path.Combine(FileDirectory, FileStartKits);

		private static readonly string PathUsedKits = Path.Combine(FileDirectory, FileUsedKits);

		public static ConcurrentDictionary<string, List<RecordKit>> StartKits = new ConcurrentDictionary<string, List<RecordKit>>();

		public static ConcurrentDictionary<ulong, bool> UsedKits = new ConcurrentDictionary<ulong, bool>();

		public static bool EnabledKitCommand = true;

		public static string MessageAlreadyUsedKit = "";

		public static string MessageOnGivenKit = "";

		internal static void SaveData()
		{
			File.WriteAllText(PathStarterKits, JsonSerializer.Serialize(StartKits, new JsonSerializerOptions
			{
				WriteIndented = true
			}));
			File.WriteAllText(PathUsedKits, JsonSerializer.Serialize(UsedKits, new JsonSerializerOptions
			{
				WriteIndented = true
			}));
			Plugin.Logger.LogWarning((object)"StartKit, UsedKits DB Saved.");
		}

		internal static void LoadData()
		{
			if (!Directory.Exists(FileDirectory))
			{
				Directory.CreateDirectory(FileDirectory);
			}
			LoadStarterKit();
			LoadUsedKits();
			SaveData();
		}

		internal static void LoadUsedKits()
		{
			if (!File.Exists(PathUsedKits))
			{
				UsedKits.Clear();
				Plugin.Logger.LogWarning((object)"UsedKits DB Created.");
			}
			else
			{
				string json = File.ReadAllText(PathUsedKits);
				UsedKits = JsonSerializer.Deserialize<ConcurrentDictionary<ulong, bool>>(json);
				Plugin.Logger.LogWarning((object)"UsedKits DB Populated");
			}
		}

		internal static void LoadStarterKit()
		{
			if (!File.Exists(PathStarterKits))
			{
				StartKits.Clear();
				StartKits.TryAdd("startkit", new List<RecordKit>
				{
					new RecordKit("Item_Boots_T09_Dracula_Brute", 1),
					new RecordKit("Item_Chest_T09_Dracula_Brute", 1),
					new RecordKit("Item_Gloves_T09_Dracula_Brute", 1),
					new RecordKit("Item_Legs_T09_Dracula_Brute", 1)
				});
				Plugin.Logger.LogWarning((object)"StartKit DB Created.");
			}
			else
			{
				string json = File.ReadAllText(PathStarterKits);
				StartKits = JsonSerializer.Deserialize<ConcurrentDictionary<string, List<RecordKit>>>(json);
				Plugin.Logger.LogWarning((object)"StartKit DB Populated");
			}
		}
	}
}
namespace StarterKit.Configs
{
	internal class MainConfig
	{
		private static readonly string FileDirectory = Path.Combine("BepInEx", "config");

		private static readonly string FileName = "StarterKit.cfg";

		private static readonly string fullPath = Path.Combine(FileDirectory, FileName);

		private static readonly ConfigFile Conf = new ConfigFile(fullPath, true);

		public static ConfigEntry<string> MessageOnGivenKit;

		public static ConfigEntry<string> MessageAlreadyUsedKit;

		public static ConfigEntry<bool> EnabledKitCommand;

		public static void ConfigInit()
		{
			EnabledKitCommand = Conf.Bind<bool>("StarterKit", "EnableKitCommand", true, "Enable kit command..");
			MessageOnGivenKit = Conf.Bind<string>("StarterKit", "MessageOnGivenKit", "Enjoy your <color=#ffffffff>free gear pack</color> and let the battle begin!", "Message when kit given player.");
			MessageAlreadyUsedKit = Conf.Bind<string>("StarterKit", "MessageAlreadyUsedKit", "You have already used the starter kit.", "Message when the player has already used a kit and will try to use it again.");
			ConfigBind();
		}

		public static void ConfigBind()
		{
			DB.EnabledKitCommand = EnabledKitCommand.Value;
			DB.MessageAlreadyUsedKit = MessageAlreadyUsedKit.Value;
			DB.MessageOnGivenKit = MessageOnGivenKit.Value;
		}
	}
}
namespace StarterKit.Commands
{
	internal class KitCommands
	{
		[Command("kit", null, null, "Give new vampire start kit.", null, false)]
		public static void KitCommand(ChatCommandContext ctx, string KitName = "StartKit")
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (DB.EnabledKitCommand)
			{
				ulong platformId = ctx.User.PlatformId;
				if (DB.StartKits.TryGetValue(KitName.ToLower(), out var value))
				{
					if (DB.UsedKits.TryGetValue(platformId, out var value2))
					{
						if (!value2)
						{
							Helper.GiveStartKit(ctx, value);
							DB.UsedKits[platformId] = true;
							ctx.Reply("Enjoy your <color=#ffffffff>free gear pack</color> and let the battle begin!");
						}
						else
						{
							ctx.Reply("You have already used the starter kit.");
						}
					}
				}
				else
				{
					ctx.Reply("Kit with name [" + KitName + "] not found.");
				}
			}
			else
			{
				ctx.Reply("Command disabled by admins.");
			}
		}
	}
}