using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Timers;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DiscordConnector.Config;
using DiscordConnector.Leaderboards;
using DiscordConnector.Records;
using HarmonyLib;
using LiteDB;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Valheim Discord Connector (games.nwest.valheim.discordconnector)")]
[assembly: AssemblyProduct("Valheim Discord Connector")]
[assembly: AssemblyCopyright("© 2024 Nicholas Westerhausen Repository at github: nwesterhausen/valheim-discordconnector")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.3.2.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 DiscordConnector
{
	internal class ConfigWatcher
	{
		private static Regex watchedConfigFilesRegex = new Regex("discordconnector?[\\w\\-]*\\.cfg$");

		private static Regex configExtensionMatcherRegex = new Regex("discordconnector-(\\w+)\\.cfg$");

		private static DateTime lastChangeDetected;

		private static int DEBOUNCE_SECONDS = 10;

		private static Dictionary<string, string> _fileHashDictionary;

		public ConfigWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
			fileSystemWatcher.NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite;
			fileSystemWatcher.Changed += OnChanged;
			fileSystemWatcher.Error += OnError;
			fileSystemWatcher.Path = Plugin.StaticConfig.configPath;
			fileSystemWatcher.Filter = "discordconnector*.cfg";
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.EnableRaisingEvents = true;
			Plugin.StaticLogger.LogInfo("File watcher loaded and watching for changes to configs.");
			_fileHashDictionary = new Dictionary<string, string>();
			PopulateHashDictionary();
			lastChangeDetected = DateTime.Now;
		}

		private void PopulateHashDictionary()
		{
			Task.Run(delegate
			{
				foreach (string item in from file in Directory.EnumerateFiles(Plugin.StaticConfig.configPath)
					where watchedConfigFilesRegex.IsMatch(file)
					select file)
				{
					string key = ConfigExtensionFromFilename(item);
					_fileHashDictionary.Add(key, Hashing.GetMD5Checksum(item));
				}
				Plugin.StaticLogger.LogDebug("Initialization of file hash dictionary completed.");
				Plugin.StaticLogger.LogDebug(string.Join(Environment.NewLine, _fileHashDictionary));
			});
		}

		private static string ConfigExtensionFromFilename(string filename)
		{
			string result = "main";
			Match match = configExtensionMatcherRegex.Match(filename);
			if (match.Success && match.Groups.Count > 1)
			{
				result = match.Groups[1].Value;
			}
			return result;
		}

		private static void OnChanged(object sender, FileSystemEventArgs e)
		{
			if (e.ChangeType == WatcherChangeTypes.Changed)
			{
				string text = ConfigExtensionFromFilename(e.FullPath);
				Plugin.StaticLogger.LogDebug("Detected change of " + text + " config file");
				string mD5Checksum = Hashing.GetMD5Checksum(e.FullPath);
				if (!_fileHashDictionary.ContainsKey(text))
				{
					Plugin.StaticLogger.LogWarning("Unexpectedly encountered unhashed config file!");
					Plugin.StaticLogger.LogDebug("Added " + text + " config to config hash dictionary.");
					_fileHashDictionary.Add(text, mD5Checksum);
				}
				else if (string.Equals(_fileHashDictionary[text], mD5Checksum))
				{
					Plugin.StaticLogger.LogDebug("Changes to file were determined to be inconsequential.");
				}
				else if (lastChangeDetected.AddSeconds(DEBOUNCE_SECONDS) > DateTime.Now)
				{
					Plugin.StaticLogger.LogDebug("Skipping config reload, within DEBOUNCE timing.");
				}
				else
				{
					Plugin.StaticConfig.ReloadConfig(text);
					lastChangeDetected = DateTime.Now;
				}
			}
		}

		private static void OnError(object sender, ErrorEventArgs e)
		{
			Plugin.StaticLogger.LogError(e.GetException().ToString());
		}
	}
	internal class PluginConfig
	{
		private MainConfig mainConfig;

		private MessagesConfig messagesConfig;

		private TogglesConfig togglesConfig;

		private VariableConfig variableConfig;

		private LeaderBoardConfig leaderBoardConfig;

		private ExtraWebhookConfig extraWebhookConfig;

		public readonly string configPath;

		private const string ConfigJsonFilename = "config-dump.json";

		internal static string[] ConfigExtensions = new string[6] { "messages", "variables", "leaderBoard", "toggles", "extraWebhooks", "main" };

		public bool LaunchMessageEnabled => togglesConfig.LaunchMessageEnabled;

		public bool LoadedMessageEnabled => togglesConfig.LoadedMessageEnabled;

		public bool StopMessageEnabled => togglesConfig.StopMessageEnabled;

		public bool ShutdownMessageEnabled => togglesConfig.ShutdownMessageEnabled;

		public bool WorldSaveMessageEnabled => togglesConfig.WorldSaveMessageEnabled;

		public bool ChatShoutEnabled => togglesConfig.ChatShoutEnabled;

		public bool ChatPingEnabled => togglesConfig.ChatPingEnabled;

		public bool PlayerJoinMessageEnabled => togglesConfig.PlayerJoinMessageEnabled;

		public bool PlayerDeathMessageEnabled => togglesConfig.PlayerDeathMessageEnabled;

		public bool PlayerLeaveMessageEnabled => togglesConfig.PlayerLeaveMessageEnabled;

		public bool EventStartMessageEnabled => togglesConfig.EventStartMessageEnabled;

		public bool EventStopMessageEnabled => togglesConfig.EventStopMessageEnabled;

		public bool EventPausedMessageEnabled => togglesConfig.EventPausedMessageEnabled;

		public bool EventResumedMessageEnabled => togglesConfig.EventResumedMessageEnabled;

		public bool ChatShoutAllCaps => togglesConfig.ChatShoutAllCaps;

		public bool NewDayNumberEnabled => togglesConfig.NewDayNumberEnabled;

		public bool StatsDeathEnabled
		{
			get
			{
				if (mainConfig.CollectStatsEnabled)
				{
					return togglesConfig.StatsDeathEnabled;
				}
				return false;
			}
		}

		public bool StatsJoinEnabled
		{
			get
			{
				if (mainConfig.CollectStatsEnabled)
				{
					return togglesConfig.StatsJoinEnabled;
				}
				return false;
			}
		}

		public bool StatsLeaveEnabled
		{
			get
			{
				if (mainConfig.CollectStatsEnabled)
				{
					return togglesConfig.StatsLeaveEnabled;
				}
				return false;
			}
		}

		public bool StatsPingEnabled
		{
			get
			{
				if (mainConfig.CollectStatsEnabled)
				{
					return togglesConfig.StatsPingEnabled;
				}
				return false;
			}
		}

		public bool StatsShoutEnabled
		{
			get
			{
				if (mainConfig.CollectStatsEnabled)
				{
					return togglesConfig.StatsShoutEnabled;
				}
				return false;
			}
		}

		public bool ChatPingPosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.ChatPingPosEnabled;
				}
				return false;
			}
		}

		public bool ChatShoutPosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.ChatShoutPosEnabled;
				}
				return false;
			}
		}

		public bool PlayerJoinPosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.PlayerJoinPosEnabled;
				}
				return false;
			}
		}

		public bool PlayerDeathPosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.PlayerDeathPosEnabled;
				}
				return false;
			}
		}

		public bool PlayerLeavePosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.PlayerLeavePosEnabled;
				}
				return false;
			}
		}

		public bool EventStartPosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.EventStartPosEnabled;
				}
				return false;
			}
		}

		public bool EventStopPosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.EventStopPosEnabled;
				}
				return false;
			}
		}

		public bool EventPausedPosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.EventPausedPosEnabled;
				}
				return false;
			}
		}

		public bool EventResumedPosEnabled
		{
			get
			{
				if (mainConfig.SendPositionsEnabled)
				{
					return togglesConfig.EventResumedPosEnabled;
				}
				return false;
			}
		}

		public string DefaultWebhookUsernameOverride => mainConfig.DefaultWebhookUsernameOverride;

		public WebhookEntry PrimaryWebhook => mainConfig.PrimaryWebhook;

		public WebhookEntry SecondaryWebhook => mainConfig.SecondaryWebhook;

		public bool CollectStatsEnabled => mainConfig.CollectStatsEnabled;

		public bool DiscordEmbedsEnabled => mainConfig.DiscordEmbedsEnabled;

		public bool SendPositionsEnabled => mainConfig.SendPositionsEnabled;

		public bool AnnouncePlayerFirsts => mainConfig.AnnouncePlayerFirsts;

		public MainConfig.RetrievalDiscernmentMethods RecordRetrievalDiscernmentMethod => mainConfig.RecordRetrievalDiscernmentMethod;

		public List<string> MutedPlayers => mainConfig.MutedPlayers;

		public Regex MutedPlayersRegex => mainConfig.MutedPlayersRegex;

		public bool AllowNonPlayerShoutLogging => mainConfig.AllowNonPlayerShoutLogging;

		public bool AllowMentionsHereEveryone => mainConfig.AllowMentionsHereEveryone;

		public bool AllowMentionsAnyRole => mainConfig.AllowMentionsAnyRole;

		public bool AllowMentionsAnyUser => mainConfig.AllowMentionsAnyUser;

		public List<string> AllowedRoleMentions => mainConfig.AllowedRoleMentions;

		public List<string> AllowedUserMentions => mainConfig.AllowedUserMentions;

		public string LaunchMessage => messagesConfig.LaunchMessage;

		public string LoadedMessage => messagesConfig.LoadedMessage;

		public string StopMessage => messagesConfig.StopMessage;

		public string ShutdownMessage => messagesConfig.ShutdownMessage;

		public string SaveMessage => messagesConfig.SaveMessage;

		public string NewDayMessage => messagesConfig.NewDayMessage;

		public string JoinMessage => messagesConfig.JoinMessage;

		public string LeaveMessage => messagesConfig.LeaveMessage;

		public string DeathMessage => messagesConfig.DeathMessage;

		public string PingMessage => messagesConfig.PingMessage;

		public string ShoutMessage => messagesConfig.ShoutMessage;

		public string PlayerFirstDeathMessage => messagesConfig.PlayerFirstDeathMessage;

		public string PlayerFirstJoinMessage => messagesConfig.PlayerFirstJoinMessage;

		public string PlayerFirstLeaveMessage => messagesConfig.PlayerFirstLeaveMessage;

		public string PlayerFirstPingMessage => messagesConfig.PlayerFirstPingMessage;

		public string PlayerFirstShoutMessage => messagesConfig.PlayerFirstShoutMessage;

		public bool AnnouncePlayerFirstDeathEnabled
		{
			get
			{
				if (mainConfig.AnnouncePlayerFirsts)
				{
					return togglesConfig.AnnouncePlayerFirstDeathEnabled;
				}
				return false;
			}
		}

		public bool AnnouncePlayerFirstJoinEnabled
		{
			get
			{
				if (mainConfig.AnnouncePlayerFirsts)
				{
					return togglesConfig.AnnouncePlayerFirstJoinEnabled;
				}
				return false;
			}
		}

		public bool AnnouncePlayerFirstLeaveEnabled
		{
			get
			{
				if (mainConfig.AnnouncePlayerFirsts)
				{
					return togglesConfig.AnnouncePlayerFirstLeaveEnabled;
				}
				return false;
			}
		}

		public bool AnnouncePlayerFirstPingEnabled
		{
			get
			{
				if (mainConfig.AnnouncePlayerFirsts)
				{
					return togglesConfig.AnnouncePlayerFirstPingEnabled;
				}
				return false;
			}
		}

		public bool AnnouncePlayerFirstShoutEnabled
		{
			get
			{
				if (mainConfig.AnnouncePlayerFirsts)
				{
					return togglesConfig.AnnouncePlayerFirstShoutEnabled;
				}
				return false;
			}
		}

		public string EventStartMessage => messagesConfig.EventStartMessage;

		public string EventStopMessage => messagesConfig.EventStopMessage;

		public string EventPausedMessage => messagesConfig.EventPausedMessage;

		public string EventResumedMessage => messagesConfig.EventResumedMessage;

		public string UserVariable => variableConfig.UserVariable;

		public string UserVariable1 => variableConfig.UserVariable1;

		public string UserVariable2 => variableConfig.UserVariable2;

		public string UserVariable3 => variableConfig.UserVariable3;

		public string UserVariable4 => variableConfig.UserVariable4;

		public string UserVariable5 => variableConfig.UserVariable5;

		public string UserVariable6 => variableConfig.UserVariable6;

		public string UserVariable7 => variableConfig.UserVariable7;

		public string UserVariable8 => variableConfig.UserVariable8;

		public string UserVariable9 => variableConfig.UserVariable9;

		public string PosVarFormat => variableConfig.PosVarFormat;

		public string AppendedPosFormat => variableConfig.AppendedPosFormat;

		public bool DebugEveryPlayerPosCheck => togglesConfig.DebugEveryPlayerPosCheck;

		public bool DebugEveryEventCheck => togglesConfig.DebugEveryEventCheck;

		public bool DebugEveryEventChange => togglesConfig.DebugEveryEventChange;

		public bool DebugHttpRequestResponse => togglesConfig.DebugHttpRequestResponse;

		public bool DebugDatabaseMethods => togglesConfig.DebugDatabaseMethods;

		public string LeaderBoardTopPlayerHeading => messagesConfig.LeaderBoardTopPlayerHeading;

		public string LeaderBoardBottomPlayersHeading => messagesConfig.LeaderBoardBottomPlayersHeading;

		public string LeaderBoardHighestHeading => messagesConfig.LeaderBoardHighestHeading;

		public string LeaderBoardLowestHeading => messagesConfig.LeaderBoardLowestHeading;

		public LeaderBoardConfigReference[] LeaderBoards => leaderBoardConfig.LeaderBoards;

		public ActivePlayersAnnouncementConfigValues ActivePlayersAnnouncement => leaderBoardConfig.ActivePlayersAnnouncement;

		public List<WebhookEntry> ExtraWebhooks => extraWebhookConfig.GetWebhookEntries();

		internal void migrateConfigIfNeeded()
		{
			if (!Directory.Exists(configPath))
			{
				Directory.CreateDirectory(configPath);
			}
			string[] configExtensions = ConfigExtensions;
			foreach (string text in configExtensions)
			{
				string text2 = Path.Combine(Paths.ConfigPath, "games.nwest.valheim.discordconnector-" + text + ".cfg");
				string text3 = Path.Combine(configPath, "discordconnector-" + text + ".cfg");
				if (text.Equals("main"))
				{
					text2 = Path.Combine(Paths.ConfigPath, "games.nwest.valheim.discordconnector.cfg");
					text3 = Path.Combine(configPath, "discordconnector.cfg");
				}
				if (File.Exists(text2))
				{
					if (File.Exists(text3))
					{
						Plugin.StaticLogger.LogWarning("Expected to be moving " + text + " config from pre-2.1.0 location to new config location, but already exists!");
					}
					else
					{
						File.Move(text2, text3);
					}
				}
			}
		}

		public PluginConfig(ConfigFile config)
		{
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Expected O, but got Unknown
			configPath = Path.Combine(Paths.ConfigPath, "games.nwest.valheim.discordconnector");
			migrateConfigIfNeeded();
			string path = "discordconnector.cfg";
			string path2 = "discordconnector-" + MessagesConfig.ConfigExtension + ".cfg";
			string path3 = "discordconnector-" + TogglesConfig.ConfigExtension + ".cfg";
			string path4 = "discordconnector-" + VariableConfig.ConfigExtension + ".cfg";
			string path5 = "discordconnector-" + LeaderBoardConfig.ConfigExtension + ".cfg";
			string path6 = "discordconnector-" + ExtraWebhookConfig.ConfigExtension + ".cfg";
			string text = Path.Combine(configPath, path);
			string text2 = Path.Combine(configPath, path2);
			string text3 = Path.Combine(configPath, path3);
			string text4 = Path.Combine(configPath, path4);
			string text5 = Path.Combine(configPath, path5);
			string text6 = Path.Combine(configPath, path6);
			Plugin.StaticLogger.LogDebug("Main config: " + text);
			Plugin.StaticLogger.LogDebug("Messages config: " + text2);
			Plugin.StaticLogger.LogDebug("Toggles config: " + text3);
			Plugin.StaticLogger.LogDebug("Variable config: " + text4);
			Plugin.StaticLogger.LogDebug("Leader board config: " + text5);
			Plugin.StaticLogger.LogDebug("Extra Webhook config: " + text6);
			mainConfig = new MainConfig(new ConfigFile(text, true));
			messagesConfig = new MessagesConfig(new ConfigFile(text2, true));
			togglesConfig = new TogglesConfig(new ConfigFile(text3, true));
			variableConfig = new VariableConfig(new ConfigFile(text4, true));
			leaderBoardConfig = new LeaderBoardConfig(new ConfigFile(text5, true));
			extraWebhookConfig = new ExtraWebhookConfig(new ConfigFile(text6, true));
			Plugin.StaticLogger.LogDebug("Configuration Loaded");
			Plugin.StaticLogger.LogDebug("Muted Players Regex pattern ('a^' is default for no matches): " + mainConfig.MutedPlayersRegex.ToString());
			DumpConfigAsJson();
		}

		public void ReloadConfig()
		{
			mainConfig.ReloadConfig();
			messagesConfig.ReloadConfig();
			togglesConfig.ReloadConfig();
			variableConfig.ReloadConfig();
			leaderBoardConfig.ReloadConfig();
			extraWebhookConfig.ReloadConfig();
		}

		public void ReloadConfig(string configExt)
		{
			switch (configExt)
			{
			case "main":
				mainConfig.ReloadConfig();
				break;
			case "messages":
				messagesConfig.ReloadConfig();
				break;
			case "toggles":
				togglesConfig.ReloadConfig();
				break;
			case "variables":
				variableConfig.ReloadConfig();
				break;
			case "leaderBoard":
				leaderBoardConfig.ReloadConfig();
				break;
			case "extraWebhooks":
				extraWebhookConfig.ReloadConfig();
				break;
			}
		}

		public void DumpConfigAsJson()
		{
			string jsonString = "{";
			jsonString = jsonString + "\"Config.Main\":" + mainConfig.ConfigAsJson() + ",";
			jsonString = jsonString + "\"Config.Messages\":" + messagesConfig.ConfigAsJson() + ",";
			jsonString = jsonString + "\"Config.Toggles\":" + togglesConfig.ConfigAsJson() + ",";
			jsonString = jsonString + "\"Config.Variables\":" + variableConfig.ConfigAsJson() + ",";
			jsonString = jsonString + "\"Config.LeaderBoard\":" + leaderBoardConfig.ConfigAsJson() + ",";
			jsonString = jsonString + "\"Config.ExtraWebhooks\":" + extraWebhookConfig.ConfigAsJson();
			jsonString += "}";
			Task.Run(delegate
			{
				File.WriteAllText(Path.Combine(configPath, "config-dump.json"), jsonString);
				Plugin.StaticLogger.LogDebug("Dumped configuration files to config-dump.json");
			});
		}
	}
	internal class DiscordApi
	{
		public static void SendMessage(Webhook.Event ev, string message, Vector3 pos)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.StaticConfig.DiscordEmbedsEnabled)
			{
				SendMessageWithFields(ev, message, new List<Tuple<string, string>>(1) { Tuple.Create("Coordinates", MessageTransformer.FormatVector3AsPos(pos)) });
			}
			else
			{
				SendMessage(ev, message + " " + MessageTransformer.FormatAppendedPos(pos));
			}
		}

		public static void SendMessage(Webhook.Event ev, string message)
		{
			DiscordExecuteWebhook discordExecuteWebhook = new DiscordExecuteWebhook();
			discordExecuteWebhook.content = message;
			discordExecuteWebhook.SendFor(ev);
		}

		public static void SendMessageWithFields(Webhook.Event ev, string content = null, List<Tuple<string, string>> fields = null)
		{
			if (string.IsNullOrEmpty(content) && fields == null)
			{
				content = "Uh-oh! An unexpectedly empty message was sent!";
			}
			DiscordExecuteWebhook discordExecuteWebhook = new DiscordExecuteWebhook
			{
				content = content
			};
			if (fields != null)
			{
				discordExecuteWebhook.embeds = new List<DiscordEmbed>();
				List<DiscordField> list = new List<DiscordField>();
				new List<string>();
				foreach (Tuple<string, string> field in fields)
				{
					list.Add(new DiscordField
					{
						name = field.Item1,
						value = field.Item2
					});
				}
				discordExecuteWebhook.embeds.Add(new DiscordEmbed
				{
					fields = list
				});
			}
			discordExecuteWebhook.SendFor(ev);
		}

		public static void SendSerializedJson(Webhook.Event ev, string serializedJson)
		{
			Plugin.StaticLogger.LogDebug($"Finding webhooks for event: (event: {ev})");
			if (ev == Webhook.Event.Other)
			{
				Plugin.StaticLogger.LogInfo("Dispatching webhook for 3rd party plugin (configured as 'Other' in WebHook config)");
			}
			if ((string.IsNullOrEmpty(Plugin.StaticConfig.PrimaryWebhook.Url) && string.IsNullOrEmpty(Plugin.StaticConfig.SecondaryWebhook.Url)) || string.IsNullOrEmpty(serializedJson))
			{
				return;
			}
			byte[] bytes = Encoding.UTF8.GetBytes(serializedJson);
			if (Plugin.StaticConfig.PrimaryWebhook.HasEvent(ev))
			{
				Plugin.StaticLogger.LogDebug($"Sending {ev} message to Primary Webhook");
				DispatchRequest(Plugin.StaticConfig.PrimaryWebhook, bytes);
			}
			if (Plugin.StaticConfig.SecondaryWebhook.HasEvent(ev))
			{
				Plugin.StaticLogger.LogDebug($"Sending {ev} message to Secondary Webhook");
				DispatchRequest(Plugin.StaticConfig.SecondaryWebhook, bytes);
			}
			foreach (WebhookEntry extraWebhook in Plugin.StaticConfig.ExtraWebhooks)
			{
				if (extraWebhook.HasEvent(ev))
				{
					Plugin.StaticLogger.LogDebug($"Sending {ev} message to Extra Webhook: {extraWebhook.Url}");
					DispatchRequest(extraWebhook, bytes);
				}
			}
		}

		public static void SendSerializedJson(WebhookEntry webhook, string serializedJson)
		{
			Plugin.StaticLogger.LogDebug("Trying webhook with payload: " + serializedJson);
			if (!string.IsNullOrEmpty(webhook.Url) && !string.IsNullOrEmpty(serializedJson))
			{
				byte[] bytes = Encoding.UTF8.GetBytes(serializedJson);
				DispatchRequest(webhook, bytes);
			}
		}

		private static void DispatchRequest(WebhookEntry webhook, byte[] byteArray)
		{
			if (string.IsNullOrEmpty(webhook.Url))
			{
				Plugin.StaticLogger.LogDebug("Dispatch attempted with empty webhook - ignoring");
				return;
			}
			string requestId = GuidHelper.GenerateShortHexGuid();
			Plugin.StaticLogger.LogDebug($"DispatchRequest.{requestId}: sending {byteArray.Length} bytes to Discord");
			WebRequest request = WebRequest.Create(webhook.Url);
			request.Method = "POST";
			request.ContentType = "application/json";
			request.ContentLength = byteArray.Length;
			Task.Run(delegate
			{
				try
				{
					using (Stream stream = request.GetRequestStream())
					{
						stream.Write(byteArray, 0, byteArray.Length);
					}
					bool flag = true;
					WebResponse webResponse = null;
					try
					{
						webResponse = request.GetResponse();
						if (Plugin.StaticConfig.DebugHttpRequestResponse)
						{
							if (webResponse is HttpWebResponse httpWebResponse)
							{
								if (httpWebResponse.StatusCode == HttpStatusCode.NoContent)
								{
									flag = false;
								}
								Plugin.StaticLogger.LogDebug($"DispatchRequest.{requestId}: Response Code: {httpWebResponse.StatusCode}");
							}
							else
							{
								Plugin.StaticLogger.LogDebug("DispatchRequest." + requestId + ": Response was not an HttpWebResponse");
							}
						}
					}
					catch (WebException arg)
					{
						Plugin.StaticLogger.LogError($"DispatchRequest.{requestId}: Error getting web response: {arg}");
						return;
					}
					if (flag)
					{
						using Stream stream2 = webResponse.GetResponseStream();
						if (stream2 == null)
						{
							Plugin.StaticLogger.LogError("DispatchRequest." + requestId + ": Response stream is null");
							return;
						}
						using StreamReader streamReader = new StreamReader(stream2);
						string text = streamReader.ReadToEnd();
						if (Plugin.StaticConfig.DebugHttpRequestResponse)
						{
							if (text.Length > 0)
							{
								Plugin.StaticLogger.LogDebug("DispatchRequest." + requestId + ": Response from server: " + text);
							}
							else
							{
								Plugin.StaticLogger.LogDebug("DispatchRequest." + requestId + ": Empty response from server (normal)");
							}
						}
					}
					webResponse.Close();
				}
				catch (Exception arg2)
				{
					Plugin.StaticLogger.LogWarning($"Error dispatching webhook: {arg2}");
				}
			}).ConfigureAwait(continueOnCapturedContext: false);
		}

		public static void SendMessage(string message, Vector3 pos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			SendMessage(Webhook.Event.Other, message, pos);
		}

		public static void SendMessage(string message)
		{
			SendMessage(Webhook.Event.Other, message);
		}

		public static void SendMessageWithFields(string content = null, List<Tuple<string, string>> fields = null)
		{
			SendMessageWithFields(Webhook.Event.Other, content, fields);
		}

		private static void SendSerializedJson(string serializedJson)
		{
			SendSerializedJson(Webhook.Event.Other, serializedJson);
		}
	}
	internal class DiscordExecuteWebhook
	{
		public string? content { get; set; }

		public string? username { get; set; }

		public string? avatar_url { get; set; }

		public List<DiscordEmbed>? embeds { get; set; }

		public AllowedMentions? allowed_mentions { get; set; }

		public DiscordExecuteWebhook()
		{
			allowed_mentions = new AllowedMentions();
			ResetOverrides();
		}

		public void SetUsername(string username)
		{
			this.username = username;
		}

		public void SetAvatarUrl(string avatar_url)
		{
			this.avatar_url = avatar_url;
		}

		public bool IsValid()
		{
			if (string.IsNullOrEmpty(content))
			{
				return embeds != null;
			}
			return true;
		}

		public void ResetOverrides()
		{
			username = null;
			avatar_url = null;
			if (!string.IsNullOrEmpty(Plugin.StaticConfig.DefaultWebhookUsernameOverride))
			{
				SetUsername(Plugin.StaticConfig.DefaultWebhookUsernameOverride);
			}
		}

		public void SendFor(Webhook.Event ev)
		{
			if (!IsValid())
			{
				Plugin.StaticLogger.LogWarning($"Attempted to send an invalid DiscordExecuteWebhook object:\n{this}");
				return;
			}
			try
			{
				if (Plugin.StaticConfig.PrimaryWebhook.HasEvent(ev))
				{
					Plugin.StaticLogger.LogDebug($"Sending {ev} message to Primary Webhook");
					WebhookEntry primaryWebhook = Plugin.StaticConfig.PrimaryWebhook;
					ResetOverrides();
					if (primaryWebhook.HasUsernameOverride())
					{
						SetUsername(primaryWebhook.UsernameOverride);
					}
					if (primaryWebhook.HasAvatarOverride())
					{
						SetAvatarUrl(primaryWebhook.AvatarOverride);
					}
					DiscordApi.SendSerializedJson(primaryWebhook, JsonConvert.SerializeObject((object)this));
				}
				if (Plugin.StaticConfig.SecondaryWebhook.HasEvent(ev))
				{
					Plugin.StaticLogger.LogDebug($"Sending {ev} message to Secondary Webhook");
					WebhookEntry secondaryWebhook = Plugin.StaticConfig.SecondaryWebhook;
					ResetOverrides();
					if (secondaryWebhook.HasUsernameOverride())
					{
						SetUsername(secondaryWebhook.UsernameOverride);
					}
					if (secondaryWebhook.HasAvatarOverride())
					{
						SetAvatarUrl(secondaryWebhook.AvatarOverride);
					}
					DiscordApi.SendSerializedJson(secondaryWebhook, JsonConvert.SerializeObject((object)this));
				}
				if (Plugin.StaticConfig.ExtraWebhooks == null)
				{
					return;
				}
				foreach (WebhookEntry extraWebhook in Plugin.StaticConfig.ExtraWebhooks)
				{
					if (extraWebhook.HasEvent(ev))
					{
						Plugin.StaticLogger.LogDebug($"Sending {ev} message to an Extra Webhook");
						ResetOverrides();
						if (extraWebhook.HasUsernameOverride())
						{
							SetUsername(extraWebhook.UsernameOverride);
						}
						if (extraWebhook.HasAvatarOverride())
						{
							SetAvatarUrl(extraWebhook.AvatarOverride);
						}
						DiscordApi.SendSerializedJson(extraWebhook, JsonConvert.SerializeObject((object)this));
					}
				}
			}
			catch (Exception arg)
			{
				Plugin.StaticLogger.LogWarning($"Error serializing payload: {arg}");
			}
		}
	}
	internal class AllowedMentions
	{
		public List<string> parse { get; set; }

		public List<string> roles { get; set; }

		public List<string> users { get; set; }

		public bool replied_user { get; set; }

		public AllowedMentions()
		{
			parse = new List<string>();
			roles = new List<string>();
			users = new List<string>();
			replied_user = false;
			if (Plugin.StaticConfig.AllowMentionsHereEveryone)
			{
				AllowEveryone();
			}
			if (Plugin.StaticConfig.AllowMentionsAnyRole)
			{
				AllowAnyRoles();
			}
			if (Plugin.StaticConfig.AllowMentionsAnyUser)
			{
				AllowAnyUsers();
			}
			if (Plugin.StaticConfig.AllowedRoleMentions.Count > 0)
			{
				AllowRoles(Plugin.StaticConfig.AllowedRoleMentions);
			}
			if (Plugin.StaticConfig.AllowedUserMentions.Count > 0)
			{
				AllowUsers(Plugin.StaticConfig.AllowedUserMentions);
			}
		}

		public void AllowEveryone()
		{
			if (!parse.Contains("everyone"))
			{
				parse.Add("everyone");
			}
		}

		public void AllowHere()
		{
			if (!parse.Contains("everyone"))
			{
				parse.Add("everyone");
			}
		}

		public void AllowRole(string role_id)
		{
			if (!roles.Contains(role_id))
			{
				roles.Add(role_id);
			}
		}

		public void AllowRoles(List<string> role_ids)
		{
			foreach (string role_id in role_ids)
			{
				AllowRole(role_id);
			}
		}

		public void DisallowRole(string role_id)
		{
			if (roles.Contains(role_id))
			{
				roles.Remove(role_id);
			}
		}

		public void AllowUser(string user_id)
		{
			if (!users.Contains(user_id))
			{
				users.Add(user_id);
			}
		}

		public void AllowUsers(List<string> user_ids)
		{
			foreach (string user_id in user_ids)
			{
				AllowUser(user_id);
			}
		}

		public void DisallowUser(string user_id)
		{
			if (users.Contains(user_id))
			{
				users.Remove(user_id);
			}
		}

		public void AllowAnyRoles()
		{
			if (!parse.Contains("roles"))
			{
				parse.Add("roles");
			}
		}

		public void AllowAnyUsers()
		{
			if (!parse.Contains("users"))
			{
				parse.Add("users");
			}
		}

		public void DisallowAnyRoles()
		{
			if (parse.Contains("roles"))
			{
				parse.Remove("roles");
			}
		}

		public void DisallowAnyUsers()
		{
			if (parse.Contains("users"))
			{
				parse.Remove("users");
			}
		}
	}
	internal class DiscordEmbed
	{
		public string? title { get; set; }

		public string? description { get; set; }

		public List<DiscordField>? fields { get; set; }
	}
	internal class DiscordField
	{
		public string name { get; set; }

		public string value { get; set; }

		public bool? inline { get; set; }
	}
	internal class EventWatcher
	{
		private static class Status
		{
			public static bool HaveActiveEvent => RandEventSystem.HaveActiveEvent();

			public static RandomEvent Event
			{
				get
				{
					if (!HaveActiveEvent)
					{
						return null;
					}
					return RandEventSystem.instance.GetCurrentRandomEvent();
				}
			}

			public static string Name
			{
				get
				{
					if (!HaveActiveEvent)
					{
						return "";
					}
					return Event.m_name;
				}
			}

			public static float Duration
			{
				get
				{
					if (!HaveActiveEvent)
					{
						return 0f;
					}
					return Event.m_duration;
				}
			}

			public static float Elapsed
			{
				get
				{
					if (!HaveActiveEvent)
					{
						return 0f;
					}
					return Event.m_time;
				}
			}

			public static bool IsRunning
			{
				get
				{
					if (!HaveActiveEvent)
					{
						return false;
					}
					return RandEventSystem.instance.IsAnyPlayerInEventArea(Event);
				}
			}

			public static Vector3 Pos
			{
				get
				{
					//IL_0021: 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)
					if (!HaveActiveEvent)
					{
						return new Vector3(0f, 0f, 0f);
					}
					return Event.m_pos;
				}
			}

			public static string EndMessage
			{
				get
				{
					if (!HaveActiveEvent)
					{
						return "";
					}
					return Localization.instance.Localize(Event.m_endMessage);
				}
			}

			public static string StartMessage
			{
				get
				{
					if (!HaveActiveEvent)
					{
						return "";
					}
					return Localization.instance.Localize(Event.m_startMessage);
				}
			}

			public static string[] InvolvedPlayersList()
			{
				//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_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				List<string> list = new List<string>();
				if (!HaveActiveEvent)
				{
					return list.ToArray();
				}
				foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
				{
					if (!player.m_publicPosition)
					{
						if (Plugin.StaticConfig.DebugEveryPlayerPosCheck)
						{
							Plugin.StaticLogger.LogDebug("Unable to check location for " + player.m_name + " because their location is not public.");
						}
					}
					else if (RandEventSystem.instance.IsInsideRandomEventArea(Event, player.m_position))
					{
						list.Add(player.m_name);
						if (Plugin.StaticConfig.DebugEveryPlayerPosCheck)
						{
							Plugin.StaticLogger.LogDebug($"{player.m_name} is at {player.m_position}");
						}
					}
				}
				return list.ToArray();
			}
		}

		private bool WasRunning;

		private bool HadActiveEvent;

		private float PreviousElapsed;

		private string PreviousEventStartMessage;

		private string PreviousEventEndMessage;

		private Vector3 PreviousEventPos;

		private Timer randEventTimer;

		public EventWatcher()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			WasRunning = false;
			HadActiveEvent = false;
			PreviousElapsed = 0f;
			PreviousEventStartMessage = "";
			PreviousEventEndMessage = "";
			PreviousEventPos = default(Vector3);
			randEventTimer = new Timer();
			randEventTimer.Elapsed += CheckRandomEvent;
			randEventTimer.Interval = 1000.0;
		}

		public void Activate()
		{
			randEventTimer.Start();
		}

		public void Dispose()
		{
			randEventTimer.Stop();
		}

		public void CheckRandomEvent(object sender, ElapsedEventArgs elapsedEventArgs)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			if (Status.HaveActiveEvent)
			{
				string message = $"Currently an event: {Status.HaveActiveEvent}. {Status.StartMessage} | {Status.EndMessage}" + Environment.NewLine + $"Event: {Status.Name} at {Status.Pos}. Status.IsRunning: {Status.IsRunning}. {Status.Elapsed} of {Status.Duration} seconds completed." + Environment.NewLine + $"PreviousEventStartMsg: {PreviousEventStartMessage}, PreviousEventEndMsg: {PreviousEventEndMessage}, PreviousEventPos: {PreviousEventPos}" + Environment.NewLine + "Involved Players: " + string.Join(",", Status.InvolvedPlayersList());
				if (Plugin.StaticConfig.DebugEveryEventCheck)
				{
					Plugin.StaticLogger.LogDebug(message);
				}
				if (Status.IsRunning)
				{
					if (!HadActiveEvent)
					{
						TriggerEventStart();
						if (Plugin.StaticConfig.DebugEveryEventChange)
						{
							Plugin.StaticLogger.LogDebug(message);
						}
					}
					if (HadActiveEvent && !WasRunning)
					{
						TriggerEventResumed();
						if (Plugin.StaticConfig.DebugEveryEventChange)
						{
							Plugin.StaticLogger.LogDebug(message);
						}
					}
				}
				else if (!HadActiveEvent || (HadActiveEvent && WasRunning))
				{
					TriggerEventPaused();
					if (Plugin.StaticConfig.DebugEveryEventChange)
					{
						Plugin.StaticLogger.LogDebug(message);
					}
				}
				if (Status.Pos != Vector3.zero)
				{
					PreviousEventStartMessage = Status.StartMessage;
					PreviousEventEndMessage = Status.EndMessage;
					PreviousEventPos = Status.Pos;
				}
			}
			else
			{
				if (Plugin.StaticConfig.DebugEveryEventCheck)
				{
					Plugin.StaticLogger.LogDebug($"PreviousEventStartMsg: {PreviousEventStartMessage}, PreviousEventEndMsg: {PreviousEventEndMessage}, PreviousEventPos: {PreviousEventPos}" + Environment.NewLine + "Event check ran, no current events (or world isn't loaded yet).");
				}
				if (HadActiveEvent)
				{
					TriggerEventStop();
					if (Plugin.StaticConfig.DebugEveryEventChange)
					{
						Plugin.StaticLogger.LogDebug("Event stopped!");
					}
				}
			}
			HadActiveEvent = Status.HaveActiveEvent;
			WasRunning = Status.IsRunning;
			PreviousElapsed = Status.Elapsed;
		}

		internal void TriggerEventStart()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.StaticConfig.EventStartMessageEnabled)
			{
				string text = MessageTransformer.FormatEventStartMessage(Plugin.StaticConfig.EventResumedMessage, Status.StartMessage, Status.EndMessage);
				if (!Plugin.StaticConfig.EventStartPosEnabled)
				{
					DiscordApi.SendMessage(Webhook.Event.EventStart, text);
					return;
				}
				if (Plugin.StaticConfig.DiscordEmbedsEnabled || !text.Contains("%POS%"))
				{
					DiscordApi.SendMessage(Webhook.Event.EventStart, text, Status.Pos);
					return;
				}
				text = MessageTransformer.FormatEventStartMessage(Plugin.StaticConfig.EventResumedMessage, Status.EndMessage, Status.StartMessage, Status.Pos);
				DiscordApi.SendMessage(Webhook.Event.EventStart, text);
			}
		}

		internal void TriggerEventPaused()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.StaticConfig.EventPausedMessageEnabled)
			{
				string text = MessageTransformer.FormatEventMessage(Plugin.StaticConfig.EventPausedMessage, Status.StartMessage, Status.EndMessage);
				if (!Plugin.StaticConfig.EventPausedPosEnabled)
				{
					DiscordApi.SendMessage(Webhook.Event.EventPaused, text);
					return;
				}
				if (Plugin.StaticConfig.DiscordEmbedsEnabled || !text.Contains("%POS%"))
				{
					DiscordApi.SendMessage(Webhook.Event.EventPaused, text, Status.Pos);
					return;
				}
				text = MessageTransformer.FormatEventMessage(Plugin.StaticConfig.EventPausedMessage, Status.StartMessage, Status.EndMessage, Status.Pos);
				DiscordApi.SendMessage(Webhook.Event.EventPaused, text);
			}
		}

		internal void TriggerEventResumed()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.StaticConfig.EventResumedMessageEnabled)
			{
				string text = MessageTransformer.FormatEventMessage(Plugin.StaticConfig.EventResumedMessage, Status.StartMessage, Status.EndMessage);
				if (!Plugin.StaticConfig.EventResumedPosEnabled)
				{
					DiscordApi.SendMessage(Webhook.Event.EventResumed, text);
					return;
				}
				if (Plugin.StaticConfig.DiscordEmbedsEnabled || !text.Contains("%POS%"))
				{
					DiscordApi.SendMessage(Webhook.Event.EventResumed, text, Status.Pos);
					return;
				}
				text = MessageTransformer.FormatEventMessage(Plugin.StaticConfig.EventResumedMessage, Status.StartMessage, Status.EndMessage, Status.Pos);
				DiscordApi.SendMessage(Webhook.Event.EventResumed, text);
			}
		}

		internal void TriggerEventStop()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.StaticConfig.EventStopMessageEnabled)
			{
				string text = MessageTransformer.FormatEventEndMessage(Plugin.StaticConfig.EventStopMessage, PreviousEventStartMessage, PreviousEventEndMessage);
				if (!Plugin.StaticConfig.EventStopPosEnabled)
				{
					DiscordApi.SendMessage(Webhook.Event.EventStop, text);
					return;
				}
				if (Plugin.StaticConfig.DiscordEmbedsEnabled || !text.Contains("%POS%"))
				{
					DiscordApi.SendMessage(Webhook.Event.EventStop, text, PreviousEventPos);
					return;
				}
				text = MessageTransformer.FormatEventEndMessage(Plugin.StaticConfig.EventStopMessage, PreviousEventStartMessage, PreviousEventEndMessage, PreviousEventPos);
				DiscordApi.SendMessage(Webhook.Event.EventStop, text);
			}
		}
	}
	internal static class Handlers
	{
		public static HashSet<string> joinedPlayers = new HashSet<string>();

		public static void Join(ZNetPeer peer)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (peer == null)
			{
				Plugin.StaticLogger.LogDebug("Handler:Join - Guarded against null peer");
				return;
			}
			Webhook.Event ev = Webhook.Event.PlayerJoin;
			string text = peer.m_socket.GetHostName() ?? "";
			if (!joinedPlayers.Add(text))
			{
				Plugin.StaticLogger.LogDebug(text + " already exists in list of joined players.");
				if (((ZDOID)(ref peer.m_characterID)).ID != 0)
				{
					Death(peer);
				}
				return;
			}
			Plugin.StaticLogger.LogDebug($"Added player {text} peer_id:{peer.m_uid} ({peer.m_playerName}) to joined player list.");
			string text2 = "";
			if (Plugin.StaticConfig.AnnouncePlayerFirstJoinEnabled && Plugin.StaticDatabase.CountOfRecordsByName("join", peer.m_playerName) == 0)
			{
				text2 = Plugin.StaticConfig.PlayerFirstJoinMessage;
				ev = Webhook.Event.PlayerFirstJoin;
			}
			else if (Plugin.StaticConfig.PlayerJoinMessageEnabled)
			{
				text2 = Plugin.StaticConfig.JoinMessage;
			}
			if (Plugin.StaticConfig.StatsJoinEnabled)
			{
				Plugin.StaticDatabase.InsertSimpleStatRecord("join", peer.m_playerName, text, peer.m_refPos);
			}
			if (!string.IsNullOrEmpty(text2))
			{
				FinalizeFormattingAndSend(peer, text, text2, Plugin.StaticConfig.PlayerJoinPosEnabled, ev);
			}
		}

		public static void Leave(ZNetPeer peer)
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (peer == null)
			{
				Plugin.StaticLogger.LogDebug("Handler:Leave - Guarded against null peer");
				return;
			}
			Webhook.Event ev = Webhook.Event.PlayerLeave;
			string text = peer.m_socket.GetHostName() ?? "";
			if (!joinedPlayers.Remove(text))
			{
				Plugin.StaticLogger.LogDebug(text + " did not exist in the list of joined players!");
				return;
			}
			Plugin.StaticLogger.LogDebug($"Removed player {text} peer_id:{peer.m_uid} ({peer.m_playerName}) from joined player list.");
			string text2 = "";
			if (Plugin.StaticConfig.AnnouncePlayerFirstLeaveEnabled && Plugin.StaticDatabase.CountOfRecordsByName("leave", peer.m_playerName) == 0)
			{
				text2 = Plugin.StaticConfig.PlayerFirstLeaveMessage;
				ev = Webhook.Event.PlayerFirstLeave;
			}
			else if (Plugin.StaticConfig.PlayerLeaveMessageEnabled)
			{
				text2 = Plugin.StaticConfig.LeaveMessage;
			}
			if (Plugin.StaticConfig.StatsLeaveEnabled)
			{
				Plugin.StaticDatabase.InsertSimpleStatRecord("leave", peer.m_playerName, text, peer.m_refPos);
			}
			if (!string.IsNullOrEmpty(text2))
			{
				FinalizeFormattingAndSend(peer, text, text2, Plugin.StaticConfig.PlayerLeavePosEnabled, ev);
			}
		}

		public static void Death(ZNetPeer peer)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (peer == null)
			{
				Plugin.StaticLogger.LogDebug("Handler:Death - Guarded against null peer");
				return;
			}
			Webhook.Event ev = Webhook.Event.PlayerDeath;
			string playerHostName = peer.m_socket.GetHostName() ?? "";
			string text = "";
			if (Plugin.StaticConfig.AnnouncePlayerFirstDeathEnabled && Plugin.StaticDatabase.CountOfRecordsByName("death", peer.m_playerName) == 0)
			{
				text = Plugin.StaticConfig.PlayerFirstDeathMessage;
				ev = Webhook.Event.PlayerFirstDeath;
			}
			else if (Plugin.StaticConfig.PlayerDeathMessageEnabled)
			{
				text = Plugin.StaticConfig.DeathMessage;
			}
			if (Plugin.StaticConfig.StatsDeathEnabled)
			{
				Plugin.StaticDatabase.InsertSimpleStatRecord("death", peer.m_playerName, playerHostName, peer.m_refPos);
			}
			if (!string.IsNullOrEmpty(text))
			{
				FinalizeFormattingAndSend(peer, playerHostName, text, Plugin.StaticConfig.PlayerDeathPosEnabled, ev);
			}
		}

		public static void Ping(ZNetPeer peer, Vector3 pos)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (peer == null)
			{
				Plugin.StaticLogger.LogDebug("Handler:Ping - Guarded against null peer");
				return;
			}
			Webhook.Event ev = Webhook.Event.PlayerPing;
			string playerHostName = peer.m_socket.GetHostName() ?? "";
			string text = "";
			if (Plugin.StaticConfig.AnnouncePlayerFirstPingEnabled && Plugin.StaticDatabase.CountOfRecordsByName("ping", peer.m_playerName) == 0)
			{
				text = Plugin.StaticConfig.PlayerFirstPingMessage;
				ev = Webhook.Event.PlayerFirstPing;
			}
			else if (Plugin.StaticConfig.ChatPingEnabled)
			{
				text = Plugin.StaticConfig.PingMessage;
			}
			if (Plugin.StaticConfig.StatsPingEnabled)
			{
				Plugin.StaticDatabase.InsertSimpleStatRecord("ping", peer.m_playerName, playerHostName, pos);
			}
			if (!string.IsNullOrEmpty(text))
			{
				FinalizeFormattingAndSend(peer, playerHostName, text, Plugin.StaticConfig.ChatPingPosEnabled, pos, ev);
			}
		}

		public static void Shout(ZNetPeer peer, Vector3 pos, string text)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (peer == null)
			{
				Plugin.StaticLogger.LogDebug("Handler:Shout - Guarded against null peer");
				return;
			}
			Webhook.Event ev = Webhook.Event.PlayerShout;
			string playerHostName = peer.m_socket.GetHostName() ?? "";
			string text2 = "";
			if (Plugin.StaticConfig.AnnouncePlayerFirstShoutEnabled && Plugin.StaticDatabase.CountOfRecordsByName("shout", peer.m_playerName) == 0)
			{
				text2 = Plugin.StaticConfig.PlayerFirstShoutMessage;
				ev = Webhook.Event.PlayerFirstShout;
			}
			else if (Plugin.StaticConfig.ChatShoutEnabled)
			{
				text2 = Plugin.StaticConfig.ShoutMessage;
			}
			if (Plugin.StaticConfig.StatsShoutEnabled)
			{
				Plugin.StaticDatabase.InsertSimpleStatRecord("shout", peer.m_playerName, playerHostName, pos);
			}
			if (!string.IsNullOrEmpty(text2))
			{
				if (Plugin.StaticConfig.ChatShoutAllCaps)
				{
					text = text.ToUpper();
				}
				FinalizeFormattingAndSend(peer, playerHostName, text2, Plugin.StaticConfig.ChatShoutPosEnabled, pos, text, ev);
			}
		}

		private static void FinalizeFormattingAndSend(ZNetPeer peer, string playerHostName, string preFormattedMessage, bool posEnabled, Webhook.Event ev)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			FinalizeFormattingAndSend(peer, playerHostName, preFormattedMessage, posEnabled, peer.m_refPos, ev);
		}

		private static void FinalizeFormattingAndSend(ZNetPeer peer, string playerHostName, string preFormattedMessage, bool posEnabled, Vector3 pos, Webhook.Event ev)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			bool subtractOne = ev == Webhook.Event.PlayerLeave || ev == Webhook.Event.PlayerFirstLeave;
			string text;
			if (preFormattedMessage.Contains("%POS%"))
			{
				if (!posEnabled)
				{
					preFormattedMessage.Replace("%POS%", "");
				}
				text = MessageTransformer.FormatPlayerMessage(preFormattedMessage, peer.m_playerName, playerHostName, pos, subtractOne);
			}
			else
			{
				text = MessageTransformer.FormatPlayerMessage(preFormattedMessage, peer.m_playerName, playerHostName, subtractOne);
			}
			if (posEnabled && (Plugin.StaticConfig.DiscordEmbedsEnabled || !text.Contains("%POS%")))
			{
				DiscordApi.SendMessage(ev, text, pos);
			}
			else
			{
				DiscordApi.SendMessage(ev, text);
			}
		}

		private static void FinalizeFormattingAndSend(ZNetPeer peer, string playerHostName, string preFormattedMessage, bool posEnabled, Vector3 pos, string text, Webhook.Event ev)
		{
			//IL_002b: 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)
			string text2;
			if (preFormattedMessage.Contains("%POS%"))
			{
				if (!posEnabled)
				{
					preFormattedMessage.Replace("%POS%", "");
				}
				text2 = MessageTransformer.FormatPlayerMessage(preFormattedMessage, peer.m_playerName, playerHostName, text, pos);
			}
			else
			{
				text2 = MessageTransformer.FormatPlayerMessage(preFormattedMessage, peer.m_playerName, playerHostName, text);
			}
			if (posEnabled && (Plugin.StaticConfig.DiscordEmbedsEnabled || !text2.Contains("%POS%")))
			{
				DiscordApi.SendMessage(ev, text2, pos);
			}
			else
			{
				DiscordApi.SendMessage(ev, text2);
			}
		}

		internal static void NonPlayerChat(Type type, string user, string text)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (Plugin.StaticConfig.AllowNonPlayerShoutLogging)
			{
				if ((int)type != 2)
				{
					Plugin.StaticLogger.LogDebug("Ignored ping/join/leave from non-player " + user);
					return;
				}
				string playerId = "";
				Plugin.StaticLogger.LogDebug("Sending shout from '" + user + "' to discord: '" + text + "'");
				if (Plugin.StaticConfig.ChatShoutEnabled)
				{
					string playerName = MessageTransformer.CleanCaretFormatting(user);
					string text2 = MessageTransformer.FormatPlayerMessage(Plugin.StaticConfig.ShoutMessage, playerName, playerId, text);
					if (text2.Contains("%POS%"))
					{
						text2.Replace("%POS%", "");
					}
					DiscordApi.SendMessage(Webhook.Event.PlayerShout, text2);
				}
			}
			else
			{
				Plugin.StaticLogger.LogInfo("Ignored shout from " + user + " because they aren't a real player");
			}
		}
	}
	internal class LeaderbBoard
	{
		private Base leaderBoard1;

		private Base leaderBoard2;

		private Base leaderBoard3;

		private Base leaderBoard4;

		private Base leaderBoard5;

		public static readonly int MAX_LEADER_BOARD_SIZE = 16;

		public Base LeaderBoard1 => leaderBoard1;

		public Base LeaderBoard2 => leaderBoard2;

		public Base LeaderBoard3 => leaderBoard3;

		public Base LeaderBoard4 => leaderBoard4;

		public Base LeaderBoard5 => leaderBoard5;

		public LeaderbBoard()
		{
			leaderBoard1 = new Composer(0);
			leaderBoard2 = new Composer(1);
			leaderBoard3 = new Composer(2);
			leaderBoard4 = new Composer(3);
			leaderBoard5 = new Composer(4);
		}

		public static string RankedCountResultToString(List<CountResult> rankings)
		{
			string text = "";
			for (int i = 0; i < rankings.Count; i++)
			{
				text += $"{i + 1}: {rankings[i].Name}: {rankings[i].Count}{Environment.NewLine}";
			}
			return text;
		}

		private static string ToReadableString(TimeSpan span)
		{
			string text = string.Format("{0}{1}{2}{3}", (span.Duration().Days > 0) ? string.Format("{0:0} day{1}, ", span.Days, (span.Days == 1) ? string.Empty : "s") : string.Empty, (span.Duration().Hours > 0) ? string.Format("{0:0} hour{1}, ", span.Hours, (span.Hours == 1) ? string.Empty : "s") : string.Empty, (span.Duration().Minutes > 0) ? string.Format("{0:0} minute{1}, ", span.Minutes, (span.Minutes == 1) ? string.Empty : "s") : string.Empty, (span.Duration().Seconds > 0) ? string.Format("{0:0} second{1}", span.Seconds, (span.Seconds == 1) ? string.Empty : "s") : string.Empty);
			if (text.EndsWith(", "))
			{
				text = text.Substring(0, text.Length - 2);
			}
			if (string.IsNullOrEmpty(text))
			{
				text = "0 seconds";
			}
			return text;
		}

		public static string RankedSecondsToString(List<CountResult> rankings)
		{
			string text = "";
			for (int i = 0; i < rankings.Count; i++)
			{
				string text2 = ToReadableString(TimeSpan.FromSeconds(rankings[i].Count));
				text += $"{i + 1}: {rankings[i].Name}: {text2}{Environment.NewLine}";
			}
			return text;
		}
	}
	internal class VDCLogger
	{
		private static ManualLogSource _logger;

		private static string _logFilePath;

		private bool _logDebugMessages;

		private static readonly string LOG_NAME = "vdc.log";

		public VDCLogger(ManualLogSource logger)
		{
			_logger = logger;
			_logFilePath = Path.Combine(Paths.ConfigPath, "games.nwest.valheim.discordconnector", LOG_NAME);
			InitializeLogFile();
			_logger.LogInfo((object)"Logger initialized.");
		}

		internal void SetLogLevel(bool logDebugMessages)
		{
			_logDebugMessages = logDebugMessages;
		}

		private void InitializeLogFile()
		{
			if (File.Exists(_logFilePath))
			{
				string text = _logFilePath + ".old";
				File.Move(_logFilePath, text);
				_logger.LogInfo((object)("Existing log file moved to " + text));
			}
		}

		private async Task LogToFileAsync(string severity, string message)
		{
			try
			{
				using StreamWriter writer = new StreamWriter(_logFilePath, append: true);
				await writer.WriteLineAsync($"{DateTime.Now} [{severity}]: {message}");
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Error writing to log file: " + ex.Message));
			}
		}

		public async Task LogDebugAsync(string message)
		{
			await LogToFileAsync("DEBUG", message);
			if (_logDebugMessages)
			{
				_logger.LogInfo((object)message);
			}
		}

		public async Task LogInfoAsync(string message)
		{
			await LogToFileAsync("INFO", message);
			_logger.LogInfo((object)message);
		}

		public async Task LogWarningAsync(string message)
		{
			await LogToFileAsync("WARNING", message);
			_logger.LogWarning((object)message);
		}

		public async Task LogErrorAsync(string message)
		{
			await LogToFileAsync("ERROR", message);
			_logger.LogError((object)message);
		}

		public async Task LogFatalAsync(string message)
		{
			await LogToFileAsync("FATAL", message);
			_logger.LogFatal((object)message);
		}

		public void LogDebug(string message)
		{
			LogDebugAsync(message).GetAwaiter().GetResult();
		}

		public void LogInfo(string message)
		{
			LogInfoAsync(message).GetAwaiter().GetResult();
		}

		public void LogWarning(string message)
		{
			LogWarningAsync(message).GetAwaiter().GetResult();
		}

		public void LogError(string message)
		{
			LogErrorAsync(message).GetAwaiter().GetResult();
		}

		public void LogFatal(string message)
		{
			LogFatalAsync(message).GetAwaiter().GetResult();
		}
	}
	internal static class MessageTransformer
	{
		private const string PUBLIC_IP = "%PUBLICIP%";

		private const string VAR = "%VAR1%";

		private const string VAR_1 = "%VAR2%";

		private const string VAR_2 = "%VAR3%";

		private const string VAR_3 = "%VAR4%";

		private const string VAR_4 = "%VAR5%";

		private const string VAR_5 = "%VAR6%";

		private const string VAR_6 = "%VAR7%";

		private const string VAR_7 = "%VAR8%";

		private const string VAR_8 = "%VAR9%";

		private const string VAR_9 = "%VAR10%";

		private const string PLAYER_NAME = "%PLAYER_NAME%";

		private const string PLAYER_STEAMID = "%PLAYER_STEAMID%";

		private const string PLAYER_ID = "%PLAYER_ID%";

		private const string SHOUT = "%SHOUT%";

		private const string POS = "%POS%";

		private const string EVENT_START_MSG = "%EVENT_START_MSG%";

		private const string EVENT_END_MSG = "%EVENT_END_MSG%";

		private const string EVENT_MSG = "%EVENT_MSG%";

		private const string EVENT_PLAYERS = "%PLAYERS%";

		private const string N = "%N%";

		private const string WORLD_NAME = "%WORLD_NAME%";

		private const string DAY_NUMBER = "%DAY_NUMBER%";

		private const string NUM_PLAYERS = "%NUM_PLAYERS%";

		private const string JOIN_CODE = "%JOIN_CODE%";

		private const string TIMESTAMP = "%TIMESTAMP%";

		private const string TIMESINCE = "%TIMESINCE%";

		private const string UNIX_TIMESTAMP = "%UNIX_TIMESTAMP%";

		private static readonly Regex OpenCaretRegex = new Regex("<[\\w=]+>");

		private static readonly Regex CloseCaretRegex = new Regex("</[\\w]+>");

		private static string ReplaceVariables(string rawMessage, bool subtractOne = false)
		{
			return ReplaceDynamicVariables(rawMessage.Replace("%VAR1%", Plugin.StaticConfig.UserVariable).Replace("%VAR2%", Plugin.StaticConfig.UserVariable1).Replace("%VAR3%", Plugin.StaticConfig.UserVariable2)
				.Replace("%VAR4%", Plugin.StaticConfig.UserVariable3)
				.Replace("%VAR5%", Plugin.StaticConfig.UserVariable4)
				.Replace("%VAR6%", Plugin.StaticConfig.UserVariable5)
				.Replace("%VAR7%", Plugin.StaticConfig.UserVariable6)
				.Replace("%VAR8%", Plugin.StaticConfig.UserVariable7)
				.Replace("%VAR9%", Plugin.StaticConfig.UserVariable8)
				.Replace("%VAR10%", Plugin.StaticConfig.UserVariable9), subtractOne);
		}

		private static string ReplaceDynamicVariables(string rawMessage, bool subtractOne = false)
		{
			return ReplaceUnixTimestamp(ReplaceTimesince(ReplaceTimestamp(ReplaceJoinCode(ReplaceNumPlayers(ReplaceDayNumber(ReplaceWorldName(ReplacePublicIp(rawMessage))), subtractOne)))));
		}

		private static string ReplaceTimestamp(string rawMessage)
		{
			return rawMessage.Replace("%TIMESTAMP%", $"<t:{(int)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds}>");
		}

		private static string ReplaceTimesince(string rawMessage)
		{
			return rawMessage.Replace("%TIMESINCE%", $"<t:{(int)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds}:R>");
		}

		private static string ReplaceUnixTimestamp(string rawMessage)
		{
			return rawMessage.Replace("%UNIX_TIMESTAMP%", ((int)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds).ToString());
		}

		private static string ReplaceJoinCode(string rawMessage)
		{
			return rawMessage.Replace("%JOIN_CODE%", ZPlayFabMatchmaking.JoinCode);
		}

		private static string ReplaceDayNumber(string rawMessage)
		{
			return rawMessage.Replace("%DAY_NUMBER%", ((Object)(object)EnvMan.instance != (Object)null) ? EnvMan.instance.GetCurrentDay().ToString() : "%DAY_NUMBER%");
		}

		private static string ReplaceNumPlayers(string rawMessage, bool subtractOne = false)
		{
			if (subtractOne)
			{
				return rawMessage.Replace("%NUM_PLAYERS%", ((Object)(object)ZNet.instance != (Object)null) ? (ZNet.instance.GetNrOfPlayers() - 1).ToString() : "%NUM_PLAYERS%");
			}
			return rawMessage.Replace("%NUM_PLAYERS%", ((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetNrOfPlayers().ToString() : "%NUM_PLAYERS%");
		}

		private static string ReplacePublicIp(string rawMessage)
		{
			return rawMessage.Replace("%PUBLICIP%", Plugin.PublicIpAddress);
		}

		private static string ReplaceWorldName(string rawMessage)
		{
			return rawMessage.Replace("%WORLD_NAME%", ((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetWorldName() : "%WORLD_NAME%");
		}

		public static string FormatServerMessage(string rawMessage)
		{
			return ReplaceVariables(rawMessage);
		}

		public static string FormatPlayerMessage(string rawMessage, string playerName, string playerId, bool subtractOne = false)
		{
			return ReplaceVariables(rawMessage, subtractOne).Replace("%PLAYER_STEAMID%", playerId).Replace("%PLAYER_ID%", playerId).Replace("%PLAYER_NAME%", playerName);
		}

		public static string FormatPlayerMessage(string rawMessage, string playerName, string playerId, Vector3 pos, bool subtractOne = false)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return FormatPlayerMessage(rawMessage, playerName, playerId, subtractOne).Replace("%POS%", $"{pos}");
		}

		public static string FormatPlayerMessage(string rawMessage, string playerName, string playerId, string shout, bool subtractOne = false)
		{
			return FormatPlayerMessage(rawMessage, playerName, playerId, subtractOne).Replace("%SHOUT%", shout);
		}

		public static string FormatPlayerMessage(string rawMessage, string playerName, string playerSteamId, string shout, Vector3 pos, bool subtractOne = false)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return FormatPlayerMessage(rawMessage, playerName, playerSteamId, pos, subtractOne).Replace("%SHOUT%", shout);
		}

		public static string FormatEventMessage(string rawMessage, string eventStartMsg, string eventEndMsg)
		{
			return ReplaceVariables(rawMessage).Replace("%EVENT_START_MSG%", eventStartMsg).Replace("%EVENT_END_MSG%", eventEndMsg);
		}

		public static string FormatEventMessage(string rawMessage, string eventStartMsg, string eventEndMsg, Vector3 pos)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return FormatEventMessage(rawMessage, eventStartMsg, eventEndMsg).Replace("%POS%", $"{pos}");
		}

		public static string FormatEventStartMessage(string rawMessage, string eventStartMsg, string eventEndMsg)
		{
			return FormatEventMessage(rawMessage, eventStartMsg, eventEndMsg).Replace("%EVENT_MSG%", eventStartMsg);
		}

		public static string FormatEventEndMessage(string rawMessage, string eventStartMsg, string eventEndMsg)
		{
			return FormatEventMessage(rawMessage, eventStartMsg, eventEndMsg).Replace("%EVENT_MSG%", eventEndMsg);
		}

		public static string FormatEventStartMessage(string rawMessage, string eventStartMsg, string eventEndMsg, Vector3 pos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return FormatEventMessage(rawMessage, eventStartMsg, eventEndMsg, pos).Replace("%EVENT_MSG%", eventStartMsg);
		}

		public static string FormatEventEndMessage(string rawMessage, string eventStartMsg, string eventEndMsg, Vector3 pos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return FormatEventMessage(rawMessage, eventStartMsg, eventEndMsg, pos).Replace("%EVENT_MSG%", eventEndMsg);
		}

		public static string FormatLeaderBoardHeader(string rawMessage)
		{
			return ReplaceVariables(rawMessage);
		}

		public static string FormatLeaderBoardHeader(string rawMessage, int n)
		{
			return ReplaceVariables(rawMessage).Replace("%N%", n.ToString());
		}

		public static string CleanCaretFormatting(string str)
		{
			string input = OpenCaretRegex.Replace(str, "", 1);
			return CloseCaretRegex.Replace(input, "", 1);
		}

		public static string FormatVector3AsPos(Vector3 vec3)
		{
			return Plugin.StaticConfig.PosVarFormat.Replace("%X%", vec3.x.ToString("F1")).Replace("%Y%", vec3.y.ToString("F1")).Replace("%Z%", vec3.z.ToString("F1"));
		}

		public static string FormatAppendedPos(Vector3 vec3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string newValue = FormatVector3AsPos(vec3);
			return Plugin.StaticConfig.AppendedPosFormat.Replace("%POS%", newValue);
		}
	}
	[BepInPlugin("games.nwest.valheim.discordconnector", "Valheim Discord Connector", "2.3.2")]
	public class Plugin : BaseUnityPlugin
	{
		internal static VDCLogger StaticLogger;

		internal static PluginConfig StaticConfig;

		internal static Database StaticDatabase;

		internal static LeaderbBoard StaticLeaderBoards;

		internal static EventWatcher StaticEventWatcher;

		internal static ConfigWatcher StaticConfigWatcher;

		private static string _publicIpAddress;

		private Harmony _harmony;

		internal static string PublicIpAddress
		{
			get
			{
				if (!string.IsNullOrEmpty(_publicIpAddress))
				{
					return _publicIpAddress;
				}
				_publicIpAddress = PublicIPChecker.GetPublicIP();
				return _publicIpAddress;
			}
		}

		public Plugin()
		{
			StaticLogger = new VDCLogger(((BaseUnityPlugin)this).Logger);
			StaticConfig = new PluginConfig(((BaseUnityPlugin)this).Config);
			StaticDatabase = new Database(Paths.GameRootPath);
			StaticLeaderBoards = new LeaderbBoard();
			StaticConfigWatcher = new ConfigWatcher();
			_publicIpAddress = "";
		}

		private void Awake()
		{
			StaticLogger.LogDebug("Plugin games.nwest.valheim.discordconnector is loaded!");
			if (!IsHeadless())
			{
				StaticLogger.LogInfo("Not running on a dedicated server, some features may break -- please report them!");
			}
			else
			{
				StaticEventWatcher = new EventWatcher();
			}
			if (string.IsNullOrEmpty(StaticConfig.PrimaryWebhook.Url) && string.IsNullOrEmpty(StaticConfig.SecondaryWebhook.Url))
			{
				StaticLogger.LogWarning("No value set for WebHookURL! Plugin will run without using a main Discord webhook.");
			}
			if (StaticConfig.LeaderBoards[0].Enabled)
			{
				Timer timer = new Timer();
				timer.Elapsed += StaticLeaderBoards.LeaderBoard1.SendLeaderBoardOnTimer;
				timer.Interval = 60000 * StaticConfig.LeaderBoards[0].PeriodInMinutes;
				StaticLogger.LogInfo("Enabling LeaderBoard.1 timer with interval " + Strings.HumanReadableMs(timer.Interval));
				timer.Start();
			}
			if (StaticConfig.LeaderBoards[1].Enabled)
			{
				Timer timer2 = new Timer();
				timer2.Elapsed += StaticLeaderBoards.LeaderBoard2.SendLeaderBoardOnTimer;
				timer2.Interval = 60000 * StaticConfig.LeaderBoards[1].PeriodInMinutes;
				StaticLogger.LogInfo("Enabling LeaderBoard.2 timer with interval " + Strings.HumanReadableMs(timer2.Interval));
				timer2.Start();
			}
			if (StaticConfig.LeaderBoards[2].Enabled)
			{
				Timer timer3 = new Timer();
				timer3.Elapsed += StaticLeaderBoards.LeaderBoard3.SendLeaderBoardOnTimer;
				timer3.Interval = 60000 * StaticConfig.LeaderBoards[2].PeriodInMinutes;
				StaticLogger.LogInfo("Enabling LeaderBoard.3 timer with interval " + Strings.HumanReadableMs(timer3.Interval));
				timer3.Start();
			}
			if (StaticConfig.LeaderBoards[3].Enabled)
			{
				Timer timer4 = new Timer();
				timer4.Elapsed += StaticLeaderBoards.LeaderBoard4.SendLeaderBoardOnTimer;
				timer4.Interval = 60000 * StaticConfig.LeaderBoards[3].PeriodInMinutes;
				StaticLogger.LogInfo("Enabling LeaderBoard.4 timer with interval " + Strings.HumanReadableMs(timer4.Interval));
				timer4.Start();
			}
			if (StaticConfig.LeaderBoards[4].Enabled)
			{
				Timer timer5 = new Timer();
				timer5.Elapsed += StaticLeaderBoards.LeaderBoard4.SendLeaderBoardOnTimer;
				timer5.Interval = 60000 * StaticConfig.LeaderBoards[4].PeriodInMinutes;
				StaticLogger.LogInfo("Enabling LeaderBoard.5 timer with interval " + Strings.HumanReadableMs(timer5.Interval));
				timer5.Start();
			}
			if (StaticConfig.ActivePlayersAnnouncement.Enabled)
			{
				Timer timer6 = new Timer();
				timer6.Elapsed += ActivePlayersAnnouncement.SendOnTimer;
				timer6.Interval = 60000 * StaticConfig.ActivePlayersAnnouncement.PeriodInMinutes;
				StaticLogger.LogInfo("Enabling Player Activity announcement with interval " + Strings.HumanReadableMs(timer6.Interval));
				timer6.Start();
			}
			_harmony = Harmony.CreateAndPatchAll(typeof(Plugin).Assembly, "games.nwest.valheim.discordconnector");
		}

		private void OnDestroy()
		{
			_harmony.UnpatchSelf();
			StaticDatabase.Dispose();
		}

		public static bool IsHeadless()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			return (int)SystemInfo.graphicsDeviceType == 4;
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_ID = "games.nwest.valheim.discordconnector";

		public const string PLUGIN_NAME = "Valheim Discord Connector";

		public const string PLUGIN_VERSION = "2.3.2";

		public const string PLUGIN_REPO_SHORT = "github: nwesterhausen/valheim-discordconnector";

		public const string PLUGIN_AUTHOR = "Nicholas Westerhausen";

		public const string SHORT_PLUGIN_ID = "discordconnector";
	}
	internal static class Hashing
	{
		public static string GetMD5Checksum(string filename)
		{
			using MD5 mD = MD5.Create();
			using FileStream inputStream = File.OpenRead(filename);
			return BitConverter.ToString(mD.ComputeHash(inputStream)).Replace("-", "");
		}
	}
	internal static class Strings
	{
		public static string HumanReadableMs(double ms)
		{
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(ms);
			if (timeSpan.Milliseconds == timeSpan.Seconds && timeSpan.Seconds == 0)
			{
				return $"{timeSpan.Hours:D2}h:{timeSpan.Minutes:D2}m";
			}
			return $"{timeSpan.Hours:D2}h:{timeSpan.Minutes:D2}m:{timeSpan.Seconds:D2}s:{timeSpan.Milliseconds:D3}ms";
		}
	}
	internal static class PublicIPChecker
	{
		public static string GetPublicIP()
		{
			Plugin.StaticLogger.LogDebug("Getting public IP address.");
			string text = string.Empty;
			try
			{
				using WebClient webClient = new WebClient();
				text = webClient.DownloadString("https://ifconfig.me/ip");
			}
			catch (Exception ex)
			{
				Plugin.StaticLogger.LogError("Failed to get public IP address, an empty string will be used: " + ex.Message);
			}
			Plugin.StaticLogger.LogDebug("Public IP address is '" + text + "'");
			return text;
		}
	}
	internal static class GuidHelper
	{
		public static string GenerateShortHexGuid(int byteCount = 4)
		{
			if (byteCount <= 0 || byteCount > 16)
			{
				throw new ArgumentException("Byte count must be between 1 and 16.");
			}
			return BitConverter.ToString(Guid.NewGuid().ToByteArray(), 0, byteCount).Replace("-", "").ToLower();
		}
	}
	public class Webhook
	{
		public enum Event
		{
			ServerLaunch,
			ServerStart,
			ServerStop,
			ServerShutdown,
			ServerSave,
			EventStart,
			EventPaused,
			EventResumed,
			EventStop,
			PlayerJoin,
			PlayerLeave,
			PlayerShout,
			PlayerPing,
			PlayerDeath,
			PlayerFirstJoin,
			PlayerFirstLeave,
			PlayerFirstShout,
			PlayerFirstPing,
			PlayerFirstDeath,
			ActivePlayers,
			Leaderboard1,
			Leaderboard2,
			Leaderboard3,
			Leaderboard4,
			Leaderboard5,
			ALL,
			ServerLifecycle,
			EventLifecycle,
			PlayerAll,
			PlayerFirstAll,
			LeaderboardsAll,
			None,
			Other,
			CronJob,
			NewDayNumber
		}

		public static Event StringToEvent(string eventToken)
		{
			switch (eventToken)
			{
			case "ALL":
				return Event.ALL;
			case "serverLifecycle":
				return Event.ServerLifecycle;
			case "eventLifecycle":
				return Event.EventLifecycle;
			case "playerAll":
				return Event.PlayerAll;
			case "playerFirstAll":
				return Event.PlayerFirstAll;
			case "leaderboardsAll":
				return Event.LeaderboardsAll;
			case "serverLaunch":
				return Event.ServerLaunch;
			case "serverStart":
				return Event.ServerStart;
			case "serverStop":
				return Event.ServerStop;
			case "serverShutdown":
				return Event.ServerShutdown;
			case "serverSave":
				return Event.ServerSave;
			case "eventStart":
				return Event.EventStart;
			case "eventPaused":
				return Event.EventPaused;
			case "eventResumed":
				return Event.EventResumed;
			case "eventStop":
				return Event.EventStop;
			case "playerJoin":
				return Event.PlayerJoin;
			case "playerLeave":
				return Event.PlayerLeave;
			case "playerShout":
				return Event.PlayerShout;
			case "playerPing":
				return Event.PlayerPing;
			case "playerDeath":
				return Event.PlayerDeath;
			case "playerFirstJoin":
				return Event.PlayerFirstJoin;
			case "playerFirstLeave":
				return Event.PlayerFirstLeave;
			case "playerFirstShout":
				return Event.PlayerFirstShout;
			case "playerFirstPing":
				return Event.PlayerFirstPing;
			case "playerFirstDeath":
				return Event.PlayerFirstDeath;
			case "activePlayers":
				return Event.ActivePlayers;
			case "leaderboard1":
				return Event.Leaderboard1;
			case "leaderboard2":
				return Event.Leaderboard2;
			case "leaderboard3":
				return Event.Leaderboard3;
			case "leaderboard4":
				return Event.Leaderboard4;
			case "leaderboard5":
				return Event.Leaderboard5;
			case "cronjob":
				return Event.CronJob;
			case "newDayNumber":
				return Event.NewDayNumber;
			default:
				Plugin.StaticLogger.LogDebug("Unmatched event token '" + eventToken + "'");
				return Event.None;
			}
		}

		public static List<Event> StringToEventList(string configEntry)
		{
			if (string.IsNullOrEmpty(configEntry))
			{
				return new List<Event>();
			}
			string text = Regex.Replace(configEntry, "[^;\\w]", "");
			Plugin.StaticLogger.LogDebug("Webhooks: cleaned config entry '" + configEntry + "' => '" + text + "'");
			if (text.Equals("ALL"))
			{
				return new List<Event>(1) { Event.ALL };
			}
			List<Event> list = new List<Event>();
			string[] array = text.Split(new char[1] { ';' });
			foreach (string eventToken in array)
			{
				list.Add(StringToEvent(eventToken));
			}
			Plugin.StaticLogger.LogDebug("Webhooks: parsed config entry '" + configEntry + "' => '" + string.Join(", ", list) + "'");
			return list;
		}
	}
	internal class WebhookEntry
	{
		public string Url { get; set; }

		public List<Webhook.Event> FireOnEvents { get; set; }

		public string UsernameOverride { get; set; } = string.Empty;


		public string AvatarOverride { get; set; } = string.Empty;


		public WebhookEntry(string url)
		{
			Url = url;
			FireOnEvents = new List<Webhook.Event>(1) { Webhook.Event.ALL };
		}

		public WebhookEntry(string url, List<Webhook.Event> fireOnEvents, string usernameOverride = "", string avatarOverride = "")
		{
			if (string.IsNullOrEmpty(url))
			{
				Plugin.StaticLogger.LogDebug("Coerced null or empty webhook url to empty string. Ignoring event list.");
				Url = "";
				FireOnEvents = new List<Webhook.Event>();
				return;
			}
			Url = url;
			if (fireOnEvents == null || fireOnEvents.Count == 0)
			{
				Plugin.StaticLogger.LogDebug("Coerced null or empty webhook event list to empty list.");
				FireOnEvents = new List<Webhook.Event>();
			}
			else
			{
				FireOnEvents = fireOnEvents;
			}
			if (!string.IsNullOrEmpty(usernameOverride))
			{
				UsernameOverride = usernameOverride;
			}
			if (!string.IsNullOrEmpty(avatarOverride))
			{
				AvatarOverride = avatarOverride;
			}
		}

		public bool HasUsernameOverride()
		{
			return !string.IsNullOrEmpty(UsernameOverride);
		}

		public bool HasAvatarOverride()
		{
			return !string.IsNullOrEmpty(AvatarOverride);
		}

		internal bool HasEvent(Webhook.Event ev)
		{
			if (FireOnEvents.Count == 0)
			{
				return false;
			}
			if (FireOnEvents.Contains(Webhook.Event.ALL))
			{
				Plugin.StaticLogger.LogDebug("Webhook has 'ALL' enabled");
				return true;
			}
			if (FireOnEvents.Contains(Webhook.Event.PlayerAll))
			{
				Plugin.StaticLogger.LogDebug($"Checking if {ev} is part of PlayerAll");
				if (ev == Webhook.Event.PlayerDeath || ev == Webhook.Event.PlayerJoin || ev == Webhook.Event.PlayerLeave || ev == Webhook.Event.PlayerPing || ev == Webhook.Event.PlayerShout)
				{
					return true;
				}
			}
			if (FireOnEvents.Contains(Webhook.Event.PlayerFirstAll))
			{
				Plugin.StaticLogger.LogDebug($"Checking if {ev} is part of PlayerFirstAll");
				if (ev == Webhook.Event.PlayerFirstDeath || ev == Webhook.Event.PlayerFirstJoin || ev == Webhook.Event.PlayerFirstLeave || ev == Webhook.Event.PlayerFirstPing || ev == Webhook.Event.PlayerFirstShout)
				{
					return true;
				}
			}
			if (FireOnEvents.Contains(Webhook.Event.EventLifecycle))
			{
				Plugin.StaticLogger.LogDebug($"Checking if {ev} is part of EventLifecycle");
				if (ev == Webhook.Event.EventStart || ev == Webhook.Event.EventStop || ev == Webhook.Event.EventResumed || ev == Webhook.Event.EventPaused)
				{
					return true;
				}
			}
			if (FireOnEvents.Contains(Webhook.Event.ServerLifecycle))
			{
				Plugin.StaticLogger.LogDebug($"Checking if {ev} is part of ServerLifecycle");
				if (ev == Webhook.Event.ServerLaunch || ev == Webhook.Event.ServerShutdown || ev == Webhook.Event.ServerStart || ev == Webhook.Event.ServerStop || ev == Webhook.Event.NewDayNumber)
				{
					return true;
				}
			}
			if (FireOnEvents.Contains(Webhook.Event.LeaderboardsAll))
			{
				Plugin.StaticLogger.LogDebug($"Checking if {ev} is part of LeaderboardsAll");
				if (ev == Webhook.Event.ActivePlayers || ev == Webhook.Event.Leaderboard1 || ev == Webhook.Event.Leaderboard2 || ev == Webhook.Event.Leaderboard3 || ev == Webhook.Event.Leaderboard4 || ev == Webhook.Event.Leaderboard5)
				{
					return true;
				}
			}
			Plugin.StaticLogger.LogDebug($"Checking for exact match of {ev}");
			return FireOnEvents.Contains(ev);
		}
	}
}
namespace DiscordConnector.Records
{
	public class CountResult
	{
		public string Name { get; }

