using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using OdinEye.Coroutines;
using OdinEye.Events;
using OdinEye.Extensions;
using OdinEye.Http;
using OdinEye.Http.Api.Controllers;
using OdinEye.Http.WebSockets;
using OdinEye.Logging;
using OdinEye.Middlewares;
using OdinEye.Models;
using OdinEye.Models.Api;
using OdinEye.Models.Proto;
using ProtoBuf;
using UnityEngine;
using Utf8Json;
using WebSocketSharp.Net;
using WebSocketSharp.Server;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("OdinEye")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OdinEye")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: InternalsVisibleTo("OdinEye.Tests")]
[assembly: Guid("6BC0320E-49F2-4A19-BE85-E909D6852C1C")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace OdinEye
{
	[BepInPlugin("org.bepinex.plugins.odineye", "odineye", "1.0.0.0")]
	public class OdinEyePlugin : BaseUnityPlugin
	{
		private ConfigEntry<string> httpServerAddress;

		public static OdinEyePlugin Instance { get; private set; }

		public ILogger Logger { get; private set; }

		public OdinEye.Events.EventHandler EventHandler { get; private set; }

		public EventFeed EventFeed { get; private set; }

		public HttpWebServer HttpWebServer { get; private set; }

		public GameStatsSnapshotCoroutine StatsSnapshotCoroutine { get; private set; }

		private void Awake()
		{
			Instance = this;
			Logger = new Logger(((BaseUnityPlugin)this).Logger);
			Logger.LogInfo("OdinEye starting!");
			LoadConfiguration();
			try
			{
				HttpWebServer = new HttpWebServer(httpServerAddress.Value, Logger);
			}
			catch (Exception arg)
			{
				Logger.LogError($"Failed to start OdinEye's Http/WebSocket server at '{httpServerAddress.Value}': {arg}. " + "Check the [Hosting] HttpServerAddress setting in the org.bepinex.plugins.odineye.cfg config file. OdinEye's REST API and WebSocket event stream will be unavailable until this is fixed.");
				return;
			}
			try
			{
				SetupEventPipeline();
			}
			catch (Exception arg2)
			{
				Logger.LogError($"Failed to initialize OdinEye's event pipeline: {arg2}. " + "OdinEye's WebSocket event stream will be unavailable until this is fixed.");
				return;
			}
			try
			{
				SetupHarmonyPatches();
			}
			catch (Exception arg3)
			{
				Logger.LogError($"Failed to apply OdinEye's Harmony patches: {arg3}. " + "In-game event hooks (chat, world/player events, etc.) will not fire, but the REST API and WebSocket server remain available.");
				return;
			}
			Logger.LogInfo("OdinEye running!");
		}

		private void LoadConfiguration()
		{
			httpServerAddress = ((BaseUnityPlugin)this).Config.Bind<string>("Hosting", "HttpServerAddress", "http://localhost:2469/", "The network address where the Http Server will be hosted");
		}

		private void SetupHarmonyPatches()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			new Harmony("org.bepinex.plugins.odineye").PatchAll(executingAssembly);
		}

		private void SetupEventPipeline()
		{
			StatsSnapshotCoroutine = new GameStatsSnapshotCoroutine(HttpWebServer);
			EventHandler = new OdinEye.Events.EventHandler();
			EventFeed = new EventFeed();
			EventHandler.Configure(delegate(EventHandlerConfigurationOptions options)
			{
				options.AddMiddleware(new ExceptionHandlerMiddleware(Logger)).AddMiddleware(new LoggingMiddleware(Logger)).AddMiddleware(new EventFeedMiddleware(EventFeed))
					.AddMiddleware(new EventDispatcherMiddleware(HttpWebServer));
			});
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "OdinEye";

		public const string PLUGIN_NAME = "";

		public const string PLUGIN_VERSION = "1.0.0.0";
	}
}
namespace OdinEye.Patches
{
	[HarmonyPatch(typeof(Character))]
	public class CharacterDeathPatch
	{
		private static readonly FieldInfo NViewField = AccessTools.Field(typeof(Character), "m_nview");

		private static readonly int? AttackersVarId = typeof(Character).Assembly.GetType("ZDOVars")?.GetField("s_attackers", BindingFlags.Static | BindingFlags.Public)?.GetValue(null) as int?;

		[HarmonyPatch("OnDeath")]
		[HarmonyPrefix]
		protected static void OnDeath(Character __instance)
		{
			if (__instance.IsPlayer() || !AttackersVarId.HasValue)
			{
				return;
			}
			object? value = NViewField.GetValue(__instance);
			ZNetView val = (ZNetView)((value is ZNetView) ? value : null);
			if (val != null && val.IsOwner())
			{
				ZDO zdo = val.GetZDO();
				string attackerKeyPrefix = AttackersVarId.Value.ToString();
				List<string> list = (from p in ZNet.instance.GetPlayerList()
					where zdo.GetBool(attackerKeyPrefix + p.m_name, false)
					select p.m_name).ToList();
				if (list.Count != 0)
				{
					string text = string.Join(", ", list) + " killed " + __instance.m_name + " " + $"(level {__instance.GetLevel()}, boss: {__instance.IsBoss()})";
					Dictionary<string, object> dictionary = EnemyKillDetails.Build(__instance.m_name, __instance.GetLevel(), __instance.IsBoss(), list);
					OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)300, text, (Player)null, (IDictionary<string, object>)dictionary));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Chat))]
	public class ChatPatch
	{
		[HarmonyPatch("OnNewChatMessage")]
		[HarmonyPrefix]
		protected static void OnNewChatMessage(GameObject go, long senderID, Vector3 pos, Type type, UserInfo sender, string text)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			string text2 = "user " + sender.Name + " said: " + text;
			switch ((int)type)
			{
			case 0:
				OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)5, "CHAT WHISPER " + text2, (Player)null));
				break;
			case 1:
				OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)5, "CHAT NORMAL " + text2, (Player)null));
				break;
			case 2:
				OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)5, "CHAT SHOUT " + text2, (Player)null));
				break;
			case 3:
				OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)5, "PING " + text2, (Player)null));
				break;
			default:
				OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)5, $"Unknown chat type {type}", (Player)null));
				break;
			}
		}
	}
	[HarmonyPatch(typeof(EnvMan))]
	public class EnvManPatch
	{
		[HarmonyPatch("UpdateTriggers")]
		[HarmonyPrefix]
		protected static void UpdateTriggers(float oldDayFraction, float newDayFraction, Biome biome, float dt)
		{
			if (ZNet.instance.m_peers.Count != 0)
			{
				if ((double)oldDayFraction > 0.20000000298023224 && (double)oldDayFraction < 0.25 && (double)newDayFraction > 0.25 && (double)newDayFraction < 0.30000001192092896)
				{
					int currentDay = EnvMan.instance.GetCurrentDay();
					OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)200, $"MORNING STARTED, day: {currentDay}", (Player)null));
				}
				if (!((double)oldDayFraction <= 0.699999988079071) && !((double)oldDayFraction >= 0.75) && !((double)newDayFraction <= 0.75) && !((double)newDayFraction >= 0.800000011920929))
				{
					OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)201, "EVENING STARTED", (Player)null));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Game))]
	public class GamePatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		protected static void Awake()
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)50, "Game.Awake (server launch?)", (Player)null));
		}

		[HarmonyPatch("OnApplicationQuit")]
		[HarmonyPrefix]
		protected static void OnApplicationQuit()
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)51, "Game.OnApplicationQuit (server stop?)", (Player)null));
		}

		[HarmonyPatch("SleepStart")]
		[HarmonyPrefix]
		protected static void SleepStart(long sender)
		{
			string text = string.Join(", ", ZNet.instance.m_peers.Select((ZNetPeer p) => p.m_playerName));
			string text2 = "Players " + text + " went to sleep";
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)6, text2, (Player)null));
		}

		[HarmonyPatch("SleepStop")]
		[HarmonyPrefix]
		protected static void SleepStop(long sender)
		{
			string text = string.Join(", ", ZNet.instance.m_peers.Select((ZNetPeer p) => p.m_playerName));
			string text2 = "Players " + text + " woke up";
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)7, text2, (Player)null));
		}
	}
	[HarmonyPatch(typeof(RandomEvent))]
	public class RandomEventPatch
	{
		[HarmonyPatch("OnActivate")]
		[HarmonyPrefix]
		protected static void OnActivate(RandomEvent __instance)
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)100, $"RandomEvent.OnActivate: {__instance.m_name} active for {__instance.m_duration}", (Player)null));
		}

		[HarmonyPatch("OnDeactivate")]
		[HarmonyPrefix]
		protected static void OnDeactivate(RandomEvent __instance)
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)101, $"RandomEvent.OnDeactivate: {__instance.m_name} was active for {__instance.m_duration}", (Player)null));
		}
	}
	[HarmonyPatch(typeof(RandEventSystem))]
	public class RandomEventSystemPatch
	{
		[HarmonyPatch("SetRandomEvent")]
		[HarmonyPostfix]
		protected static void OnSetRandomEvent(RandomEvent ev, Vector3 pos)
		{
			if (ev != null)
			{
				OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)102, "SetRandomEvent: " + ev.m_name + " - " + ev.m_startMessage, (Player)null));
			}
		}
	}
	[HarmonyPatch(typeof(Talker))]
	public class TalkerPatch
	{
		[HarmonyPatch("RPC_Say")]
		[HarmonyPrefix]
		protected static void Say(long sender, int ctype, UserInfo user, string text)
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)5, "Talker.Say: " + user.Name + " - " + text, (Player)null));
		}
	}
	[HarmonyPatch(typeof(ZNet))]
	public class ZNetPatch
	{
		private static HashSet<ZDOID> deadPlayers = new HashSet<ZDOID>();

		[HarmonyPatch("RPC_PeerInfo")]
		[HarmonyPostfix]
		protected static void RPC_PeerInfo(ZNet __instance, ZRpc rpc, ZPackage pkg)
		{
			ZNetPeer peer = __instance.GetPeer(rpc);
			if (__instance.m_zdoMan.m_peers.Any((ZDOPeer zdoPeer) => zdoPeer.m_peer == peer))
			{
				OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)1, "Player has joined: " + peer.m_playerName, peer.ToPlayer()));
			}
		}

		[HarmonyPatch("RPC_CharacterID")]
		[HarmonyPostfix]
		protected static void OnRPCCharId(ZNet __instance, ZRpc rpc)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ZNetPeer peer = __instance.GetPeer(rpc);
			if (peer.m_characterID != ZDOID.None)
			{
				OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)2, "Player has spawned: " + peer.m_playerName, peer.ToPlayer()));
			}
		}

		[HarmonyPatch("RPC_Disconnect")]
		[HarmonyPrefix]
		protected static void Disco(ZNet __instance, ZRpc rpc)
		{
			ZNetPeer peer = __instance.GetPeer(rpc);
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)4, "Player disconnected: " + peer.m_playerName, peer.ToPlayer()));
		}

		[HarmonyPatch("LoadWorld")]
		[HarmonyPostfix]
		protected static void OnLoadWorld(ZNet __instance)
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)53, "World loaded!", (Player)null));
			((MonoBehaviour)__instance).StartCoroutine(OdinEyePlugin.Instance.StatsSnapshotCoroutine.SendGameStatsSnapshotCoroutine());
		}

		[HarmonyPatch("SaveWorld")]
		[HarmonyPostfix]
		protected static void SaveWorld()
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)54, "World was saved!", (Player)null));
		}

		[HarmonyPatch("Shutdown")]
		[HarmonyPrefix]
		protected static void OnShutdown()
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)55, "Shutdown triggered!", (Player)null));
		}

		[HarmonyPatch("SendPeriodicData")]
		[HarmonyPrefix]
		protected static void SendPeriodicData(ZNet __instance)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			foreach (ZNetPeer peer in __instance.m_peers)
			{
				if (!peer.IsReady() || ((ZDOID)(ref peer.m_characterID)).IsNone())
				{
					continue;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
				if (zDO == null)
				{
					break;
				}
				if (zDO.GetBool(ZDOVars.s_dead, false))
				{
					if (deadPlayers.Add(zDO.m_uid))
					{
						OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)3, "Player died: " + peer.m_playerName, (Player)null));
					}
				}
				else
				{
					deadPlayers.Remove(zDO.m_uid);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem))]
	public class ZoneSystemPatch
	{
		[HarmonyPatch("RPC_SetGlobalKey")]
		[HarmonyPrefix]
		protected static void RPC_SetGlobalKey(string name)
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)56, "GlobalKey added: " + name, (Player)null));
		}

		[HarmonyPatch("RPC_RemoveGlobalKey")]
		[HarmonyPrefix]
		protected static void RPC_RemoveGlobalKey(string name)
		{
			OdinEyePlugin.Instance.EventHandler.Handle(GameEvent.New((EventType)57, "GlobalKey removed: " + name, (Player)null));
		}
	}
}
namespace OdinEye.Models
{
	public class Peer
	{
		public string CharacterId { get; set; }

