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.1.17.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;

		public readonly string configPath;

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

		internal static string[] ConfigExtensions = new string[5] { "messages", "variables", "leaderBoard", "toggles", "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 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 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 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 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;

		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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: 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 text = "discordconnector-" + LeaderBoardConfig.ConfigExtension + ".cfg";
			string text2 = Path.Combine(configPath, path);
			string text3 = Path.Combine(configPath, path2);
			string text4 = Path.Combine(configPath, path3);
			string text5 = Path.Combine(configPath, path4);
			string text6 = Path.Combine(configPath, text);
			Plugin.StaticLogger.LogDebug("Main config: " + text2);
			Plugin.StaticLogger.LogDebug("Messages config: " + text3);
			Plugin.StaticLogger.LogDebug("Toggles config: " + text4);
			Plugin.StaticLogger.LogDebug("Variable config: " + text5);
			Plugin.StaticLogger.LogDebug("Leader board config: " + text);
			mainConfig = new MainConfig(new ConfigFile(text2, true));
			messagesConfig = new MessagesConfig(new ConfigFile(text3, true));
			togglesConfig = new TogglesConfig(new ConfigFile(text4, true));
			variableConfig = new VariableConfig(new ConfigFile(text5, true));
			leaderBoardConfig = new LeaderBoardConfig(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();
		}

		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;
			}
		}

		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 += "}";
			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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.StaticConfig.DiscordEmbedsEnabled)
			{
				SendMessageWithFields(ev, message, new List<Tuple<string, string>> { Tuple.Create("Coordinates", MessageTransformer.FormatVector3AsPos(pos)) });
			}
			else
			{
				SendMessage(ev, message + " " + MessageTransformer.FormatAppendedPos(pos));
			}
		}

		public static void SendMessage(Webhook.Event ev, string message)
		{
			DiscordSimpleWebhook discordSimpleWebhook = new DiscordSimpleWebhook
			{
				content = message
			};
			try
			{
				string serializedJson = JsonConvert.SerializeObject((object)discordSimpleWebhook);
				SendSerializedJson(ev, serializedJson);
			}
			catch (Exception arg)
			{
				Plugin.StaticLogger.LogWarning($"Error serializing payload: {arg}");
			}
		}

		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!";
			}
			string text = "{";
			if (fields != null)
			{
				List<string> list = new List<string>();
				foreach (Tuple<string, string> field in fields)
				{
					try
					{
						list.Add(JsonConvert.SerializeObject((object)new DiscordField
						{
							name = field.Item1,
							value = field.Item2
						}));
					}
					catch (Exception arg)
					{
						Plugin.StaticLogger.LogWarning($"Error serializing field: {arg}");
					}
				}
				if (list.Count > 0)
				{
					text += "\"embeds\":[{\"fields\":[";
					text += string.Join(",", list.ToArray());
					text += "]}]";
					if (content != null)
					{
						text += ",";
					}
				}
			}
			if (content != null)
			{
				text = text + "\"content\":\"" + content + "\"";
			}
			text += "}";
			SendSerializedJson(ev, text);
		}

		private static void SendSerializedJson(Webhook.Event ev, string serializedJson)
		{
			Plugin.StaticLogger.LogDebug($"Trying webhook with payload: {serializedJson} (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))
			{
				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);
				}
			}
		}

		private static void DispatchRequest(WebhookEntry webhook, byte[] byteArray)
		{
			if (string.IsNullOrEmpty(webhook.Url))
			{
				Plugin.StaticLogger.LogDebug("Dispatch attempted with empty webhook - ignoring");
				return;
			}
			WebRequest request = WebRequest.Create(webhook.Url);
			request.Method = "POST";
			request.ContentType = "application/json";
			request.ContentLength = byteArray.Length;
			Task.Run(delegate
			{
				Stream requestStream = request.GetRequestStream();
				requestStream.Write(byteArray, 0, byteArray.Length);
				requestStream.Close();
				WebResponse response = request.GetResponse();
				if (Plugin.StaticConfig.DebugHttpRequestResponse)
				{
					Plugin.StaticLogger.LogDebug("Request Response Short Code: " + ((HttpWebResponse)response).StatusDescription);
				}
				using (requestStream = response.GetResponseStream())
				{
					string text = new StreamReader(requestStream).ReadToEnd();
					if (Plugin.StaticConfig.DebugHttpRequestResponse)
					{
						Plugin.StaticLogger.LogDebug("Full response: " + text);
					}
				}
				response.Close();
			}).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 DiscordSimpleWebhook
	{
		public string content { get; set; }
	}
	internal class DiscordComplexWebhook
	{
		public DiscordEmbed embeds { get; set; }
	}
	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; }
	}
	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)
			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, 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			string text;
			if (preFormattedMessage.Contains("%POS%"))
			{
				if (!posEnabled)
				{
					preFormattedMessage.Replace("%POS%", "");
				}
				text = MessageTransformer.FormatPlayerMessage(preFormattedMessage, peer.m_playerName, playerHostName, pos);
			}
			else
			{
				text = MessageTransformer.FormatPlayerMessage(preFormattedMessage, peer.m_playerName, playerHostName);
			}
			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_0064: 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 LeaderBoard
	{
		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 LeaderBoard()
		{
			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;
		}
	}
	internal class VDCLogger
	{
		private static ManualLogSource _logger;

		private bool _logDebugMessages;

		public VDCLogger(ManualLogSource logger)
		{
			_logger = logger;
			_logger.LogInfo((object)"Logger initialized.");
		}

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

		public void LogDebug(string message)
		{
			_logger.LogDebug((object)message);
			if (_logDebugMessages)
			{
				_logger.LogInfo((object)message);
			}
		}

		public void LogInfo(string message)
		{
			_logger.LogInfo((object)message);
		}

		public void LogWarning(string message)
		{
			_logger.LogWarning((object)message);
		}

		public void LogError(string message)
		{
			_logger.LogError((object)message);
		}

		public void LogFatal(string message)
		{
			_logger.LogFatal((object)message);
		}
	}
	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 static Regex OpenCaretRegex = new Regex("<[\\w=]+>");

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

		private static string ReplaceVariables(string rawMessage)
		{
			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)
				.Replace("%PUBLICIP%", Plugin.PublicIpAddress);
		}

		private static string ReplaceDynamicVariables(string rawMessage)
		{
			string newValue = "";
			try
			{
				newValue = ZNet.instance.GetWorldName();
			}
			catch (Exception ex)
			{
				Plugin.StaticLogger.LogDebug("Unable to get World Name from ZNet. " + ex.Message);
			}
			return rawMessage.Replace("%WORLD_NAME%", newValue);
		}

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

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

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

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

		public static string FormatPlayerMessage(string rawMessage, string playerName, string playerSteamId, string shout, Vector3 pos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return FormatPlayerMessage(rawMessage, playerName, playerSteamId, pos).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.1.17")]
	public class Plugin : BaseUnityPlugin
	{
		internal static VDCLogger StaticLogger;

		internal static PluginConfig StaticConfig;

		internal static Database StaticDatabase;

		internal static LeaderBoard 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 = ZNet.GetPublicIP();
				return _publicIpAddress;
			}
		}

		public Plugin()
		{
			StaticLogger = new VDCLogger(((BaseUnityPlugin)this).Logger);
			StaticConfig = new PluginConfig(((BaseUnityPlugin)this).Config);
			StaticDatabase = new Database(Paths.GameRootPath);
			StaticLeaderBoards = new LeaderBoard();
			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.1.17";

		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";
		}
	}
	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
		}

		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;
			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> { Event.ALL };
			}
			List<Event> list = new List<Event>();
			string[] array = text.Split(new char[1] { ';' });
			foreach (string eventToken in array)
			{
				list.Add(StringToEvent(eventToken));
			}
			foreach (Event item in list)
			{
				Plugin.StaticLogger.LogDebug($"Added {item} to list");
			}
			return list;
		}
	}
	internal class WebhookEntry
	{
		public string Url { get; set; }

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

		public WebhookEntry(string url, List<Webhook.Event> fireOnEvents)
		{
			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;
			}
		}

		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)
				{
					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)
		{
			_id = ObjectId.NewObjectId();
			CharacterName = characterName;
			PlayerId = playerHostName;
			InsertedDate = DateTime.Now;
		}

		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 playerHostName)
		{
			StatId = ObjectId.NewObjectId();
			Name = name;
			PlayerId = playerHostName;
			Date = DateTime.Now;
			Pos = new Position();
		}

		public SimpleStat(string name, string playerHostName, float x, float y, float z)
		{
			StatId = ObjectId.NewObjectId();
			Name = name;
			PlayerId = playerHostName;
			Date = DateTime.Now;
			Pos = new Position(x, y, z);
		}

		[BsonCtor]
		public SimpleStat(ObjectId _id, string name, DateTime date, string playerHostName, Position pos)
		{
			StatId = _id;
			Name = name;
			Date = date;
			PlayerId = playerHostName;
			Pos = pos;
		}

		public override string ToString()
		{
			return $"{Date.ToShortDateString()} {Date.ToShortTimeString()}: {Name} ({PlayerId}) at {Pos}";
		}
	}
	internal class Database
	{
		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 AllTimeOnlineRecordsGrouped();
			default:
				Plugin.StaticLogger.LogDebug("CountAllRecordsGrouped, invalid key '" + key + "'");
				return new List<CountResult>();
			}
		}

		private List<CountResult> AllTimeOnlineRecordsGrouped()
		{
			PlayerToName[] array = ((ILiteQueryableResult<PlayerToName>)(object)PlayerToNameCollection.Query()).ToArray();
			List<CountResult> list = new List<CountResult>();
			PlayerToName[] array2 = array;
			foreach (PlayerToName player in array2)
			{
				Tuple.Create(player.PlayerId, player.CharacterName);
				TimeSpan timeSpan = TimeSpan.FromSeconds(0.0);
				SimpleStat[] array3 = ((ILiteQueryableResult<SimpleStat>)(object)JoinCollection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
				SimpleStat[] array4 = ((ILiteQueryableResult<SimpleStat>)(object)LeaveCollection.Query().Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
				Plugin.StaticLogger.LogDebug($"{player.PlayerId} as {player.CharacterName} has {array3.Length} joins, {array4.Length}");
				int num = array3.Length - array4.Length;
				if (num > 1)
				{
					Plugin.StaticLogger.LogDebug($"{num} more joins than leaves, timeOnline likely to be very inaccurate");
				}
				int num2 = array3.Length - num;
				for (int j = 0; j < num2; j++)
				{
					DateTime date = array3[j].Date;
					TimeSpan ts = array4[j].Date.Subtract(date);
					timeSpan.Add(ts);
				}
				Plugin.StaticLogger.LogDebug(timeSpan.ToString() + " total online time.");
				list.Add(new CountResult(player.CharacterName, (int)timeSpan.TotalSeconds));
			}
			return list;
		}

		private List<CountResult> TimeOnlineRecordsWhereDate(DateTime startDate, DateTime endDate, 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)
			{
				Tuple.Create(player.PlayerId, player.CharacterName);
				TimeSpan timeSpan = TimeSpan.FromSeconds(0.0);
				SimpleStat[] array3;
				SimpleStat[] array4;
				if (inclusiveStart && inclusiveEnd)
				{
					array3 = ((ILiteQueryableResult<SimpleStat>)(object)JoinCollection.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)).Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
					array4 = ((ILiteQueryableResult<SimpleStat>)(object)LeaveCollection.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)).Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
				}
				else if (inclusiveEnd)
				{
					array3 = ((ILiteQueryableResult<SimpleStat>)(object)JoinCollection.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)).Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
					array4 = ((ILiteQueryableResult<SimpleStat>)(object)LeaveCollection.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)).Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
				}
				else if (inclusiveStart)
				{
					array3 = ((ILiteQueryableResult<SimpleStat>)(object)JoinCollection.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)).Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
					array4 = ((ILiteQueryableResult<SimpleStat>)(object)LeaveCollection.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)).Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
				}
				else
				{
					array3 = ((ILiteQueryableResult<SimpleStat>)(object)JoinCollection.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)).Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
					array4 = ((ILiteQueryableResult<SimpleStat>)(object)LeaveCollection.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)).Where((Expression<Func<SimpleStat, bool>>)((SimpleStat x) => x.PlayerId == player.PlayerId && x.Name == player.CharacterName))).ToArray();
				}
				Plugin.StaticLogger.LogDebug($"{player.PlayerId} as {player.CharacterName} has {array3.Length} joins, {array4.Length}");
				int num = array3.Length - array4.Length;
				if (num > 1)
				{
					Plugin.StaticLogger.LogDebug($"{num} more joins than leaves, timeOnline likely to be very inaccurate");
				}
				int num2 = array3.Length - num;
				for (int j = 0; j < num2; j++)
				{
					DateTime date = array3[j].Date;
					TimeSpan ts = array4[j].Date.Subtract(date);
					timeSpan.Add(ts);
				}
				Plugin.StaticLogger.LogDebug(timeSpan.ToString() + " 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 TimeOnlineRecordsWhereDate(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(BsonExpression.op_Implicit(text2))
				.ToList()) : 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()))));
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"CountAllRecordsGroupsWhereDate {list.Count} records returned");
			}
			return list;
		}
	}
	public static class Categories
	{
		public const string Death = "death";

		public const string Join = "join";

		public const string Leave = "leave";

		public const string Ping = "ping";

		public const string Shout = "shout";

		public const string TimeOnline = "time_online";

		public static readonly string[] All = new string[6] { "death", "join", "leave", "ping", "shout", "time_online" };
	}
	public static class Helper
	{
		public static List<CountResult> TopNResultForCategory(string key, int n)
		{
			return TopNResultForCategory(key, n, DateHelper.DummyDateTime, DateHelper.DummyDateTime);
		}

		public static List<CountResult> TopNResultForCategory(string key, int n, DateTime startDate, DateTime endDate)
		{
			if (Array.IndexOf(Categories.All, key) == -1)
			{
				Plugin.StaticLogger.LogWarning($"Invalid key \"{key}\" when getting top {n} results.");
				Plugin.StaticLogger.LogDebug("Empty list returned because of invalid key.");
				return new List<CountResult>();
			}
			List<CountResult> list = ((!(startDate != DateHelper.DummyDateTime) || !(endDate != DateHelper.DummyDateTime)) ? Plugin.StaticDatabase.CountAllRecordsGrouped(key) : Plugin.StaticDatabase.CountRecordsBetweenDatesGrouped(key, startDate, endDate));
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"TopNResultForCategory {key} n={n}, results={list.Count}");
			}
			if (list.Count == 0)
			{
				return list;
			}
			list.Sort(CountResult.CompareByCount);
			list.Reverse();
			if (list.Count <= n)
			{
				return list;
			}
			return list.GetRange(0, n);
		}

		public static List<CountResult> BottomNResultForCategory(string key, int n)
		{
			return BottomNResultForCategory(key, n, DateHelper.DummyDateTime, DateHelper.DummyDateTime);
		}

		public static List<CountResult> BottomNResultForCategory(string key, int n, DateTime startDate, DateTime endDate)
		{
			if (Array.IndexOf(Categories.All, key) == -1)
			{
				Plugin.StaticLogger.LogWarning($"Invalid key \"{key}\" when getting bottom {n} results.");
				Plugin.StaticLogger.LogDebug("Empty list returned because of invalid key.");
				return new List<CountResult>();
			}
			List<CountResult> list = ((!(startDate != DateHelper.DummyDateTime) || !(endDate != DateHelper.DummyDateTime)) ? Plugin.StaticDatabase.CountAllRecordsGrouped(key) : Plugin.StaticDatabase.CountRecordsBetweenDatesGrouped(key, startDate, endDate));
			if (Plugin.StaticConfig.DebugDatabaseMethods)
			{
				Plugin.StaticLogger.LogDebug($"BottomNResultForCategory {key} n={n}, results={list.Count}");
			}
			if (list.Count == 0)
			{
				return list;
			}
			list.Sort(CountResult.CompareByCount);
			if (list.Count <= n)
			{
				return list;
			}
			return list.GetRange(0, n);
		}

		internal static int CountUniquePlayers(string key, TimeRange timeRange)
		{
			if (Array.IndexOf(Categories.All, key) == -1)
			{
				Plugin.StaticLogger.LogWarning("Invalid key \"" + key + "\" when getting total unique players.");
				Plugin.StaticLogger.LogDebug("Zero returned because of invalid key.");
				return 0;
			}
			if (timeRange == TimeRange.AllTime)
			{
				return Plugin.StaticDatabase.CountAllRecordsGrouped(key).Count;
			}
			Tuple<DateTime, DateTime> tuple = DateHelper.StartEndDatesForTimeRange(timeRange);
			return CountUniquePlayers(key, tuple.Item1, tuple.Item2);
		}

		internal static int CountUniquePlayers(string key, DateTime startDate, DateTime endDate)
		{
			if (Array.IndexOf(Categories.All, key) == -1)
			{
				Plugin.StaticLogger.LogWarning("Invalid key \"" + key + "\" when getting total unique players.");
				Plugin.StaticLogger.LogDebug("Zero returned because of invalid key.");
				return 0;
			}
			return Plugin.StaticDatabase.CountRecordsBetweenDatesGrouped(key, startDate, endDate).Count;
		}
	}
}
namespace DiscordConnector.Patches
{
	internal class ChatPatches
	{
		[HarmonyPatch(typeof(Chat), "OnNewChatMessage")]
		internal class OnNewChatMessage
		{
			private static void Prefix(ref GameObject go, ref long senderID, ref Vector3 pos, ref Type type, ref UserInfo user, ref string text, ref string senderNetworkUserId)
			{
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Invalid comparison between Unknown and I4
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Invalid comparison between Unknown and I4
				//IL_014e: 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_0123: Unknown result type (might be due to invalid IL or missing references)
				Plugin.StaticLogger.LogDebug("User details: name:" + user.Name + " gamerTag:" + user.Gamertag + " networkUserId:" + user.NetworkUserId + " DisplayName():" + user.GetDisplayName(user.NetworkUserId));
				string name = user.Name;
				if (string.IsNullOrEmpty(name))
				{
					Plugin.StaticLogger.LogInfo("Ignored shout from invalid user (null reference)");
					return;
				}
				if (Plugin.StaticConfig.MutedPlayers.IndexOf(name) >= 0 || Plugin.StaticConfig.MutedPlayersRegex.IsMatch(name))
				{
					Plugin.StaticLogger.LogInfo("Ignored shout from user on muted list. User: " + name + " Shout: " + text + ".");
					return;
				}
				ZNetPeer peerByPlayerName = ZNet.instance.GetPeerByPlayerName(name);
				if (peerByPlayerName == null || peerByPlayerName.m_socket == null)
				{
					Handlers.NonPlayerChat(type, name, text);
					return;
				}
				peerByPlayerName.m_socket.GetHostName();
				Type val = type;
				if ((int)val != 2)
				{
					if ((int)val == 3)
					{
						Handlers.Ping(peerByPlayerName, pos);
						return;
					}
					Plugin.StaticLogger.LogDebug($"Unmatched chat message. [{type}] {name}: {text} at {pos}");
				}
				else if (text.Equals("I have arrived!"))
				{
					if (!Plugin.IsHeadless())
					{
						Handlers.Join(peerByPlayerName);
					}
				}
				else
				{
					Handlers.Shout(peerByPlayerName, pos, text);
				}
			}
		}