		public int Count { get; }

		[BsonCtor]
		public CountResult(string name, int count)
		{
			Name = name;
			Count = count;
		}

		public static int CompareByCount(CountResult cr1, CountResult cr2)
		{
			return cr1.Count.CompareTo(cr2.Count);
		}

		public static int CompareByName(CountResult cr1, CountResult cr2)
		{
			return cr1.Name.CompareTo(cr2.Name);
		}

		public static List<CountResult> ConvertFromBsonDocuments(List<BsonDocument> bsonDocuments)
		{
			List<CountResult> list = new List<CountResult>();
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"ConvertBsonDocumentCountToDotNet r={bsonDocuments.Count}");
			}
			foreach (BsonDocument bsonDocument in bsonDocuments)
			{
				if (bsonDocument.ContainsKey("Count"))
				{
					if (bsonDocument.ContainsKey("Name"))
					{
						list.Add(new CountResult(((BsonValue)bsonDocument)["Name"].AsString, ((BsonValue)bsonDocument)["Count"].AsInt32));
					}
					else if (bsonDocument.ContainsKey("NamePlayer"))
					{
						list.Add(new CountResult(((BsonValue)bsonDocument)["NamePlayer"]["Name"].AsString, ((BsonValue)bsonDocument)["Count"].AsInt32));
					}
					else if (bsonDocument.ContainsKey("Player") && !((BsonValue)bsonDocument)["Player"].IsNull)
					{
						list.Add(new CountResult(Plugin.StaticDatabase.GetLatestCharacterNameForPlayer(BsonValue.op_Implicit(((BsonValue)bsonDocument)["Player"])), ((BsonValue)bsonDocument)["Count"].AsInt32));
					}
				}
			}
			return list;
		}

		public override string ToString()
		{
			return $"{Name}: {Count}";
		}
	}
	public class PlayerToName
	{
		public ObjectId _id { get; }

		public string CharacterName { get; }

		public string PlayerId { get; }

		public DateTime InsertedDate { get; }

		public PlayerToName(string characterName, string playerHostName)
			: this(ObjectId.NewObjectId(), characterName, playerHostName, DateTime.Now)
		{
		}

		[BsonCtor]
		public PlayerToName(ObjectId id, string characterName, string playerId, DateTime insertedDate)
		{
			_id = id;
			CharacterName = characterName;
			PlayerId = playerId;
			InsertedDate = insertedDate;
		}

		public override string ToString()
		{
			return CharacterName + " (" + PlayerId + ")";
		}
	}
	public class Position
	{
		public float x { get; }

		public float y { get; }

		public float z { get; }

		public Position()
		{
			x = 0f;
			y = 0f;
			z = 0f;
		}

		public Position(float _x, float _y, float _z)
		{
			x = _x;
			y = _y;
			z = _z;
		}

		public override string ToString()
		{
			return $"({x},{y},{z})";
		}
	}
	public class SimpleStat
	{
		public ObjectId StatId { get; }

		public string Name { get; }

		public DateTime Date { get; }

		public string PlayerId { get; }

		public Position Pos { get; }

		public SimpleStat(string name, string playerId, float x, float y, float z)
			: this(ObjectId.NewObjectId(), name, DateTime.Now, playerId, new Position(x, y, z))
		{
		}

		[BsonCtor]
		public SimpleStat(ObjectId id, ObjectId statId, string name, DateTime date, string playerId, BsonDocument pos)
			: this(statId, name, date, playerId, BsonMapper.Global.Deserialize<Position>((BsonValue)(object)pos))
		{
		}

		public SimpleStat(ObjectId statId, string name, DateTime date, string playerId, Position pos)
		{
			StatId = statId;
			Name = name;
			Date = date;
			PlayerId = playerId;
			Pos = pos;
		}

		public override string ToString()
		{
			return $"{Date.ToShortDateString()} {Date.ToShortTimeString()}: {Name} ({PlayerId}) at {Pos}";
		}
	}
	internal class Database
	{
		private struct JoinLeaveTime
		{
			public DateTime Time;

			public bool IsJoin;
		}

		private const string DB_NAME = "records.db";

		private static string DbPath;

		private LiteDatabase db;

		private ILiteCollection<SimpleStat> DeathCollection;

		private ILiteCollection<SimpleStat> JoinCollection;

		private ILiteCollection<SimpleStat> LeaveCollection;

		private ILiteCollection<SimpleStat> ShoutCollection;

		private ILiteCollection<SimpleStat> PingCollection;

		private ILiteCollection<PlayerToName> PlayerToNameCollection;

		public Database(string rootStorePath)
		{
			DbPath = Path.Combine(Paths.ConfigPath, "games.nwest.valheim.discordconnector", "records.db");
			string text = Path.Combine(Paths.ConfigPath, "games.nwest.valheim.discordconnector-records.db");
			if (File.Exists(text))
			{
				File.Move(text, DbPath);
			}
			Initialize();
		}

		public void Initialize()
		{
			Task.Run(delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				try
				{
					db = new LiteDatabase(DbPath, (BsonMapper)null);
					Plugin.StaticLogger.LogDebug("LiteDB Connection Established to " + DbPath);
					DeathCollection = db.GetCollection<SimpleStat>("deaths", (BsonAutoId)10);
					JoinCollection = db.GetCollection<SimpleStat>("joins", (BsonAutoId)10);
					LeaveCollection = db.GetCollection<SimpleStat>("leaves", (BsonAutoId)10);
					ShoutCollection = db.GetCollection<SimpleStat>("shouts", (BsonAutoId)10);
					PingCollection = db.GetCollection<SimpleStat>("pings", (BsonAutoId)10);
					PlayerToNameCollection = db.GetCollection<PlayerToName>("player_name", (BsonAutoId)10);
					Task.Run(delegate
					{
						EnsureIndicesOnCollections();
						Plugin.StaticLogger.LogDebug("Created indices on database collections");
					}).ConfigureAwait(continueOnCapturedContext: false);
				}
				catch (IOException ex)
				{
					Plugin.StaticLogger.LogError("Unable to acquire un-shared access to " + DbPath);
					Plugin.StaticLogger.LogDebug(ex.ToString());
				}
			}).ConfigureAwait(continueOnCapturedContext: false);
		}

		private void EnsureIndicesOnCollections()
		{
			DeathCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.PlayerId), false);
			DeathCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.Name), false);
			JoinCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.PlayerId), false);
			JoinCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.Name), false);
			LeaveCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.PlayerId), false);
			LeaveCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.Name), false);
			ShoutCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.PlayerId), false);
			ShoutCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.Name), false);
			PingCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.PlayerId), false);
			PingCollection.EnsureIndex<string>((Expression<Func<SimpleStat, string>>)((SimpleStat x) => x.Name), false);
			PlayerToNameCollection.EnsureIndex<string>((Expression<Func<PlayerToName, string>>)((PlayerToName x) => x.PlayerId), false);
			PlayerToNameCollection.EnsureIndex<string>((Expression<Func<PlayerToName, string>>)((PlayerToName x) => x.CharacterName), false);
		}

		public void Dispose()
		{
			Plugin.StaticLogger.LogDebug("Closing LiteDB connection");
			db.Dispose();
		}

		private void InsertSimpleStatRecord(ILiteCollection<SimpleStat> collection, string playerName, string playerHostName, Vector3 pos)
		{
			//IL_0014: 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)
			Task.Run(delegate
			{
				SimpleStat simpleStat = new SimpleStat(playerName, playerHostName, pos.x, pos.y, pos.z);
				collection.Insert(simpleStat);
			}).ConfigureAwait(continueOnCapturedContext: false);
		}

		private void EnsurePlayerNameRecorded(string characterName, string playerHostName)
		{
			Task.Run(delegate
			{
				if (!PlayerToNameCollection.Exists((Expression<Func<PlayerToName, bool>>)((PlayerToName x) => x.PlayerId.Equals(playerHostName) && x.CharacterName.Equals(characterName))))
				{
					if (PlayerToNameCollection.Exists((Expression<Func<PlayerToName, bool>>)((PlayerToName x) => x.PlayerId.Equals(playerHostName))))
					{
						Plugin.StaticLogger.LogDebug("Multiple characters from " + playerHostName + ", latest is " + characterName);
					}
					PlayerToName playerToName = new PlayerToName(characterName, playerHostName);
					PlayerToNameCollection.Insert(playerToName);
				}
			}).ConfigureAwait(continueOnCapturedContext: false);
		}

		private void InsertSimpleStatRecord(ILiteCollection<SimpleStat> collection, string playerName, string playerHostName)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			InsertSimpleStatRecord(collection, playerName, playerHostName, Vector3.zero);
		}

		public void InsertSimpleStatRecord(string key, string playerName, string playerHostName, Vector3 pos)
		{
			//IL_004c: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			switch (key)
			{
			case "death":
				InsertSimpleStatRecord(DeathCollection, playerName, playerHostName, pos);
				break;
			case "join":
				EnsurePlayerNameRecorded(playerName, playerHostName);
				InsertSimpleStatRecord(JoinCollection, playerName, playerHostName, pos);
				break;
			case "leave":
				InsertSimpleStatRecord(LeaveCollection, playerName, playerHostName, pos);
				break;
			case "ping":
				InsertSimpleStatRecord(PingCollection, playerName, playerHostName, pos);
				break;
			case "shout":
				InsertSimpleStatRecord(ShoutCollection, playerName, playerHostName, pos);
				break;
			default:
				Plugin.StaticLogger.LogDebug("InsertSimpleStatRecord, invalid key '" + key + "'");
				break;
			}
		}

		public void InsertSimpleStatRecord(string key, string playerName, string playerHostName)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			InsertSimpleStatRecord(key, playerName, playerHostName, Vector3.zero);
		}

		internal string GetLatestCharacterNameForPlayer(string playerHostName)
		{
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug("GetLatestNameForCharacterId " + playerHostName + " begin");
			}
			if (PlayerToNameCollection.Exists((Expression<Func<PlayerToName, bool>>)((PlayerToName x) => x.PlayerId.Equals(playerHostName))))
			{
				try
				{
					return ((ILiteQueryableResult<PlayerToName>)(object)PlayerToNameCollection.Query().Where((Expression<Func<PlayerToName, bool>>)((PlayerToName x) => x.PlayerId.Equals(playerHostName))).OrderByDescending<DateTime>((Expression<Func<PlayerToName, DateTime>>)((PlayerToName x) => x.InsertedDate))).First().CharacterName;
				}
				catch (InvalidOperationException)
				{
					Plugin.StaticLogger.LogWarning("Should have found " + playerHostName + " in player_name table but did not!");
				}
			}
			List<BsonDocument> list = JoinCollection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId.Equals(playerHostName))).OrderByDescending(BsonExpression.op_Implicit("Date"))
				.Select(BsonExpression.op_Implicit("$.Name"))
				.ToList();
			if (list.Count == 0)
			{
				if (Plugin.StaticConfig.DebugDatabaseMethods)
				{
					Plugin.StaticLogger.LogDebug("GetLatestNameForCharacterId " + playerHostName + " result = NONE");
				}
				return "undefined";
			}
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"nameQuery has {list.Count} results");
			}
			BsonDocument result = list[0];
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"GetLatestNameForCharacterId {playerHostName} result = {result}");
			}
			Task.Run(delegate
			{
				EnsurePlayerNameRecorded(BsonValue.op_Implicit(((BsonValue)result)["Name"]), playerHostName);
			}).ConfigureAwait(continueOnCapturedContext: false);
			return ((BsonValue)result)["Name"].AsString;
		}

		public List<CountResult> CountAllRecordsGrouped(string key)
		{
			switch (key)
			{
			case "death":
				return CountAllRecordsGrouped(DeathCollection);
			case "join":
				return CountAllRecordsGrouped(JoinCollection);
			case "leave":
				return CountAllRecordsGrouped(LeaveCollection);
			case "ping":
				return CountAllRecordsGrouped(PingCollection);
			case "shout":
				return CountAllRecordsGrouped(ShoutCollection);
			case "time_online":
				return TimeOnlineRecordsGrouped();
			default:
				Plugin.StaticLogger.LogDebug("CountAllRecordsGrouped, invalid key '" + key + "'");
				return new List<CountResult>();
			}
		}

		private List<CountResult> TimeOnlineRecordsGrouped(DateTime? startDate = null, DateTime? endDate = null, bool inclusiveStart = true, bool inclusiveEnd = true)
		{
			PlayerToName[] array = ((ILiteQueryableResult<PlayerToName>)(object)PlayerToNameCollection.Query()).ToArray();
			List<CountResult> list = new List<CountResult>();
			PlayerToName[] array2 = array;
			foreach (PlayerToName player in array2)
			{
				TimeSpan timeSpan = TimeSpan.FromSeconds(0.0);
				ILiteQueryable<SimpleStat> val = JoinCollection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId.Equals(player.PlayerId) && x.Name.Equals(player.CharacterName)));
				ILiteQueryable<SimpleStat> val2 = LeaveCollection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId.Equals(player.PlayerId) && x.Name.Equals(player.CharacterName)));
				Func<int, bool> startCompare = (inclusiveStart ? ((Func<int, bool>)((int x) => x >= 0)) : ((Func<int, bool>)((int x) => x > 0)));
				Func<int, bool> endCompare = (inclusiveEnd ? ((Func<int, bool>)((int x) => x <= 0)) : ((Func<int, bool>)((int x) => x < 0)));
				if (startDate.HasValue)
				{
					val = val.Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => startCompare(x.Date.CompareTo(((DateTime?)startDate).GetValueOrDefault()))));
				}
				if (endDate.HasValue)
				{
					val = val.Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => endCompare(x.Date.CompareTo(((DateTime?)endDate).GetValueOrDefault()))));
				}
				JoinLeaveTime[] array3 = Array.ConvertAll(((ILiteQueryableResult<SimpleStat>)(object)val).ToArray(), delegate(SimpleStat stat)
				{
					JoinLeaveTime result2 = default(JoinLeaveTime);
					result2.Time = stat.Date;
					result2.IsJoin = true;
					return result2;
				});
				JoinLeaveTime[] array4 = Array.ConvertAll(((ILiteQueryableResult<SimpleStat>)(object)val2).ToArray(), delegate(SimpleStat stat)
				{
					JoinLeaveTime result = default(JoinLeaveTime);
					result.Time = stat.Date;
					result.IsJoin = false;
					return result;
				});
				JoinLeaveTime[] array5 = (from j in array3.Concat(array4)
					orderby j.Time
					select j).ToArray();
				Plugin.StaticLogger.LogDebug($"{player.PlayerId} as {player.CharacterName} has {array3.Length} joins, {array4.Length} leaves");
				DateTime? dateTime = null;
				JoinLeaveTime[] array6 = array5;
				for (int k = 0; k < array6.Length; k++)
				{
					JoinLeaveTime joinLeaveTime = array6[k];
					if (!dateTime.HasValue)
					{
						if (joinLeaveTime.IsJoin)
						{
							dateTime = joinLeaveTime.Time;
						}
						else
						{
							Plugin.StaticLogger.LogDebug($"Player {player.CharacterName} left at {joinLeaveTime.Time} but was not joined.");
						}
					}
					else if (joinLeaveTime.IsJoin)
					{
						Plugin.StaticLogger.LogDebug($"Player {player.CharacterName} joined at {joinLeaveTime.Time} but was already joined at {dateTime}");
						dateTime = joinLeaveTime.Time;
					}
					else
					{
						TimeSpan timeSpan2 = timeSpan;
						DateTime time = joinLeaveTime.Time;
						timeSpan = timeSpan2 + time.Subtract(dateTime ?? joinLeaveTime.Time);
						dateTime = null;
					}
				}
				Plugin.StaticLogger.LogDebug($"{timeSpan} total online time.");
				list.Add(new CountResult(player.CharacterName, (int)timeSpan.TotalSeconds));
			}
			return list;
		}

		public int CountOfRecordsByName(string key, string playerName)
		{
			if (!Plugin.StaticConfig.CollectStatsEnabled)
			{
				return -1;
			}
			switch (key)
			{
			case "death":
				return CountOfRecordsByName(DeathCollection, playerName);
			case "join":
				return CountOfRecordsByName(JoinCollection, playerName);
			case "leave":
				return CountOfRecordsByName(LeaveCollection, playerName);
			case "ping":
				return CountOfRecordsByName(PingCollection, playerName);
			case "shout":
				return CountOfRecordsByName(ShoutCollection, playerName);
			default:
				Plugin.StaticLogger.LogDebug("CountOfRecordsBySteamId, invalid key '" + key + "'");
				return -2;
			}
		}

		public List<CountResult> CountAllRecordsGrouped(string key, TimeRange timeRange)
		{
			if (timeRange == TimeRange.AllTime)
			{
				return CountAllRecordsGrouped(key);
			}
			Tuple<DateTime, DateTime> tuple = DateHelper.StartEndDatesForTimeRange(timeRange);
			return CountRecordsBetweenDatesGrouped(key, tuple.Item1, tuple.Item2);
		}

		internal List<CountResult> CountRecordsBetweenDatesGrouped(string key, DateTime startDate, DateTime endDate, bool inclusiveStart = true, bool inclusiveEnd = true)
		{
			switch (key)
			{
			case "death":
				return CountAllRecordsGroupsWhereDate(DeathCollection, startDate, endDate, inclusiveStart, inclusiveEnd);
			case "join":
				return CountAllRecordsGroupsWhereDate(JoinCollection, startDate, endDate, inclusiveStart, inclusiveEnd);
			case "leave":
				return CountAllRecordsGroupsWhereDate(LeaveCollection, startDate, endDate, inclusiveStart, inclusiveEnd);
			case "ping":
				return CountAllRecordsGroupsWhereDate(PingCollection, startDate, endDate, inclusiveStart, inclusiveEnd);
			case "shout":
				return CountAllRecordsGroupsWhereDate(ShoutCollection, startDate, endDate, inclusiveStart, inclusiveEnd);
			case "time_online":
				return TimeOnlineRecordsGrouped(startDate, endDate, inclusiveStart, inclusiveEnd);
			default:
				Plugin.StaticLogger.LogDebug("CountTodaysRecordsGrouped, invalid key '" + key + "'");
				return new List<CountResult>();
			}
		}

		internal int CountOfRecordsByName(ILiteCollection<SimpleStat> collection, string playerName)
		{
			try
			{
				return ((ILiteQueryableResult<SimpleStat>)(object)collection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.Name.Equals(playerName)))).Count();
			}
			catch
			{
				Plugin.StaticLogger.LogDebug("Error when trying to find " + playerName + " to count!");
				return -3;
			}
		}

		internal List<CountResult> CountAllRecordsGrouped(ILiteCollection<SimpleStat> collection)
		{
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"CountAllRecordsGrouped {Plugin.StaticConfig.RecordRetrievalDiscernmentMethod}");
			}
			if (collection.Count() == 0)
			{
				if (Plugin.StaticConfig.DebugDatabaseMethods)
				{
					Plugin.StaticLogger.LogDebug("Collection is empty, skipping.");
				}
				return new List<CountResult>();
			}
			string text = "PlayerId";
			string text2 = "{Player: @Key, Count: Count(*)}";
			if (Plugin.StaticConfig.RecordRetrievalDiscernmentMethod == MainConfig.RetrievalDiscernmentMethods.NameAndPlayerId)
			{
				text = "{Name,PlayerId}";
				text2 = "{NamePlayer: @Key, Count: COUNT(*)}";
			}
			if (Plugin.StaticConfig.RecordRetrievalDiscernmentMethod == MainConfig.RetrievalDiscernmentMethods.Name)
			{
				text = "Name";
				text2 = "{Name: @Key, Count: Count(*)}";
			}
			List<CountResult> list = CountResult.ConvertFromBsonDocuments(collection.Query().GroupBy(BsonExpression.op_Implicit(text)).Select(BsonExpression.op_Implicit(text2))
				.ToList());
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"CountAllRecordsGrouped {list.Count} records returned");
			}
			return list;
		}

		internal List<CountResult> CountAllRecordsGroupsWhereDate(ILiteCollection<SimpleStat> collection, DateTime startDate, DateTime endDate, bool inclusiveStart = true, bool inclusiveEnd = true)
		{
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"CountAllRecordsGroupsWhereDate {Plugin.StaticConfig.RecordRetrievalDiscernmentMethod} {startDate} {endDate}");
			}
			if (collection.Count() == 0)
			{
				if (Plugin.StaticConfig.DebugDatabaseMethods)
				{
					Plugin.StaticLogger.LogDebug("Collection is empty, skipping.");
				}
				return new List<CountResult>();
			}
			string text = "PlayerId";
			string text2 = "{Player: @Key, Count: Count(*)}";
			if (Plugin.StaticConfig.RecordRetrievalDiscernmentMethod == MainConfig.RetrievalDiscernmentMethods.NameAndPlayerId)
			{
				text = "{Name,PlayerId}";
				text2 = "{NamePlayer: @Key, Count: COUNT(*)}";
			}
			if (Plugin.StaticConfig.RecordRetrievalDiscernmentMethod == MainConfig.RetrievalDiscernmentMethods.Name)
			{
				text = "Name";
				text2 = "{Name: @Key, Count: Count(*)}";
			}
			List<CountResult> list = ((inclusiveStart && inclusiveEnd) ? CountResult.ConvertFromBsonDocuments(collection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.Date.Year >= ((DateTime)startDate).Date.Year && x.Date.Month >= ((DateTime)startDate).Date.Month && x.Date.Day >= ((DateTime)startDate).Date.Day && x.Date.Year <= ((DateTime)endDate).Date.Year && x.Date.Month <= ((DateTime)endDate).Date.Month && x.Date.Day <= ((DateTime)endDate).Date.Day)).GroupBy(BsonExpression.op_Implicit(text))
				.Select(BsonExpression.op_Implicit(text2))
				.ToList()) : (inclusiveEnd ? CountResult.ConvertFromBsonDocuments(collection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.Date.Year > ((DateTime)startDate).Date.Year && x.Date.Month > ((DateTime)startDate).Date.Month && x.Date.Day > ((DateTime)startDate).Date.Day && x.Date.Year <= ((DateTime)endDate).Date.Year && x.Date.Month <= ((DateTime)endDate).Date.Month && x.Date.Day <= ((DateTime)endDate).Date.Day)).GroupBy(BsonExpression.op_Implicit(text))
				.Select(BsonExpression.op_Implicit(text2))
				.ToList()) : ((!inclusiveStart) ? CountResult.ConvertFromBsonDocuments(collection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.Date.Year > ((DateTime)startDate).Date.Year && x.Date.Month > ((DateTime)startDate).Date.Month && x.Date.Day > ((DateTime)startDate).Date.Day && x.Date.Year < ((DateTime)endDate).Date.Year && x.Date.Month < ((DateTime)endDate).Date.Month && x.Date.Day < ((DateTime)endDate).Date.Day)).GroupBy(BsonExpression.op_Implicit(text))
				.Select(BsonExpres