		public string SteamId { get; set; }

		public string Name { get; set; }

		public float Health { get; set; }

		public float MaxHealth { get; set; }

		public float Stamina { get; set; }
	}
}
namespace OdinEye.Middlewares
{
	public class EventDispatcherMiddleware : EventMiddleware
	{
		private readonly HttpWebServer httpWebServer;

		public EventDispatcherMiddleware(HttpWebServer httpWebServer)
		{
			this.httpWebServer = httpWebServer;
		}

		protected override void Invoke(GameEvent gameEvent, MiddlewareDelegate next)
		{
			httpWebServer.BroadcastWebSocketMessage<GameEvent>(gameEvent);
		}
	}
	public class EventFeedMiddleware : EventMiddleware
	{
		private readonly EventFeed feed;

		public EventFeedMiddleware(EventFeed feed)
		{
			this.feed = feed;
		}

		protected override void Invoke(GameEvent gameEvent, MiddlewareDelegate next)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (EventFeed.ShouldRecord(gameEvent.Type))
			{
				feed.Append(gameEvent);
			}
			next(gameEvent);
		}
	}
	public class ExceptionHandlerMiddleware : EventMiddleware
	{
		private readonly ILogger logger;

		public ExceptionHandlerMiddleware(ILogger logger)
		{
			this.logger = logger;
		}

		protected override void Invoke(GameEvent gameEvent, MiddlewareDelegate next)
		{
			try
			{
				next(gameEvent);
			}
			catch (Exception ex)
			{
				logger.LogError("Error while handling game event: " + ex.Message);
			}
		}
	}
	public interface IEventMiddleware
	{
		IEventMiddleware SetNext(EventMiddleware handler);

		void Handle(GameEvent gameEvent);
	}
	public delegate void MiddlewareDelegate(GameEvent gameEvent);
	public abstract class EventMiddleware : IEventMiddleware
	{
		private MiddlewareDelegate next;

		public IEventMiddleware SetNext(EventMiddleware handler)
		{
			next = handler.InvokeWithNextDelegate;
			return handler;
		}

		public void Handle(GameEvent gameEvent)
		{
			Invoke(gameEvent, next);
		}

		protected abstract void Invoke(GameEvent gameEvent, MiddlewareDelegate next);

		private void InvokeWithNextDelegate(GameEvent gameEvent)
		{
			Invoke(gameEvent, next ?? ((MiddlewareDelegate)delegate
			{
			}));
		}
	}
	public class LoggingMiddleware : EventMiddleware
	{
		private readonly ILogger logger;

		public LoggingMiddleware(ILogger logger)
		{
			this.logger = logger;
		}

		protected override void Invoke(GameEvent gameEvent, MiddlewareDelegate next)
		{
			logger.LogInfo("Handling game event: " + gameEvent.Message);
			next(gameEvent);
		}
	}
}
namespace OdinEye.Logging
{
	public interface ILogger
	{
		void LogFatal(object data);