		private const string ArrivalShout = "I have arrived!";
	}
	internal class RandEventPatches
	{
		[HarmonyPatch(typeof(RandomEvent), "OnActivate")]
		internal class OnActivate
		{
			private static void Prefix(ref RandomEvent __instance)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: 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)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_022f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: Unknown result type (might be due to invalid IL or missing references)
				//IL_0263: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				bool active = __instance.m_active;
				float duration = __instance.m_duration;
				string name = __instance.m_name;
				float time = __instance.m_time;
				Vector3 pos = __instance.m_pos;
				Plugin.StaticLogger.LogDebug($"Random event OnActivate {name}: {active} for {duration} at {pos}. (time: {time})");
				List<string> list = new List<string>();
				foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
				{
					if (RandEventSystem.instance.IsInsideRandomEventArea(__instance, player.m_position))
					{
						list.Add(player.m_name);
					}
				}
				Plugin.StaticLogger.LogDebug("Involved players in event: " + string.Join(",", list.ToArray()));
				if (__instance.m_time > 0f)
				{
					if (Plugin.StaticConfig.EventResumedMessageEnabled)
					{
						string text = MessageTransformer.FormatEventMessage(Plugin.StaticConfig.EventResumedMessage, Localization.instance.Localize(__instance.m_endMessage), Localization.instance.Localize(__instance.m_startMessage));
						if (!Plugin.StaticConfig.EventResumedPosEnabled)
						{
							DiscordApi.SendMessage(Webhook.Event.EventResumed, text);
							return;
						}
						if (Plugin.StaticConfig.DiscordEmbedsEnabled || !text.Contains("%POS%"))
						{
							DiscordApi.SendMessage(Webhook.Event.EventResumed, text, pos);
							return;
						}
						text = MessageTransformer.FormatEventMessage(Plugin.StaticConfig.EventResumedMessage, Localization.instance.Localize(__instance.m_endMessage), Localization.instance.Localize(__instance.m_startMessage), pos);
						DiscordApi.SendMessage(Webhook.Event.EventResumed, text);
					}
				}
				else if (Plugin.StaticConfig.EventStartMessageEnabled)
				{
					string text2 = MessageTransformer.FormatEventStartMessage(Plugin.StaticConfig.EventResumedMessage, Localization.instance.Localize(__instance.m_endMessage), Localization.instance.Localize(__instance.m_startMessage));
					if (!Plugin.StaticConfig.EventStartPosEnabled)
					{
						DiscordApi.SendMessage(Webhook.Event.EventStart, text2);
						return;
					}
					if (Plugin.StaticConfig.DiscordEmbedsEnabled || !text2.Contains("%POS%"))
					{
						DiscordApi.SendMessage(Webhook.Event.EventStart, text2, pos);
						return;
					}
					text2 = MessageTransformer.FormatEventStartMessage(Plugin.StaticConfig.EventResumedMessage, Localization.instance.Localize(__instance.m_endMessage), Localization.instance.Localize(__instance.m_startMessage), pos);
					DiscordApi.SendMessage(Webhook.Event.EventStart, text2);
				}
			}
		}

		[HarmonyPatch(typeof(RandomEvent), "OnDeactivate")]
		internal class OnDeactivate
		{
			private static void Prefix(ref RandomEvent __instance, ref bool end)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_00