		void LogError(object data);

		void LogWarning(object data);

		void LogMessage(object data);

		void LogInfo(object data);

		void LogDebug(object data);
	}
	public class Logger : ILogger
	{
		private readonly ManualLogSource manualLogSource;

		public Logger(ManualLogSource manualLogSource)
		{
			this.manualLogSource = manualLogSource;
		}

		public void LogFatal(object data)
		{
			manualLogSource.Log((LogLevel)1, data);
		}

		public void LogError(object data)
		{
			manualLogSource.Log((LogLevel)2, data);
		}

		public void LogWarning(object data)
		{
			manualLogSource.Log((LogLevel)4, data);
		}

		public void LogMessage(object data)
		{
			manualLogSource.Log((LogLevel)8, data);
		}

		public void LogInfo(object data)
		{
			manualLogSource.Log((LogLevel)16, data);
		}

		public void LogDebug(object data)
		{
			manualLogSource.Log((LogLevel)32, data);
		}
	}
}
namespace OdinEye.Http
{
	public class HttpWebServer
	{
		private const string DefaultWebSocketPath = "/activity";

		private readonly HttpServer httpServer;

		private readonly ILogger logger;

		private WebSocketSessionManager defaultWebSocketSessionManager;

		private IEnumerable<object> controllers = new object[11]
		{
			new PlayersController(),
			new ServerDetailsController(),
			new WorldDetailsController(),
			new BossDetailsController(),
			new WorldModifiersController(),
			new CharacterStatsController(),
			new CheatStatusController(),
			new PlayerNotifyController(),
			new EventsController(),
			new PlayersMetaController(),
			new PlayerEventsController()
		};

		public HttpWebServer(string address, ILogger logger)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			this.logger = logger;
			logger.LogInfo("Starting Http Server at " + address);
			httpServer = new HttpServer(address);
			ConfigureHttpApi();
			ConfigureWebSocketServices();
			httpServer.Start();
		}

		private void ConfigureHttpApi()
		{
			httpServer.OnGet += delegate(object sender, HttpRequestEventArgs args)
			{
				foreach (object controller2 in controllers)
				{
					if (controller2 is IController controller && string.Equals(controller.Route, RoutePath(args.Request.RawUrl)))
					{
						try
						{
							controller.OnGet(args);
							break;
						}
						catch (Exception arg)
						{
							logger.LogError($"Unhandled exception in {controller2.GetType().Name} for {args.Request.RawUrl}: {arg}");
							args.Response.Error();
							break;
						}
					}
				}
			};
			httpServer.OnPost += delegate(object sender, HttpRequestEventArgs args)
			{
				foreach (object controller3 in controllers)
				{
					if (controller3 is IPostController postController)
					{
						string rawUrl = args.Request.RawUrl;
						int num = postController.RoutePrefix.Length + postController.RouteSuffix.Length;
						if (rawUrl.Length > num && rawUrl.StartsWith(postController.RoutePrefix) && rawUrl.EndsWith(postController.RouteSuffix))
						{
							string routeParameter = rawUrl.Substring(postController.RoutePrefix.Length, rawUrl.Length - postController.RoutePrefix.Length - postController.RouteSuffix.Length);
							try
							{
								postController.OnPost(args, routeParameter);
								break;
							}
							catch (Exception arg)
							{
								logger.LogError($"Unhandled exception in {controller3.GetType().Name} for {args.Request.RawUrl}: {arg}");
								args.Response.Error();
								break;
							}
						}
					}
				}
			};
		}

		internal static string RoutePath(string rawUrl)
		{
			int num = rawUrl?.IndexOf('?') ?? (-1);
			if (num >= 0)
			{
				return rawUrl.Substring(0, num);
			}
			return rawUrl;
		}

		private void ConfigureWebSocketServices()
		{
			httpServer.AddWebSocketService<ActivityWebSocketService>("/activity");
			httpServer.KeepClean = true;
			defaultWebSocketSessionManager = httpServer.WebSocketServices["/activity"].Sessions;
		}

		public void BroadcastWebSocketMessage<TInstance>(TInstance instance)
		{
			using MemoryStream memoryStream = new MemoryStream();
			Serializer.Serialize<TInstance>((Stream)memoryStream, instance);
			memoryStream.Seek(0L, SeekOrigin.Begin);
			defaultWebSocketSessionManager.Broadcast((Stream)memoryStream, (int)memoryStream.Length);
		}
	}
}
namespace OdinEye.Http.WebSockets
{
	public class ActivityWebSocketService : WebSocketBehavior
	{
	}
}
namespace OdinEye.Http.Api.Controllers
{
	public class BossDetailsController : IController
	{
		private const string DefeatedKey = "defeated_";

		private const string ActiveBossesKey = "activebosses";

		private readonly IEnumerable<(string, string)> bossNameKeys = new(string, string)[6]
		{
			("Eikthyr", "eikthyr"),
			("The Elder", "gdking"),
			("Bonemass", "bonemass"),
			("Moder", "dragon"),
			("Yagluth", "goblinking"),
			("The Queen", "queen")
		};

		public string Route => "/bossDetails";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00b4: Expected O, but got Unknown
			string value = ZoneSystem.instance.m_globalKeysValues.FirstOrDefault((KeyValuePair<string, string> kvp) => kvp.Key == "activebosses").Value;
			HashSet<string> defeatedKeys = (from kvp in ZoneSystem.instance.m_globalKeysValues
				where kvp.Key.StartsWith("defeated_")
				select kvp.Key).ToHashSet();
			BossDetails instance = new BossDetails
			{
				ActiveBosses = ((value != null) ? int.Parse(value) : 0),
				Bosses = GetBosses(defeatedKeys)
			};
			requestArguments.Response.Ok<BossDetails>(instance);
		}

		private IEnumerable<Boss> GetBosses(ICollection<string> defeatedKeys)
		{
			foreach (var (name, text) in bossNameKeys)
			{
				yield return new Boss
				{
					Key = text,
					Name = name,
					IsDefeated = defeatedKeys.Contains("defeated_" + text)
				};
			}
		}
	}
	public class CharacterStatsController : IController, IPostController
	{
		private static readonly DateTime ValheimReleaseDate = new DateTime(2021, 2, 2, 0, 0, 0, DateTimeKind.Utc);

		private static readonly ConcurrentDictionary<string, ConcurrentDictionary<string, float>> StatsByPlayerId = new ConcurrentDictionary<string, ConcurrentDictionary<string, float>>();

		internal static readonly ConcurrentDictionary<string, SubmissionMeta> MetaByPlayerId = new ConcurrentDictionary<string, SubmissionMeta>();

		public string Route => "/players/stats";

		public string RoutePrefix => "/players/";

		public string RouteSuffix => "/stats";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			Dictionary<string, IReadOnlyDictionary<string, float>> instance = ((IEnumerable<KeyValuePair<string, ConcurrentDictionary<string, float>>>)StatsByPlayerId).ToDictionary((Func<KeyValuePair<string, ConcurrentDictionary<string, float>>, string>)((KeyValuePair<string, ConcurrentDictionary<string, float>> player) => player.Key), (Func<KeyValuePair<string, ConcurrentDictionary<string, float>>, IReadOnlyDictionary<string, float>>)((KeyValuePair<string, ConcurrentDictionary<string, float>> player) => new Dictionary<string, float>(player.Value)));
			requestArguments.Response.Ok(instance);
		}

		public void OnPost(HttpRequestEventArgs requestArguments, string routeParameter)
		{
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			if (!Guid.TryParse(routeParameter, out var result))
			{
				requestArguments.Response.Error(400);
				return;
			}
			if (!IsConnectedPlayer(result))
			{
				requestArguments.Response.Error(404);
				return;
			}
			CharacterStatsSubmission val;
			try
			{
				val = JsonSerializer.Deserialize<CharacterStatsSubmission>(requestArguments.Request.InputStream);
			}
			catch
			{
				requestArguments.Response.Error(400);
				return;
			}
			if (((val != null) ? val.Stats : null) == null || val.Stats.Count == 0)
			{
				requestArguments.Response.Error(400);
				return;
			}
			string key = result.ToString();
			ConcurrentDictionary<string, float> orAdd = StatsByPlayerId.GetOrAdd(key, (string _) => new ConcurrentDictionary<string, float>());
			foreach (KeyValuePair<string, float> stat in val.Stats)
			{
				orAdd.TryGetValue(stat.Key, out var value);
				if (!IsValidStatValue(stat.Value, value))
				{
					requestArguments.Response.Error(400);
					return;
				}
			}
			foreach (KeyValuePair<string, float> stat2 in val.Stats)
			{
				orAdd[stat2.Key] = stat2.Value;
			}
			if (TryCleanMeta(val.Meta, out var clean))
			{
				MetaByPlayerId[key] = clean;
			}
			requestArguments.Response.Ok<AcceptedResponse>(new AcceptedResponse());
		}

		private static bool IsConnectedPlayer(Guid playerId)
		{
			return ZNet.instance.m_peers.Any((ZNetPeer peer) => peer.ToPlayer().Id == playerId);
		}

		internal static bool TryCleanMeta(SubmissionMeta meta, out SubmissionMeta clean)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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)
			//IL_007c: Expected O, but got Unknown
			clean = null;
			if (meta == null || string.IsNullOrEmpty(meta.PlayerId) || !long.TryParse(meta.PlayerId, out var result))
			{
				return false;
			}
			string text = meta.ClientVersion;
			if (text != null && (text.Length > 32 || !text.All((char c) => char.IsLetterOrDigit(c) || c == '.' || c == '-' || c == '+')))
			{
				text = null;
			}
			clean = new SubmissionMeta
			{
				PlayerId = result.ToString(),
				ClientVersion = text
			};
			return true;
		}

		internal static bool IsValidStatValue(float value, float previousValue)
		{
			if (float.IsNaN(value) || float.IsInfinity(value) || value < 0f)
			{
				return false;
			}
			float num = (float)(DateTime.UtcNow - ValheimReleaseDate).TotalSeconds;
			if (value > num)
			{
				return false;
			}
			return value >= previousValue;
		}
	}
	public class CheatStatusController : IController, IPostController
	{
		private static readonly ConcurrentDictionary<string, CheatStatusSubmission> StatusByPlayerId = new ConcurrentDictionary<string, CheatStatusSubmission>();

		public string Route => "/players/cheatStatus";

		public string RoutePrefix => "/players/";

		public string RouteSuffix => "/cheatStatus";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			requestArguments.Response.Ok(new Dictionary<string, CheatStatusSubmission>(StatusByPlayerId));
		}

		public void OnPost(HttpRequestEventArgs requestArguments, string routeParameter)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			if (!Guid.TryParse(routeParameter, out var result))
			{
				requestArguments.Response.Error(400);
				return;
			}
			if (!IsConnectedPlayer(result))
			{
				requestArguments.Response.Error(404);
				return;
			}
			CheatStatusSubmission val;
			try
			{
				val = JsonSerializer.Deserialize<CheatStatusSubmission>(requestArguments.Request.InputStream);
			}
			catch
			{
				requestArguments.Response.Error(400);
				return;
			}
			if (val == null)
			{
				requestArguments.Response.Error(400);
				return;
			}
			StatusByPlayerId[result.ToString()] = val;
			requestArguments.Response.Ok<AcceptedResponse>(new AcceptedResponse());
		}

		private static bool IsConnectedPlayer(Guid playerId)
		{
			return ZNet.instance.m_peers.Any((ZNetPeer peer) => peer.ToPlayer().Id == playerId);
		}
	}
	public class EventsController : IController
	{
		public string Route => "/events";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			NameValueCollection queryString = requestArguments.Request.QueryString;
			EventsQuery.Parse(queryString["after"], queryString["limit"], out var after, out var limit);
			requestArguments.Response.Ok(OdinEyePlugin.Instance.EventFeed.Read(after, limit));
		}
	}
	public interface IController
	{
		string Route { get; }

		void OnGet(HttpRequestEventArgs requestArguments);
	}
	public interface IPostController
	{
		string RoutePrefix { get; }

		string RouteSuffix { get; }

		void OnPost(HttpRequestEventArgs requestArguments, string routeParameter);
	}
	public class PlayerNotifyController : IPostController
	{
		private const int MessageTypeCenter = 2;

		private const int MaxMessageLength = 200;

		public string RoutePrefix => "/players/";

		public string RouteSuffix => "/notify";

		internal static bool IsValidSteamId(string steamId)
		{
			if (!string.IsNullOrEmpty(steamId))
			{
				return steamId.All(char.IsDigit);
			}
			return false;
		}

		internal static bool IsValidMessage(string message)
		{
			if (!string.IsNullOrWhiteSpace(message))
			{
				return message.Length <= 200;
			}
			return false;
		}

		public void OnPost(HttpRequestEventArgs requestArguments, string routeParameter)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			if (!IsValidSteamId(routeParameter))
			{
				requestArguments.Response.Error(400);
				return;
			}
			NotifyRequest val;
			try
			{
				val = JsonSerializer.Deserialize<NotifyRequest>(requestArguments.Request.InputStream);
			}
			catch
			{
				requestArguments.Response.Error(400);
				return;
			}
			if (val == null || !IsValidMessage(val.Message))
			{
				requestArguments.Response.Error(400);
				return;
			}
			ZNetPeer val2 = ((IEnumerable<ZNetPeer>)ZNet.instance.m_peers).FirstOrDefault((Func<ZNetPeer, bool>)((ZNetPeer p) => p.ToPlayer().SteamId == routeParameter));
			if (val2 == null)
			{
				requestArguments.Response.Error(404);
				return;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(val2.m_uid, "ShowMessage", new object[2] { 2, val.Message });
			requestArguments.Response.Ok<AcceptedResponse>(new AcceptedResponse());
		}
	}
	public class PlayerEventsController : IPostController
	{
		internal static readonly ClientEventRateLimiter RateLimiter = new ClientEventRateLimiter(20, TimeSpan.FromMinutes(1.0));

		public string RoutePrefix => "/players/";

		public string RouteSuffix => "/events";

		public void OnPost(HttpRequestEventArgs requestArguments, string routeParameter)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			if (!Guid.TryParse(routeParameter, out var playerId))
			{
				requestArguments.Response.Error(400);
				return;
			}
			ZNetPeer val = ((IEnumerable<ZNetPeer>)ZNet.instance.m_peers).FirstOrDefault((Func<ZNetPeer, bool>)((ZNetPeer p) => p.ToPlayer().Id == playerId));
			if (val == null)
			{
				requestArguments.Response.Error(404);
				return;
			}
			ClientEventsSubmission submission;
			try
			{
				submission = JsonSerializer.Deserialize<ClientEventsSubmission>(requestArguments.Request.InputStream);
			}
			catch
			{
				requestArguments.Response.Error(400);
				return;
			}
			Player player = val.ToPlayer();
			if (!ClientEventCleaner.TryClean(submission, player, out var events))
			{
				requestArguments.Response.Error(400);
				return;
			}
			if (!RateLimiter.TryAcquire(playerId.ToString(), events.Count, DateTime.UtcNow))
			{
				requestArguments.Response.Error(429);
				return;
			}
			foreach (GameEvent item in events)
			{
				OdinEyePlugin.Instance.EventHandler.Handle(item);
			}
			requestArguments.Response.Ok<AcceptedResponse>(new AcceptedResponse());
		}
	}
	public class PlayersMetaController : IController
	{
		public string Route => "/players/meta";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			requestArguments.Response.Ok(new Dictionary<string, SubmissionMeta>(CharacterStatsController.MetaByPlayerId));
		}
	}
	public class PlayersController : IController
	{
		public string Route => "/players";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			IEnumerable<Peer> allPeers = ZNet.instance.GetAllPeers();
			requestArguments.Response.Ok(allPeers.ToDto());
		}
	}
	public class ServerDetailsController : IController
	{
		public string Route => "/serverDetails";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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)
			//IL_002a: Expected O, but got Unknown
			ServerDetails instance = new ServerDetails
			{
				MaxNumberOfPlayers = 10,
				GameVersion = Version.GetVersionString(false),
				SteamAppId = SteamManager.APP_ID.ToString()
			};
			requestArguments.Response.Ok<ServerDetails>(instance);
		}
	}
	public class WorldDetailsController : IController
	{
		public string Route => "/worldDetails";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_0041: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			WorldDetails instance = new WorldDetails
			{
				DayNumber = EnvMan.instance.GetCurrentDay(),
				DayCycle = GetDayCycle(),
				NetTime = ZNet.instance.GetTimeSeconds(),
				WorldName = ZNet.instance.GetWorldName(),
				SeedName = ZNet.m_world.m_seedName,
				WorldKeys = ZNet.m_world.m_startingGlobalKeys,
				GlobalKeys = GetGlobalKeys()
			};
			requestArguments.Response.Ok<WorldDetails>(instance);
		}

		private string GetDayCycle()
		{
			if (EnvMan.instance.IsNightSafe())
			{
				return "night";
			}
			if (EnvMan.instance.IsDaySafe())
			{
				if (!EnvMan.instance.IsAfternoonSafe())
				{
					return "morning";
				}
				return "afternoon";
			}
			return "unknown";
		}

		private IEnumerable<GlobalKey> GetGlobalKeys()
		{
			if (ZoneSystem.instance.m_globalKeysValues.Count != 0)
			{
				return ((IEnumerable<KeyValuePair<string, string>>)ZoneSystem.instance.m_globalKeysValues).Select((Func<KeyValuePair<string, string>, GlobalKey>)((KeyValuePair<string, string> key) => new GlobalKey
				{
					Name = key.Key,
					Value = key.Value
				}));
			}
			return Enumerable.Empty<GlobalKey>();
		}
	}
	public class WorldModifiersController : IController
	{
		private static readonly string[] Categories = new string[5] { "combat", "deathpenalty", "resources", "raids", "portals" };

		public string Route => "/worldModifiers";

		public void OnGet(HttpRequestEventArgs requestArguments)
		{
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			List<WorldModifierValue> list = new List<WorldModifierValue>();
			string value = null;
			string text = null;
			if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.m_globalKeysValues.TryGetValue("preset", out value) && !string.IsNullOrEmpty(value))
			{
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				string[] array = value.Split(new char[1] { ':' });
				for (int i = 0; i < array.Length; i++)
				{
					string[] array2 = array[i].Split(new char[1] { '_' });
					if (array2.Length == 2)
					{
						dictionary[array2[0]] = array2[1];
					}
				}
				if (Categories.All(dictionary.ContainsKey))
				{
					array = Categories;
					foreach (string text2 in array)
					{
						list.Add(new WorldModifierValue
						{
							Category = text2,
							Value = dictionary[text2]
						});
					}
				}
				else
				{
					text = value;
					array = Categories;
					foreach (string category in array)
					{
						list.Add(new WorldModifierValue
						{
							Category = category,
							Value = "unknown"
						});
					}
				}
			}
			else
			{
				string[] array = Categories;
				foreach (string category2 in array)
				{
					list.Add(new WorldModifierValue
					{
						Category = category2,
						Value = "default"
					});
				}
			}
			string summary;
			if (text != null)
			{
				summary = "Preset: " + text;
			}
			else
			{
				List<WorldModifierValue> list2 = list.Where((WorldModifierValue m) => m.Value != "default").ToList();
				summary = ((list2.Count == 0) ? "Default" : string.Join(", ", list2.Select((WorldModifierValue m) => m.Category + ": " + m.Value)));
			}
			requestArguments.Response.Ok<WorldModifiersDetails>(new WorldModifiersDetails
			{
				Modifiers = list,
				Summary = summary
			});
		}
	}
}
namespace OdinEye.Extensions
{
	public static class EnvManExtensions
	{
		private static readonly MethodInfo IsDayMethod = GetBoolMethod("IsDay");

		private static readonly MethodInfo IsNightMethod = GetBoolMethod("IsNight");

		private static readonly MethodInfo IsAfternoonMethod = GetBoolMethod("IsAfternoon");

		public static bool IsDaySafe(this EnvMan env)
		{
			return Invoke(IsDayMethod, env);
		}

		public static bool IsNightSafe(this EnvMan env)
		{
			return Invoke(IsNightMethod, env);
		}

		public static bool IsAfternoonSafe(this EnvMan env)
		{
			return Invoke(IsAfternoonMethod, env);
		}

		private static MethodInfo GetBoolMethod(string name)
		{
			return typeof(EnvMan).GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		private static bool Invoke(MethodInfo method, EnvMan env)
		{
			if (method != null)
			{
				return (bool)method.Invoke(env, null);
			}
			return false;
		}
	}
	public static class HttpListenerResponseExtensions
	{
		public static void Ok<TInstance>(this HttpListenerResponse response, TInstance instance)
		{
			byte[] array = JsonSerializer.Serialize<TInstance>(instance);
			response.StatusCode = 200;
			response.ContentType = "application/json";
			response.ContentLength64 = array.Length;
			response.ContentEncoding = Encoding.UTF8;
			response.OutputStream.Write(array, 0, array.Length);
			response.Close();
		}

		public static void Error(this HttpListenerResponse response, int statusCode = 500)
		{
			byte[] bytes = Encoding.UTF8.GetBytes("An error occurred while handling this request.");
			response.StatusCode = statusCode;
			response.ContentType = "text/plain";
			response.ContentLength64 = bytes.Length;
			response.ContentEncoding = Encoding.UTF8;
			response.OutputStream.Write(bytes, 0, bytes.Length);
			response.Close();
		}
	}
	public static class PeerExtensions
	{
		public static IEnumerable<Player> ToDto(this IEnumerable<Peer> peers)
		{
			return peers.Select((Func<Peer, Player>)((Peer peer) => new Player
			{
				Id = NameBasedGuid.NewPlayerGuid(peer.SteamId, peer.Name),
				CharacterId = peer.CharacterId,
				Name = peer.Name,
				SteamId = peer.SteamId,
				Health = peer.Health,
				MaxHealth = peer.MaxHealth,
				Stamina = peer.Stamina
			}));
		}

		public static IEnumerable<PlayerStats> ToPlayerStats(this IEnumerable<Peer> peers)
		{
			return peers.Select((Func<Peer, PlayerStats>)((Peer peer) => new PlayerStats
			{
				Id = NameBasedGuid.NewPlayerGuid(peer.SteamId, peer.Name),
				CharacterId = peer.CharacterId,
				Health = peer.Health,
				MaxHealth = peer.MaxHealth,
				Stamina = peer.Stamina
			}));
		}
	}
	public static class ZNetExtensions
	{
		public static IEnumerable<Peer> GetAllPeers(this ZNet znet)
		{
			float health = default(float);
			float maxHealth = default(float);
			float stamina = default(float);
			foreach (ZNetPeer peer in znet.m_peers)
			{
				if (peer.IsReady() && !((ZDOID)(ref peer.m_characterID)).IsNone())
				{
					ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
					if (zDO != null)
					{
						zDO.GetFloat(ZDOVars.s_health, ref health);
						zDO.GetFloat(ZDOVars.s_maxHealth, ref maxHealth);
						zDO.GetFloat(ZDOVars.s_stamina, ref stamina);
						yield return new Peer
						{
							CharacterId = ((object)Unsafe.As<ZDOID, ZDOID>(ref peer.m_characterID)/*cast due to .constrained prefix*/).ToString(),
							Name = peer.m_playerName,
							SteamId = peer.m_socket.GetHostName(),
							Health = health,
							MaxHealth = maxHealth,
							Stamina = stamina
						};
					}
				}
			}
		}
	}
	public static class ZNetPeerExtensions
	{
		public static Player ToPlayer(this ZNetPeer peer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			return new Player
			{
				Id = NameBasedGuid.NewPlayerGuid(peer.m_socket.GetHostName(), peer.m_playerName),
				Name = peer.m_playerName,
				SteamId = peer.m_socket.GetHostName()
			};
		}
	}
}
namespace OdinEye.Events
{
	public class EventHandler
	{
		private IEventMiddleware rootMiddleware;

		public void Configure(Action<EventHandlerConfigurationOptions> configurator)
		{
			EventHandlerConfigurationOptions eventHandlerConfigurationOptions = new EventHandlerConfigurationOptions();
			configurator(eventHandlerConfigurationOptions);
			rootMiddleware = eventHandlerConfigurationOptions.RootMiddleware;
		}

		public void Handle(GameEvent gameEvent)
		{
			rootMiddleware.Handle(gameEvent);
		}
	}
	public sealed class EventFeed
	{
		public const int DefaultCapacity = 5000;

		private readonly object gate = new object();

		private readonly Queue<EventFeedEntry> entries = new Queue<EventFeedEntry>();

		private readonly int capacity;

		private long nextSeq = 1L;

		public string BootId { get; }

		public EventFeed(int capacity = 5000, string bootId = null)
		{
			if (capacity <= 0)
			{
				throw new ArgumentOutOfRangeException("capacity", "Capacity must be positive.");
			}
			this.capacity = capacity;
			BootId = bootId ?? Guid.NewGuid().ToString();
		}

		public static bool ShouldRecord(EventType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			return (int)type != 5;
		}

		public long Append(GameEvent gameEvent)
		{
			if (gameEvent == null)
			{
				throw new ArgumentNullException("gameEvent");
			}
			lock (gate)
			{
				long num = nextSeq++;
				entries.Enqueue(EventFeedEntry.From(num, gameEvent));
				while (entries.Count > capacity)
				{
					entries.Dequeue();
				}
				return num;
			}
		}

		public EventFeedResult Read(long after, int limit)
		{
			if (limit <= 0)
			{
				limit = 1;
			}
			lock (gate)
			{
				long num = ((entries.Count > 0) ? entries.Peek().Seq : nextSeq);
				return new EventFeedResult
				{
					BootId = BootId,
					NextSeq = nextSeq,
					Gap = (num > after + 1),
					Events = entries.Where((EventFeedEntry e) => e.Seq > after).Take(limit).ToList()
				};
			}
		}
	}
	public sealed class EventFeedResult
	{
		public string BootId { get; set; }

		public long NextSeq { get; set; }

		public bool Gap { get; set; }

		public List<EventFeedEntry> Events { get; set; }
	}
	public sealed class EventFeedEntry
	{
		public long Seq { get; set; }

		public string Ts { get; set; }

		public string Type { get; set; }

		public string Message { get; set; }

		public EventFeedPlayer Player { get; set; }

		public Dictionary<string, object> Data { get; set; }

		public static EventFeedEntry From(long seq, GameEvent gameEvent)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			return new EventFeedEntry
			{
				Seq = seq,
				Ts = ((Message)gameEvent).CreatedDate.ToUniversalTime().ToString("o"),
				Type = ((object)gameEvent.Type/*cast due to .constrained prefix*/).ToString(),
				Message = gameEvent.Message,
				Player = ((gameEvent.Player == null) ? null : new EventFeedPlayer
				{
					Id = gameEvent.Player.Id.ToString(),
					Name = gameEvent.Player.Name,
					SteamId = gameEvent.Player.SteamId
				}),
				Data = ((gameEvent.Details == null) ? new Dictionary<string, object>() : new Dictionary<string, object>(gameEvent.Details))
			};
		}
	}
	public sealed class EventFeedPlayer
	{
		public string Id { get; set; }

		public string Name { get; set; }

		public string SteamId { get; set; }
	}
	public static class EventsQuery
	{
		public const int DefaultLimit = 500;

		public const int MaxLimit = 1000;

		public static void Parse(string afterRaw, string limitRaw, out long after, out int limit)
		{
			after = ((long.TryParse(afterRaw, out var result) && result > 0) ? result : 0);
			limit = (int.TryParse(limitRaw, out var result2) ? Math.Max(1, Math.Min(1000, result2)) : 500);
		}
	}
	public static class ClientEventCleaner
	{
		public const int MaxEventsPerRequest = 20;

		private const float MaxCoordinate = 100000f;

		private static readonly HashSet<string> AllowedTypes = new HashSet<string>(StringComparer.Ordinal) { "BedRemoved", "BedMissingAtRespawn" };

		public static bool TryClean(ClientEventsSubmission submission, Player player, out List<GameEvent> events)
		{
			events = null;
			if (((submission != null) ? submission.Events : null) == null || submission.Events.Count == 0 || submission.Events.Count > 20)
			{
				return false;
			}
			List<GameEvent> list = new List<GameEvent>();
			foreach (ClientEvent @event in submission.Events)
			{
				GameEvent val = CleanOne(@event, player);
				if (val == null)
				{
					return false;
				}
				list.Add(val);
			}
			events = list;
			return true;
		}

		private static GameEvent CleanOne(ClientEvent clientEvent, Player player)
		{
			if (clientEvent == null || clientEvent.Type == null || !AllowedTypes.Contains(clientEvent.Type) || !IsSaneCoordinate(clientEvent.X) || !IsSaneCoordinate(clientEvent.Y) || !IsSaneCoordinate(clientEvent.Z))
			{
				return null;
			}
			if (clientEvent.Type == "BedRemoved")
			{
				if (!long.TryParse(clientEvent.OwnerPlayerId, out var result) || !long.TryParse(clientEvent.RemoverPlayerId, out var result2))
				{
					return null;
				}
				return GameEvent.New((EventType)400, "A claimed bed was removed with the hammer", player, (IDictionary<string, object>)new Dictionary<string, object>
				{
					["OwnerPlayerId"] = result.ToString(),
					["RemoverPlayerId"] = result2.ToString(),
					["SpawnX"] = clientEvent.X,
					["SpawnY"] = clientEvent.Y,
					["SpawnZ"] = clientEvent.Z
				});
			}
			return GameEvent.New((EventType)401, "A player respawned at the circle because their bed was gone", player, (IDictionary<string, object>)new Dictionary<string, object>
			{
				["LostSpawnX"] = clientEvent.X,
				["LostSpawnY"] = clientEvent.Y,
				["LostSpawnZ"] = clientEvent.Z
			});
		}

		private static bool IsSaneCoordinate(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return Math.Abs(value) <= 100000f;
			}
			return false;
		}
	}
	public sealed class ClientEventRateLimiter
	{
		private readonly int maxPerWindow;

		private readonly TimeSpan window;

		private readonly Dictionary<string, Queue<DateTime>> recentByPlayer = new Dictionary<string, Queue<DateTime>>();

		private readonly object gate = new object();

		public ClientEventRateLimiter(int maxPerWindow, TimeSpan window)
		{
			if (maxPerWindow <= 0)
			{
				throw new ArgumentOutOfRangeException("maxPerWindow");
			}
			if (window <= TimeSpan.Zero)
			{
				throw new ArgumentOutOfRangeException("window");
			}
			this.maxPerWindow = maxPerWindow;
			this.window = window;
		}

		public bool TryAcquire(string playerKey, int count, DateTime nowUtc)
		{
			lock (gate)
			{
				if (!recentByPlayer.TryGetValue(playerKey, out var value))
				{
					value = new Queue<DateTime>();
					recentByPlayer[playerKey] = value;
				}
				while (value.Count > 0 && nowUtc - value.Peek() >= window)
				{
					value.Dequeue();
				}
				if (value.Count + count > maxPerWindow)
				{
					return false;
				}
				for (int i = 0; i < count; i++)
				{
					value.Enqueue(nowUtc);
				}
				return true;
			}
		}
	}
	public static class EnemyKillDetails
	{
		public static Dictionary<string, object> Build(string enemyName, int level, bool isBoss, IEnumerable<string> attackers)
		{
			List<string> list = (attackers ?? Enumerable.Empty<string>()).Where((string n) => !string.IsNullOrEmpty(n)).Distinct().ToList();
			return new Dictionary<string, object>
			{
				["Enemy"] = enemyName,
				["Level"] = level,
				["Boss"] = isBoss,
				["Attackers"] = list,
				["Solo"] = list.Count == 1
			};
		}
	}
	public class EventHandlerConfigurationOptions
	{
		public IEventMiddleware RootMiddleware { get; private set; }

		public IEventMiddleware LastMiddleware { get; private set; }

		public EventHandlerConfigurationOptions AddMiddleware(EventMiddleware eventMiddleware)
		{
			if (RootMiddleware == null)
			{
				RootMiddleware = eventMiddleware;
			}
			LastMiddleware?.SetNext(eventMiddleware);
			LastMiddleware = eventMiddleware;
			return this;
		}
	}
}
namespace OdinEye.Coroutines
{
	public class GameStatsSnapshotCoroutine
	{
		private readonly HttpWebServer httpWebServer;

		public GameStatsSnapshotCoroutine(HttpWebServer httpWebServer)
		{
			this.httpWebServer = httpWebServer;
		}

		public IEnumerator SendGameStatsSnapshotCoroutine()
		{
			while (true)
			{
				SendGameStatsSnapshot();
				yield return (object)new WaitForSeconds(1f);
			}
		}

		private void SendGameStatsSnapshot()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			WorldStats worldStats = new WorldStats
			{
				DayNumber = EnvMan.instance.GetCurrentDay(),
				DayCycle = (EnvMan.instance.IsDaySafe() ? "day" : "night")
			};
			IEnumerable<PlayerStats> playerStats = ZNet.instance.GetAllPeers().ToPlayerStats();
			GameStatsSnapshot instance = new GameStatsSnapshot
			{
				CreatedDate = DateTime.UtcNow,
				PlayerStats = playerStats,
				WorldStats = worldStats
			};
			httpWebServer.BroadcastWebSocketMessage<GameStatsSnapshot>(instance);
		}
	}
}