using System;
using System.Collections;
using System.Collections.Generic;
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.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CodeTalker.Networking;
using CodeTalker.Packets;
using HarmonyLib;
using Mirror;
using ServerAnnouncements.Channels;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("atl_host")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("atl_host")]
[assembly: AssemblyCopyright("Copyright \ufffd\ufffd  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("45a14b12-0a67-4261-85f1-09da9e90923b")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ServerAnnouncements
{
	public static class AnnouncementCommandHandler
	{
		[HarmonyPatch(typeof(ChatBehaviour), "Cmd_SendChatMessage")]
		private static class ChatCommandPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(ChatBehaviour __instance, string _message)
			{
				if (string.IsNullOrEmpty(_message) || !_message.StartsWith("/ntc"))
				{
					return true;
				}
				try
				{
					ProcessCommand(__instance, _message);
				}
				catch (Exception ex)
				{
					ServerAnnouncementsPlugin.Log.LogError((object)("Command processing error: " + ex.Message));
					LocalMessage(__instance, "<color=#FF6666>[Notice] Command failed. Check log.</color>");
				}
				return false;
			}
		}

		private const string CMD_PREFIX = "/ntc";

		public static void Initialize()
		{
			ServerAnnouncementsPlugin.Log.LogDebug((object)"Notice command handler initialized.");
		}

		private static void ProcessCommand(ChatBehaviour chat, string input)
		{
			string[] array = input.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length < 2)
			{
				ShowHelp(chat);
				return;
			}
			string text = array[1].ToLower();
			bool isHost = AnnouncementManager.IsHost();
			switch (text)
			{
			case "help":
				ShowHelp(chat);
				break;
			case "toast":
				if (RequireHost(chat, isHost))
				{
					float num = AnnouncementConfig.ToastDuration.Value;
					string text2;
					if (array.Length <= 3 || !float.TryParse(array[2], out var result))
					{
						text2 = ((array.Length <= 2) ? AnnouncementConfig.JoinToastMessage.Value : string.Join(" ", array.Skip(2)));
					}
					else
					{
						num = result;
						text2 = string.Join(" ", array.Skip(3));
					}
					AnnouncementNetworkHandler.BroadcastToast(text2, num, skipLocalDisplay: false, forceShow: true);
					LocalMessage(chat, $"<color=#FFD700>[Notice]</color> Toast sent ({num}s): {text2}");
				}
				break;
			case "banner":
				if (RequireHost(chat, isHost))
				{
					ShowBannerToAll();
					LocalMessage(chat, "<color=#FFD700>[Notice]</color> Banner shown to all players.");
				}
				break;
			case "version":
				if (RequireHost(chat, isHost))
				{
					if (array.Length > 2 && int.TryParse(array[2], out var result3))
					{
						AnnouncementConfig.NoticeVersion.Value = result3;
						LocalMessage(chat, $"<color=#FFD700>[Notice]</color> Notice version set to {result3}");
					}
					else
					{
						LocalMessage(chat, $"<color=#FFD700>[Notice]</color> Current version: {AnnouncementConfig.NoticeVersion.Value}");
					}
				}
				break;
			case "duration":
				if (RequireHost(chat, isHost))
				{
					if (array.Length > 2 && float.TryParse(array[2], out var result2))
					{
						result2 = Mathf.Clamp(result2, 1f, 30f);
						AnnouncementConfig.ToastDuration.Value = result2;
						LocalMessage(chat, $"<color=#FFD700>[Notice]</color> Toast duration set to {result2}s");
					}
					else
					{
						LocalMessage(chat, $"<color=#FFD700>[Notice]</color> Current duration: {AnnouncementConfig.ToastDuration.Value}s (1-30)");
					}
				}
				break;
			case "title":
				if (RequireHost(chat, isHost))
				{
					if (array.Length > 2)
					{
						string text5 = string.Join(" ", array.Skip(2));
						AnnouncementConfig.BannerTitle.Value = text5;
						LocalMessage(chat, "<color=#FFD700>[Notice]</color> Banner title set to: " + text5);
					}
					else
					{
						LocalMessage(chat, "<color=#FFD700>[Notice]</color> Current title: " + AnnouncementConfig.BannerTitle.Value);
					}
				}
				break;
			case "content":
				if (RequireHost(chat, isHost))
				{
					if (array.Length > 2)
					{
						string value = string.Join(" ", array.Skip(2));
						AnnouncementConfig.BannerContent.Value = value;
						LocalMessage(chat, "<color=#FFD700>[Notice]</color> Banner content set.");
					}
					else
					{
						LocalMessage(chat, "<color=#FFD700>[Notice]</color> Current content: " + AnnouncementConfig.BannerContent.Value);
					}
				}
				break;
			case "joinmsg":
				if (RequireHost(chat, isHost))
				{
					if (array.Length > 2)
					{
						string text4 = string.Join(" ", array.Skip(2));
						AnnouncementConfig.JoinToastMessage.Value = text4;
						LocalMessage(chat, "<color=#FFD700>[Notice]</color> Join message set to: " + text4);
					}
					else
					{
						LocalMessage(chat, "<color=#FFD700>[Notice]</color> Current join message: " + AnnouncementConfig.JoinToastMessage.Value);
					}
				}
				break;
			case "tab":
				if (RequireHost(chat, isHost))
				{
					if (array.Length > 2)
					{
						string text3 = string.Join(" ", array.Skip(2));
						AnnouncementConfig.EasySettingsTab.Value = text3;
						LocalMessage(chat, "<color=#FFD700>[Notice]</color> EasySettings tab set to: " + text3);
						LocalMessage(chat, "<color=#AAAAAA>Restart game or reload settings for changes to take effect.</color>");
					}
					else
					{
						LocalMessage(chat, "<color=#FFD700>[Notice]</color> Current tab: " + AnnouncementConfig.EasySettingsTab.Value);
						LocalMessage(chat, "<color=#AAAAAA>Examples: Moderation, Mods, Server</color>");
					}
				}
				break;
			case "reload":
				if (RequireHost(chat, isHost))
				{
					AnnouncementConfig.Reload();
					LocalMessage(chat, "<color=#FFD700>[Notice]</color> Config reloaded.");
				}
				break;
			case "status":
				if (RequireHost(chat, isHost))
				{
					ShowStatus(chat);
				}
				break;
			case "reset":
				AnnouncementManager.Instance.ResetAllAcknowledgments();
				LocalMessage(chat, "<color=#FFD700>[Notice]</color> Notice acknowledgment history cleared.");
				break;
			default:
				LocalMessage(chat, "<color=#FF6666>[Notice]</color> Unknown command: " + text + ". Use /ntc help");
				break;
			}
		}

		private static bool RequireHost(ChatBehaviour chat, bool isHost)
		{
			if (!isHost)
			{
				LocalMessage(chat, "<color=#FF6666>[Notice]</color> This command is host-only.");
				return false;
			}
			return true;
		}

		private static void LocalMessage(ChatBehaviour chat, string msg)
		{
			chat.New_ChatMessage(msg);
		}

		private static void ShowHelp(ChatBehaviour chat)
		{
			LocalMessage(chat, "<color=#FFD700>=== Server Notice Commands ===</color>");
			LocalMessage(chat, "/ntc help - Show this help");
			LocalMessage(chat, "/ntc toast [sec] [msg] - Send toast (Host)");
			LocalMessage(chat, "/ntc banner - Show banner to all (Host)");
			LocalMessage(chat, "/ntc duration [n] - Set toast duration (Host)");
			LocalMessage(chat, "/ntc title [text] - Set banner title (Host)");
			LocalMessage(chat, "/ntc content [text] - Set banner content (Host)");
			LocalMessage(chat, "/ntc joinmsg [text] - Set join message (Host)");
			LocalMessage(chat, "/ntc version [n] - Set notice version (Host)");
			LocalMessage(chat, "/ntc tab [name] - Set EasySettings tab (Host)");
			LocalMessage(chat, "/ntc status - Show status (Host)");
			LocalMessage(chat, "/ntc reload - Reload config (Host)");
			LocalMessage(chat, "/ntc reset - Reset your acknowledgments");
		}

		private static void ShowStatus(ChatBehaviour chat)
		{
			LocalMessage(chat, "<color=#FFD700>=== Notice Status ===</color>");
			LocalMessage(chat, $"Enabled: {AnnouncementConfig.EnableNoticeSystem.Value}");
			LocalMessage(chat, $"Version: {AnnouncementConfig.NoticeVersion.Value}");
			LocalMessage(chat, "Title: " + AnnouncementConfig.BannerTitle.Value);
			LocalMessage(chat, $"Join Toast: {AnnouncementConfig.ShowToastOnJoin.Value}");
			LocalMessage(chat, $"Toast Duration: {AnnouncementConfig.ToastDuration.Value}s");
			LocalMessage(chat, "Join Message: " + AnnouncementConfig.JoinToastMessage.Value);
			LocalMessage(chat, $"Vanilla Compat: {AnnouncementConfig.VanillaCompatMode.Value}");
		}

		public static void SendToastNow(string message = null)
		{
			if (!AnnouncementManager.IsHost())
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"SendToastNow called but not host.");
				return;
			}
			string message2 = message ?? AnnouncementConfig.JoinToastMessage.Value;
			float value = AnnouncementConfig.ToastDuration.Value;
			AnnouncementNetworkHandler.BroadcastToast(message2, value, skipLocalDisplay: false, forceShow: true);
		}

		public static void ShowBannerToAll()
		{
			if (!AnnouncementManager.IsHost())
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"ShowBannerToAll called but not host.");
			}
			else
			{
				AnnouncementNetworkHandler.BroadcastBanner(forceShow: true);
			}
		}

		public static void SyncSettingsIfHost()
		{
			if (AnnouncementManager.IsHost())
			{
			}
		}
	}
	[Serializable]
	public class ModeratorSharedContent
	{
		public string ToastMessage = "Moderator Announcement";

		public float ToastDuration = 5f;

		public int ToastFontSize = 20;

		public string BannerTitle = "Moderator Notice";

		public string BannerHighlight = "";

		public string BannerContent = "";

		public string BannerExtraContent = "";

		public int TitleFontSize = 24;

		public int HighlightFontSize = 18;

		public int ContentFontSize = 16;

		public int ExtraFontSize = 14;

		public int SoundType = 0;

		public float SoundVolume = 0.5f;

		public bool ScheduleEnabled = false;

		public float ScheduleInterval = 300f;

		public bool ScheduleToast = true;

		public bool ScheduleBanner = false;

		public string LastEditedBy = "";

		public long LastEditedTimestamp = 0L;

		public DateTime LastEditedAt => DateTimeOffset.FromUnixTimeSeconds(LastEditedTimestamp).LocalDateTime;

		public void SetLastEdited(string steamId)
		{
			LastEditedBy = steamId ?? "";
			LastEditedTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
		}

		public string Serialize()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(Escape(ToastMessage));
			stringBuilder.Append("|");
			stringBuilder.Append(ToastDuration.ToString("F2"));
			stringBuilder.Append("|");
			stringBuilder.Append(ToastFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(Escape(BannerTitle));
			stringBuilder.Append("|");
			stringBuilder.Append(Escape(BannerHighlight));
			stringBuilder.Append("|");
			stringBuilder.Append(Escape(BannerContent));
			stringBuilder.Append("|");
			stringBuilder.Append(Escape(BannerExtraContent));
			stringBuilder.Append("|");
			stringBuilder.Append(TitleFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(HighlightFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(ContentFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(ExtraFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(SoundType);
			stringBuilder.Append("|");
			stringBuilder.Append(SoundVolume.ToString("F2"));
			stringBuilder.Append("|");
			stringBuilder.Append(Escape(LastEditedBy));
			stringBuilder.Append("|");
			stringBuilder.Append(LastEditedTimestamp);
			stringBuilder.Append("|");
			stringBuilder.Append(ScheduleEnabled ? "1" : "0");
			stringBuilder.Append("|");
			stringBuilder.Append(ScheduleInterval.ToString("F1"));
			stringBuilder.Append("|");
			stringBuilder.Append(ScheduleToast ? "1" : "0");
			stringBuilder.Append("|");
			stringBuilder.Append(ScheduleBanner ? "1" : "0");
			return stringBuilder.ToString();
			static string Escape(string s)
			{
				return (s ?? "").Replace("|", "\\|").Replace("\n", "\\n");
			}
		}

		public static ModeratorSharedContent Deserialize(string data)
		{
			ModeratorSharedContent moderatorSharedContent = new ModeratorSharedContent();
			if (string.IsNullOrEmpty(data))
			{
				return moderatorSharedContent;
			}
			try
			{
				string[] array = SplitByUnescapedPipe(data);
				if (array.Length >= 15)
				{
					moderatorSharedContent.ToastMessage = Unescape(array[0]);
					float.TryParse(array[1], out moderatorSharedContent.ToastDuration);
					int.TryParse(array[2], out moderatorSharedContent.ToastFontSize);
					moderatorSharedContent.BannerTitle = Unescape(array[3]);
					moderatorSharedContent.BannerHighlight = Unescape(array[4]);
					moderatorSharedContent.BannerContent = Unescape(array[5]);
					moderatorSharedContent.BannerExtraContent = Unescape(array[6]);
					int.TryParse(array[7], out moderatorSharedContent.TitleFontSize);
					int.TryParse(array[8], out moderatorSharedContent.HighlightFontSize);
					int.TryParse(array[9], out moderatorSharedContent.ContentFontSize);
					int.TryParse(array[10], out moderatorSharedContent.ExtraFontSize);
					int.TryParse(array[11], out moderatorSharedContent.SoundType);
					float.TryParse(array[12], out moderatorSharedContent.SoundVolume);
					moderatorSharedContent.LastEditedBy = Unescape(array[13]);
					long.TryParse(array[14], out moderatorSharedContent.LastEditedTimestamp);
				}
				if (array.Length >= 19)
				{
					moderatorSharedContent.ScheduleEnabled = array[15] == "1";
					float.TryParse(array[16], out moderatorSharedContent.ScheduleInterval);
					moderatorSharedContent.ScheduleToast = array[17] == "1";
					moderatorSharedContent.ScheduleBanner = array[18] == "1";
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("[ModeratorSharedContent] Deserialize error: " + ex.Message));
			}
			return moderatorSharedContent;
			static string Unescape(string s)
			{
				return (s ?? "").Replace("\\|", "|").Replace("\\n", "\n");
			}
		}

		private static string[] SplitByUnescapedPipe(string input)
		{
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < input.Length; i++)
			{
				if (input[i] == '|' && (i == 0 || input[i - 1] != '\\'))
				{
					list.Add(stringBuilder.ToString());
					stringBuilder.Clear();
				}
				else
				{
					stringBuilder.Append(input[i]);
				}
			}
			list.Add(stringBuilder.ToString());
			return list.ToArray();
		}

		public void CopyFrom(ModeratorSharedContent other)
		{
			if (other != null)
			{
				ToastMessage = other.ToastMessage;
				ToastDuration = other.ToastDuration;
				ToastFontSize = other.ToastFontSize;
				BannerTitle = other.BannerTitle;
				BannerHighlight = other.BannerHighlight;
				BannerContent = other.BannerContent;
				BannerExtraContent = other.BannerExtraContent;
				TitleFontSize = other.TitleFontSize;
				HighlightFontSize = other.HighlightFontSize;
				ContentFontSize = other.ContentFontSize;
				ExtraFontSize = other.ExtraFontSize;
				SoundType = other.SoundType;
				SoundVolume = other.SoundVolume;
				LastEditedBy = other.LastEditedBy;
				LastEditedTimestamp = other.LastEditedTimestamp;
				ScheduleEnabled = other.ScheduleEnabled;
				ScheduleInterval = other.ScheduleInterval;
				ScheduleToast = other.ScheduleToast;
				ScheduleBanner = other.ScheduleBanner;
			}
		}
	}
	public static class ModeratorContentManager
	{
		private static ModeratorSharedContent _sharedContent = new ModeratorSharedContent();

		private static string _saveFilePath = null;

		public static ModeratorSharedContent SharedContent => _sharedContent;

		public static void Initialize()
		{
			_saveFilePath = Path.Combine(Paths.ConfigPath, "ServerAnnouncements_ModeratorContent.json");
			LoadFromFile();
		}

		public static void OnServerStarted()
		{
			if (AnnouncementManager.IsHost() && _sharedContent.ScheduleEnabled)
			{
				AnnouncementRouter.Instance.StartSharedScheduler();
			}
		}

		public static void UpdateContent(ModeratorSharedContent content, string editorSteamId, bool syncToOthers = true)
		{
			if (content == null)
			{
				return;
			}
			_sharedContent.CopyFrom(content);
			_sharedContent.SetLastEdited(editorSteamId);
			if (AnnouncementManager.IsHost())
			{
				SaveToFile();
				AnnouncementRouter.Instance.UpdateSharedSchedulerState();
				if (syncToOthers)
				{
					BroadcastContentSync();
				}
			}
		}

		public static void UpdateFromSync(string serializedData)
		{
			ModeratorSharedContent other = ModeratorSharedContent.Deserialize(serializedData);
			_sharedContent.CopyFrom(other);
		}

		public static void BroadcastContentSync()
		{
			if (AnnouncementManager.IsHost())
			{
				string serializedContent = _sharedContent.Serialize();
				CodeTalkerIntegration.BroadcastModeratorContentSync(serializedContent);
			}
		}

		public static void SendContentUpdateToHost()
		{
			if (AnnouncementManager.IsHost())
			{
				_sharedContent.SetLastEdited(PermissionHelper.GetLocalSteamId());
				SaveToFile();
				BroadcastContentSync();
			}
			else
			{
				string serializedContent = _sharedContent.Serialize();
				CodeTalkerIntegration.SendModeratorContentUpdate(serializedContent);
			}
		}

		private static void SaveToFile()
		{
			if (string.IsNullOrEmpty(_saveFilePath))
			{
				return;
			}
			try
			{
				string contents = _sharedContent.Serialize();
				File.WriteAllText(_saveFilePath, contents);
				ServerAnnouncementsPlugin.Log.LogDebug((object)("[ModeratorContent] Saved to " + _saveFilePath));
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("[ModeratorContent] Save error: " + ex.Message));
			}
		}

		private static void LoadFromFile()
		{
			if (string.IsNullOrEmpty(_saveFilePath) || !File.Exists(_saveFilePath))
			{
				return;
			}
			try
			{
				string data = File.ReadAllText(_saveFilePath);
				ModeratorSharedContent moderatorSharedContent = ModeratorSharedContent.Deserialize(data);
				if (moderatorSharedContent != null)
				{
					_sharedContent.CopyFrom(moderatorSharedContent);
					ServerAnnouncementsPlugin.Log.LogInfo((object)("[ModeratorContent] Loaded from file. Last edited by " + _sharedContent.LastEditedBy));
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("[ModeratorContent] Load error: " + ex.Message));
			}
		}

		public static void Clear()
		{
			_sharedContent = new ModeratorSharedContent();
		}
	}
	public static class AnnouncementConfig
	{
		public static ConfigEntry<bool> EnableNoticeSystem;

		public static ConfigEntry<string> BannerTitle;

		public static ConfigEntry<string> BannerHighlight;

		public static ConfigEntry<string> BannerContent;

		public static ConfigEntry<string> BannerExtraContent;

		public static ConfigEntry<int> NoticeVersion;

		public static ConfigEntry<bool> ShowToastOnJoin;

		public static ConfigEntry<bool> ShowBannerOnJoin;

		public static ConfigEntry<bool> ShowToastOnJoinSelf;

		public static ConfigEntry<bool> ShowBannerOnJoinSelf;

		public static ConfigEntry<string> JoinToastMessage;

		public static ConfigEntry<float> ToastDuration;

		public static ConfigEntry<bool> VanillaCompatMode;

		public static ConfigEntry<string> ModeratorSteamIds;

		public static ConfigEntry<float> BroadcastCooldown;

		public static ConfigEntry<bool> EnableScheduledAnnouncement;

		public static ConfigEntry<float> ScheduledAnnouncementInterval;

		public static ConfigEntry<bool> ScheduledAnnouncementToast;

		public static ConfigEntry<bool> ScheduledAnnouncementBanner;

		public static ConfigEntry<bool> ScheduledAnnouncementIncludeHost;

		public static ConfigEntry<bool> ScheduledAnnouncementPlaySound;

		public static ConfigEntry<int> ScheduledSoundIndex;

		public static ConfigEntry<float> ScheduledSoundVolume;

		public static ConfigEntry<bool> EnableNoticeDisplay;

		public static ConfigEntry<bool> PlayNoticeSound;

		public static ConfigEntry<int> NotificationSoundIndex;

		public static ConfigEntry<float> NotificationSoundVolume;

		public static ConfigEntry<bool> IgnoreNormalAnnouncementSound;

		public static ConfigEntry<bool> IgnoreScheduledAnnouncementSound;

		public static ConfigEntry<string> EasySettingsTab;

		public static ConfigEntry<KeyCode> SettingsWindowKey;

		public static ConfigEntry<int> BannerTitleFontSize;

		public static ConfigEntry<int> BannerHighlightFontSize;

		public static ConfigEntry<int> BannerContentFontSize;

		public static ConfigEntry<int> BannerExtraContentFontSize;

		public static ConfigEntry<int> ToastFontSize;

		private static ConfigFile _config;

		public static void Initialize(ConfigFile config)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Expected O, but got Unknown
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Expected O, but got Unknown
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Expected O, but got Unknown
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Expected O, but got Unknown
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Expected O, but got Unknown
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Expected O, but got Unknown
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Expected O, but got Unknown
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Expected O, but got Unknown
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Expected O, but got Unknown
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Expected O, but got Unknown
			_config = config;
			EnableNoticeSystem = config.Bind<bool>("Host", "EnableNoticeSystem", true, "Enable the server notice system (Host only)");
			BannerTitle = config.Bind<string>("Host", "BannerTitle", "Server Rules", "Title displayed on the notice banner");
			BannerHighlight = config.Bind<string>("Host", "BannerHighlight", "", "Highlighted content displayed before main content (visible to vanilla clients)");
			BannerContent = config.Bind<string>("Host", "BannerContent", "Welcome to the server!\nPlease follow the rules.", "Content displayed on the notice banner (supports \\n for new lines)");
			BannerExtraContent = config.Bind<string>("Host", "BannerExtraContent", "", "Additional content displayed below the main banner content (supports \\n for new lines)");
			NoticeVersion = config.Bind<int>("Host", "NoticeVersion", 1, new ConfigDescription("Increment to show banner again to all players", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 999), Array.Empty<object>()));
			ShowToastOnJoin = config.Bind<bool>("Host", "ShowToastOnJoin", true, "Show a toast message when players join the server");
			ShowBannerOnJoin = config.Bind<bool>("Host", "ShowBannerOnJoin", true, "Show the notice banner when players join the server");
			ShowToastOnJoinSelf = config.Bind<bool>("Host", "ShowToastOnJoinSelf", true, "Show a toast message to the host when hosting starts");
			ShowBannerOnJoinSelf = config.Bind<bool>("Host", "ShowBannerOnJoinSelf", true, "Show the notice banner to the host when hosting starts");
			JoinToastMessage = config.Bind<string>("Host", "JoinToastMessage", "Welcome to the server!", "Toast message shown when players join");
			ToastDuration = config.Bind<float>("Host", "ToastDuration", 5f, new ConfigDescription("How long toast messages display (seconds)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 30f), Array.Empty<object>()));
			VanillaCompatMode = config.Bind<bool>("Host", "VanillaCompatMode", true, "Also send notices as regular chat messages for players without the mod");
			ModeratorSteamIds = config.Bind<string>("Host", "ModeratorSteamIds", "", "Comma-separated list of Steam IDs that have moderator permissions (can send announcements). Example: 76561198012345678,76561198087654321");
			BroadcastCooldown = config.Bind<float>("Host", "BroadcastCooldown", 3f, new ConfigDescription("Minimum seconds between manual broadcasts (prevents spam)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 30f), Array.Empty<object>()));
			EnableScheduledAnnouncement = config.Bind<bool>("Host", "EnableScheduledAnnouncement", false, "Enable automatic scheduled announcements");
			ScheduledAnnouncementInterval = config.Bind<float>("Host", "ScheduledAnnouncementInterval", 300f, new ConfigDescription("Interval between scheduled announcements (seconds). Min 5s for testing, Max 24 hours.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 86400f), Array.Empty<object>()));
			ScheduledAnnouncementToast = config.Bind<bool>("Host", "ScheduledAnnouncementToast", true, "Send toast message in scheduled announcements");
			ScheduledAnnouncementBanner = config.Bind<bool>("Host", "ScheduledAnnouncementBanner", false, "Send banner in scheduled announcements");
			ScheduledAnnouncementIncludeHost = config.Bind<bool>("Host", "ScheduledAnnouncementIncludeHost", false, "Include host in scheduled announcements (if false, only clients receive)");
			ScheduledAnnouncementPlaySound = config.Bind<bool>("Host", "ScheduledAnnouncementPlaySound", false, "Play notification sound for scheduled announcements (separate from normal notice sound setting)");
			ScheduledSoundIndex = config.Bind<int>("Host", "ScheduledSoundIndex", 0, new ConfigDescription("Sound type for scheduled announcements", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 7), Array.Empty<object>()));
			ScheduledSoundVolume = config.Bind<float>("Host", "ScheduledSoundVolume", 0.5f, new ConfigDescription("Volume for scheduled announcement sounds", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			EnableNoticeDisplay = config.Bind<bool>("Client", "EnableNoticeDisplay", true, "Show server notices (disable to hide all notices)");
			PlayNoticeSound = config.Bind<bool>("Client", "PlayNoticeSound", true, "Play sound when notice appears");
			IgnoreNormalAnnouncementSound = config.Bind<bool>("Client", "IgnoreNormalAnnouncementSound", false, "Ignore sounds from normal (non-scheduled) announcements sent by host");
			IgnoreScheduledAnnouncementSound = config.Bind<bool>("Client", "IgnoreScheduledAnnouncementSound", false, "Ignore sounds from scheduled announcements sent by host");
			NotificationSoundIndex = config.Bind<int>("Client", "NotificationSoundIndex", 0, new ConfigDescription("Index of the sound to play for notifications (use Sound Test in settings to find)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			NotificationSoundVolume = config.Bind<float>("Client", "NotificationSoundVolume", 0.5f, new ConfigDescription("Volume of notification sounds", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			EasySettingsTab = config.Bind<string>("UI", "EasySettingsTab", "Moderation", "Which EasySettings tab to show this mod in (e.g., 'Moderation', 'Mods', or custom name). Empty = default Mods tab.");
			SettingsWindowKey = config.Bind<KeyCode>("UI", "SettingsWindowKey", (KeyCode)291, "Key to open/close the settings window. Default: F10");
			BannerTitleFontSize = config.Bind<int>("UI", "BannerTitleFontSize", 24, new ConfigDescription("Font size for banner title", (AcceptableValueBase)(object)new AcceptableValueRange<int>(12, 48), Array.Empty<object>()));
			BannerHighlightFontSize = config.Bind<int>("UI", "BannerHighlightFontSize", 18, new ConfigDescription("Font size for banner highlight content", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 36), Array.Empty<object>()));
			BannerContentFontSize = config.Bind<int>("UI", "BannerContentFontSize", 16, new ConfigDescription("Font size for banner content", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 36), Array.Empty<object>()));
			BannerExtraContentFontSize = config.Bind<int>("UI", "BannerExtraContentFontSize", 14, new ConfigDescription("Font size for banner extra content", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 36), Array.Empty<object>()));
			ToastFontSize = config.Bind<int>("UI", "ToastFontSize", 20, new ConfigDescription("Font size for toast messages", (AcceptableValueBase)(object)new AcceptableValueRange<int>(12, 36), Array.Empty<object>()));
		}

		public static void Reload()
		{
			ConfigFile config = _config;
			if (config != null)
			{
				config.Reload();
			}
		}
	}
	public struct DismissedBannerInfo
	{
		public int Version;

		public DateTime DismissedAt;
	}
	public class AnnouncementManager
	{
		private static AnnouncementManager _instance;

		private Dictionary<string, DismissedBannerInfo> _dismissedBanners = new Dictionary<string, DismissedBannerInfo>();

		private string _currentServerId;

		private const float DISMISS_DURATION_HOURS = 24f;

		private bool _receivedBannerThisSession = false;

		private bool _receivedToastThisSession = false;

		private bool? _lastBannerSoundOverride = null;

		private bool? _lastToastSoundOverride = null;

		private int _lastSoundType = 0;

		private float _lastSoundVolume = 0.5f;

		private bool _lastIsFromNetwork = false;

		private bool _lastIsScheduled = false;

		public static AnnouncementManager Instance => _instance ?? (_instance = new AnnouncementManager());

		public event Action<AnnouncementData> OnBannerReceived;

		public event Action<string, float, int> OnToastReceived;

		private AnnouncementManager()
		{
			LoadDismissedBanners();
		}

		public void SetCurrentServer(string serverId)
		{
			_currentServerId = serverId;
		}

		public void ClearCurrentServer()
		{
			_currentServerId = null;
			_receivedBannerThisSession = false;
			_receivedToastThisSession = false;
		}

		public bool IsBannerDismissed(int version)
		{
			if (string.IsNullOrEmpty(_currentServerId))
			{
				return false;
			}
			if (_dismissedBanners.TryGetValue(_currentServerId, out var value))
			{
				if (value.Version != version)
				{
					return false;
				}
				if ((DateTime.Now - value.DismissedAt).TotalHours >= 24.0)
				{
					return false;
				}
				return true;
			}
			return false;
		}

		public void DismissBanner(int version)
		{
			if (!string.IsNullOrEmpty(_currentServerId))
			{
				_dismissedBanners[_currentServerId] = new DismissedBannerInfo
				{
					Version = version,
					DismissedAt = DateTime.Now
				};
				SaveDismissedBanners();
			}
		}

		public void ResetAllAcknowledgments()
		{
			_dismissedBanners.Clear();
			SaveDismissedBanners();
		}

		public void HandleBannerReceived(AnnouncementData data, bool forceShow = false, bool? playSound = null, int soundType = -1, float soundVolume = -1f)
		{
			if (AnnouncementConfig.EnableNoticeDisplay.Value && (forceShow || !_receivedBannerThisSession) && (forceShow || !IsBannerDismissed(data.Version)))
			{
				_lastBannerSoundOverride = playSound;
				_lastSoundType = ((soundType >= 0) ? soundType : (AnnouncementConfig.NotificationSoundIndex?.Value ?? 0));
				_lastSoundVolume = ((soundVolume >= 0f) ? soundVolume : (AnnouncementConfig.NotificationSoundVolume?.Value ?? 0.5f));
				_lastIsFromNetwork = soundType >= 0;
				_lastIsScheduled = false;
				_receivedBannerThisSession = true;
				this.OnBannerReceived?.Invoke(data);
			}
		}

		public void HandleToastReceived(string message, float duration, int fontSize = 20, bool forceShow = false, bool? playSound = null, int soundType = -1, float soundVolume = -1f)
		{
			if (AnnouncementConfig.EnableNoticeDisplay.Value && (forceShow || !_receivedToastThisSession))
			{
				_lastToastSoundOverride = playSound;
				_lastSoundType = ((soundType >= 0) ? soundType : (AnnouncementConfig.NotificationSoundIndex?.Value ?? 0));
				_lastSoundVolume = ((soundVolume >= 0f) ? soundVolume : (AnnouncementConfig.NotificationSoundVolume?.Value ?? 0.5f));
				_lastIsFromNetwork = soundType >= 0;
				_lastIsScheduled = false;
				_receivedToastThisSession = true;
				this.OnToastReceived?.Invoke(message, duration, fontSize);
			}
		}

		public void SetLastIsScheduled(bool isScheduled)
		{
			_lastIsScheduled = isScheduled;
		}

		public bool ShouldPlayBannerSound()
		{
			if (_lastBannerSoundOverride.HasValue)
			{
				return _lastBannerSoundOverride.Value;
			}
			if (_lastIsFromNetwork && !IsHost())
			{
				if (_lastIsScheduled)
				{
					ConfigEntry<bool> ignoreScheduledAnnouncementSound = AnnouncementConfig.IgnoreScheduledAnnouncementSound;
					if (ignoreScheduledAnnouncementSound != null && ignoreScheduledAnnouncementSound.Value)
					{
						return false;
					}
				}
				if (!_lastIsScheduled)
				{
					ConfigEntry<bool> ignoreNormalAnnouncementSound = AnnouncementConfig.IgnoreNormalAnnouncementSound;
					if (ignoreNormalAnnouncementSound != null && ignoreNormalAnnouncementSound.Value)
					{
						return false;
					}
				}
			}
			return AnnouncementConfig.PlayNoticeSound?.Value ?? true;
		}

		public bool ShouldPlayToastSound()
		{
			if (_lastToastSoundOverride.HasValue)
			{
				return _lastToastSoundOverride.Value;
			}
			if (_lastIsFromNetwork && !IsHost())
			{
				if (_lastIsScheduled)
				{
					ConfigEntry<bool> ignoreScheduledAnnouncementSound = AnnouncementConfig.IgnoreScheduledAnnouncementSound;
					if (ignoreScheduledAnnouncementSound != null && ignoreScheduledAnnouncementSound.Value)
					{
						return false;
					}
				}
				if (!_lastIsScheduled)
				{
					ConfigEntry<bool> ignoreNormalAnnouncementSound = AnnouncementConfig.IgnoreNormalAnnouncementSound;
					if (ignoreNormalAnnouncementSound != null && ignoreNormalAnnouncementSound.Value)
					{
						return false;
					}
				}
			}
			return AnnouncementConfig.PlayNoticeSound?.Value ?? true;
		}

		public int GetLastSoundType()
		{
			return _lastSoundType;
		}

		public float GetLastSoundVolume()
		{
			return _lastSoundVolume;
		}

		private void LoadDismissedBanners()
		{
			try
			{
				string @string = PlayerPrefs.GetString("ServerAnnouncements_DismissedBanners", "");
				if (string.IsNullOrEmpty(@string))
				{
					return;
				}
				string[] array = @string.Split(new char[1] { ';' });
				string[] array2 = array;
				foreach (string text in array2)
				{
					string[] array3 = text.Split(new char[1] { '|' });
					if (array3.Length == 3 && int.TryParse(array3[1], out var result) && long.TryParse(array3[2], out var result2))
					{
						_dismissedBanners[array3[0]] = new DismissedBannerInfo
						{
							Version = result,
							DismissedAt = new DateTime(result2)
						};
					}
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("Failed to load dismissed banners: " + ex.Message));
			}
		}

		private void SaveDismissedBanners()
		{
			try
			{
				List<string> list = new List<string>();
				foreach (KeyValuePair<string, DismissedBannerInfo> dismissedBanner in _dismissedBanners)
				{
					list.Add($"{dismissedBanner.Key}|{dismissedBanner.Value.Version}|{dismissedBanner.Value.DismissedAt.Ticks}");
				}
				PlayerPrefs.SetString("ServerAnnouncements_DismissedBanners", string.Join(";", list));
				PlayerPrefs.Save();
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("Failed to save dismissed banners: " + ex.Message));
			}
		}

		public static bool IsHost()
		{
			return NetworkServer.active && (Object)(object)Player._mainPlayer != (Object)null && Player._mainPlayer._isHostPlayer;
		}

		public static string GetServerIdentifier()
		{
			if (NetworkClient.active && NetworkClient.connection != null)
			{
				return $"server_{NetworkClient.connection.connectionId}";
			}
			return "local";
		}
	}
	public struct AnnouncementData
	{
		public string Title;

		public string Highlight;

		public string Content;

		public string ExtraContent;

		public int Version;

		public string ServerName;

		public int TitleFontSize;

		public int HighlightFontSize;

		public int ContentFontSize;

		public int ExtraContentFontSize;

		public AnnouncementData(string title, string content, int version, string serverName = "", int titleFontSize = 24, int contentFontSize = 16, string extraContent = "", int extraContentFontSize = 14, string highlight = "", int highlightFontSize = 18)
		{
			Title = title;
			Highlight = highlight;
			Content = content;
			ExtraContent = extraContent;
			Version = version;
			ServerName = serverName;
			TitleFontSize = titleFontSize;
			HighlightFontSize = highlightFontSize;
			ContentFontSize = contentFontSize;
			ExtraContentFontSize = extraContentFontSize;
		}
	}
	public enum PermissionLevel
	{
		Client,
		Moderator,
		Host
	}
	public static class PermissionHelper
	{
		private static HashSet<string> _moderatorCache = null;

		private static string _lastModeratorConfig = null;

		private static HashSet<string> _syncedModeratorList = new HashSet<string>();

		private static bool _hasSyncedList = false;

		public static bool HasSyncedList => _hasSyncedList;

		public static PermissionLevel GetCurrentPermission()
		{
			if (AnnouncementManager.IsHost())
			{
				return PermissionLevel.Host;
			}
			string localSteamId = GetLocalSteamId();
			if (!string.IsNullOrEmpty(localSteamId) && IsModerator(localSteamId))
			{
				return PermissionLevel.Moderator;
			}
			return PermissionLevel.Client;
		}

		public static bool IsModerator(string steamId)
		{
			if (string.IsNullOrEmpty(steamId))
			{
				return false;
			}
			if (AnnouncementManager.IsHost())
			{
				RefreshCacheIfNeeded();
				return _moderatorCache.Contains(steamId.Trim());
			}
			return _syncedModeratorList.Contains(steamId.Trim());
		}

		public static void UpdateSyncedModeratorList(IEnumerable<string> moderatorIds)
		{
			_syncedModeratorList.Clear();
			if (moderatorIds != null)
			{
				foreach (string moderatorId in moderatorIds)
				{
					if (!string.IsNullOrEmpty(moderatorId))
					{
						_syncedModeratorList.Add(moderatorId.Trim());
					}
				}
			}
			_hasSyncedList = true;
		}

		public static void ClearSyncedModeratorList()
		{
			_syncedModeratorList.Clear();
			_hasSyncedList = false;
		}

		public static bool CanSendAnnouncements()
		{
			return GetCurrentPermission() >= PermissionLevel.Moderator;
		}

		public static bool CanDelegatePermissions()
		{
			return GetCurrentPermission() >= PermissionLevel.Host;
		}

		public static string GetLocalSteamId()
		{
			try
			{
				Player mainPlayer = Player._mainPlayer;
				if ((Object)(object)mainPlayer != (Object)null)
				{
					return mainPlayer._steamID ?? "";
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogDebug((object)("[PermissionHelper] Failed to get local Steam ID: " + ex.Message));
			}
			return "";
		}

		public static List<string> GetModeratorList()
		{
			RefreshCacheIfNeeded();
			return _moderatorCache.ToList();
		}

		public static bool AddModerator(string steamId)
		{
			if (string.IsNullOrEmpty(steamId))
			{
				return false;
			}
			steamId = steamId.Trim();
			if (!IsValidSteamId(steamId))
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("[PermissionHelper] Invalid Steam ID format: " + steamId));
				return false;
			}
			RefreshCacheIfNeeded();
			if (_moderatorCache.Contains(steamId))
			{
				return false;
			}
			_moderatorCache.Add(steamId);
			SaveModeratorList();
			ServerAnnouncementsPlugin.Log.LogInfo((object)("[PermissionHelper] Added moderator: " + steamId));
			return true;
		}

		public static bool RemoveModerator(string steamId)
		{
			if (string.IsNullOrEmpty(steamId))
			{
				return false;
			}
			steamId = steamId.Trim();
			RefreshCacheIfNeeded();
			if (!_moderatorCache.Contains(steamId))
			{
				return false;
			}
			_moderatorCache.Remove(steamId);
			SaveModeratorList();
			ServerAnnouncementsPlugin.Log.LogInfo((object)("[PermissionHelper] Removed moderator: " + steamId));
			return true;
		}

		public static bool IsValidSteamId(string steamId)
		{
			if (string.IsNullOrEmpty(steamId))
			{
				return false;
			}
			steamId = steamId.Trim();
			if (steamId.Length != 17)
			{
				return false;
			}
			if (!steamId.StartsWith("7656"))
			{
				return false;
			}
			return steamId.All(char.IsDigit);
		}

		public static string GetPermissionName(PermissionLevel level)
		{
			return level switch
			{
				PermissionLevel.Host => "Host", 
				PermissionLevel.Moderator => "Moderator", 
				_ => "Client", 
			};
		}

		private static void RefreshCacheIfNeeded()
		{
			string text = AnnouncementConfig.ModeratorSteamIds?.Value ?? "";
			if (_moderatorCache != null && !(_lastModeratorConfig != text))
			{
				return;
			}
			_moderatorCache = new HashSet<string>();
			_lastModeratorConfig = text;
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string[] array = text.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				string text3 = text2.Trim();
				if (!string.IsNullOrEmpty(text3))
				{
					_moderatorCache.Add(text3);
				}
			}
		}

		private static void SaveModeratorList()
		{
			if (AnnouncementConfig.ModeratorSteamIds != null)
			{
				string text = string.Join(",", _moderatorCache);
				AnnouncementConfig.ModeratorSteamIds.Value = text;
				_lastModeratorConfig = text;
			}
			BroadcastModeratorSync();
		}

		public static void BroadcastModeratorSync()
		{
			if (AnnouncementManager.IsHost())
			{
				RefreshCacheIfNeeded();
				string moderatorList = string.Join(",", _moderatorCache);
				CodeTalkerIntegration.BroadcastPermissionSync(moderatorList);
			}
		}

		public static void ClearCache()
		{
			_moderatorCache = null;
			_lastModeratorConfig = null;
			_syncedModeratorList.Clear();
			_hasSyncedList = false;
		}
	}
	public enum NotificationSoundType
	{
		None,
		Slap,
		LowHealthWarning,
		LexiconBell,
		PartyInvite,
		TriggerMessage,
		Lockout,
		ErrorPrompt
	}
	public static class SoundHelper
	{
		private static AudioSource _cachedAudioSource;

		private static Dictionary<NotificationSoundType, AudioClip> _soundClips = new Dictionary<NotificationSoundType, AudioClip>();

		private static bool _initialized = false;

		private static List<NotificationSoundType> _availableSounds = new List<NotificationSoundType>();

		private static string[] _availableSoundNames = null;

		private static readonly Dictionary<NotificationSoundType, string[]> SoundFieldNames = new Dictionary<NotificationSoundType, string[]>
		{
			{
				NotificationSoundType.Slap,
				new string[1] { "_slap" }
			},
			{
				NotificationSoundType.LowHealthWarning,
				new string[1] { "_lowHealthWarning" }
			},
			{
				NotificationSoundType.LexiconBell,
				new string[1] { "_lexiconBell" }
			},
			{
				NotificationSoundType.PartyInvite,
				new string[1] { "_partyInviteSfx" }
			},
			{
				NotificationSoundType.TriggerMessage,
				new string[1] { "_triggerMessageTone" }
			},
			{
				NotificationSoundType.Lockout,
				new string[2] { "lockout", "_lockout" }
			},
			{
				NotificationSoundType.ErrorPrompt,
				new string[3] { "ui_errorPrompt", "_errorPrompt", "_ui_errorPrompt" }
			}
		};

		private static readonly Dictionary<NotificationSoundType, string> SoundDisplayNames = new Dictionary<NotificationSoundType, string>
		{
			{
				NotificationSoundType.None,
				"None (Silent)"
			},
			{
				NotificationSoundType.Slap,
				"Slap"
			},
			{
				NotificationSoundType.LowHealthWarning,
				"Low Health Warning"
			},
			{
				NotificationSoundType.LexiconBell,
				"Lexicon Bell"
			},
			{
				NotificationSoundType.PartyInvite,
				"Party Invite"
			},
			{
				NotificationSoundType.TriggerMessage,
				"Trigger Message"
			},
			{
				NotificationSoundType.Lockout,
				"Lockout"
			},
			{
				NotificationSoundType.ErrorPrompt,
				"Error Prompt"
			}
		};

		public static int AvailableSoundCount => _availableSounds?.Count ?? 1;

		public static int SoundCount => Enum.GetValues(typeof(NotificationSoundType)).Length;

		public static List<NotificationSoundType> GetAvailableSounds()
		{
			EnsureInitialized();
			return _availableSounds;
		}

		public static string[] GetAvailableSoundNames()
		{
			EnsureInitialized();
			if (_availableSoundNames == null)
			{
				List<string> list = new List<string>();
				foreach (NotificationSoundType availableSound in _availableSounds)
				{
					list.Add(SoundDisplayNames.TryGetValue(availableSound, out var value) ? value : availableSound.ToString());
				}
				_availableSoundNames = list.ToArray();
			}
			return _availableSoundNames;
		}

		public static NotificationSoundType GetSoundTypeByAvailableIndex(int availableIndex)
		{
			EnsureInitialized();
			if (availableIndex >= 0 && availableIndex < _availableSounds.Count)
			{
				return _availableSounds[availableIndex];
			}
			return NotificationSoundType.None;
		}

		public static int GetAvailableIndexForSoundType(NotificationSoundType soundType)
		{
			EnsureInitialized();
			return _availableSounds.IndexOf(soundType);
		}

		public static void PlaySound(NotificationSoundType soundType, float volume = 0.5f)
		{
			if (soundType == NotificationSoundType.None)
			{
				return;
			}
			EnsureInitialized();
			if (!_soundClips.TryGetValue(soundType, out var value) || (Object)(object)value == (Object)null)
			{
				FindSoundClip(soundType);
				_soundClips.TryGetValue(soundType, out value);
			}
			if ((Object)(object)value == (Object)null)
			{
				ServerAnnouncementsPlugin.Log.LogDebug((object)$"[SoundHelper] Sound clip not found for {soundType}");
				return;
			}
			AudioSource audioSource = GetAudioSource();
			if ((Object)(object)audioSource != (Object)null)
			{
				audioSource.PlayOneShot(value, volume);
			}
		}

		public static void PlayNotificationSound()
		{
			int soundType = AnnouncementConfig.NotificationSoundIndex?.Value ?? 0;
			float volume = AnnouncementConfig.NotificationSoundVolume?.Value ?? 0.5f;
			PlaySound((NotificationSoundType)soundType, volume);
		}

		public static void PlaySoundByIndex(int index, float volume)
		{
			if (index >= 0 && index < SoundCount)
			{
				PlaySound((NotificationSoundType)index, volume);
			}
		}

		public static void RefreshSounds()
		{
			_initialized = false;
			_soundClips.Clear();
			_availableSounds.Clear();
			_availableSoundNames = null;
			EnsureInitialized();
		}

		private static void EnsureInitialized()
		{
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			_availableSounds.Clear();
			_availableSoundNames = null;
			_availableSounds.Add(NotificationSoundType.None);
			try
			{
				foreach (NotificationSoundType value in Enum.GetValues(typeof(NotificationSoundType)))
				{
					if (value != 0)
					{
						FindSoundClip(value);
						if (_soundClips.ContainsKey(value) && (Object)(object)_soundClips[value] != (Object)null)
						{
							_availableSounds.Add(value);
						}
					}
				}
				ServerAnnouncementsPlugin.Log.LogDebug((object)$"[SoundHelper] Initialized. Found {_soundClips.Count} sounds.");
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("[SoundHelper] Init error: " + ex.Message));
			}
		}

		private static void FindSoundClip(NotificationSoundType soundType)
		{
			if (!SoundFieldNames.TryGetValue(soundType, out var value))
			{
				return;
			}
			MonoBehaviour[] array = Object.FindObjectsOfType<MonoBehaviour>();
			MonoBehaviour[] array2 = array;
			foreach (MonoBehaviour val in array2)
			{
				Type type = ((object)val).GetType();
				string[] array3 = value;
				foreach (string name in array3)
				{
					FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null && field.FieldType == typeof(AudioClip))
					{
						object? value2 = field.GetValue(val);
						AudioClip val2 = (AudioClip)((value2 is AudioClip) ? value2 : null);
						if ((Object)(object)val2 != (Object)null)
						{
							_soundClips[soundType] = val2;
							return;
						}
					}
				}
			}
		}

		private static AudioSource GetAudioSource()
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			if ((Object)(object)_cachedAudioSource != (Object)null && (Object)(object)((Component)_cachedAudioSource).gameObject != (Object)null)
			{
				return _cachedAudioSource;
			}
			ActionBarManager val = Object.FindObjectOfType<ActionBarManager>();
			if ((Object)(object)val != (Object)null)
			{
				FieldInfo field = ((object)val).GetType().GetField("_aSrc", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					object? value = field.GetValue(val);
					_cachedAudioSource = (AudioSource)((value is AudioSource) ? value : null);
					if ((Object)(object)_cachedAudioSource != (Object)null)
					{
						return _cachedAudioSource;
					}
				}
			}
			AudioSource[] array = Object.FindObjectsOfType<AudioSource>();
			if (array.Length != 0)
			{
				_cachedAudioSource = array[0];
				return _cachedAudioSource;
			}
			GameObject val2 = new GameObject("ServerNotice_AudioSource");
			Object.DontDestroyOnLoad((Object)(object)val2);
			_cachedAudioSource = val2.AddComponent<AudioSource>();
			return _cachedAudioSource;
		}

		public static void ClearCache()
		{
			_cachedAudioSource = null;
			_initialized = false;
			_soundClips.Clear();
			_availableSounds.Clear();
			_availableSoundNames = null;
		}
	}
	public class AnnouncementRouter
	{
		[CompilerGenerated]
		private sealed class <HandshakeAndNotifyCoroutine>d__33 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public int connectionId;

			public AnnouncementRouter <>4__this;

			private PlayerInfo <player>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HandshakeAndNotifyCoroutine>d__33(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<player>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<player>5__1 = PlayerTypeManager.GetPlayer(connectionId);
					if (<player>5__1 == null)
					{
						return false;
					}
					<>4__this._modClientChannel.SendHandshake(connectionId);
					PlayerTypeManager.MarkHandshakeSent(connectionId);
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					PlayerTypeManager.CheckHandshakeTimeouts();
					<player>5__1 = PlayerTypeManager.GetPlayer(connectionId);
					if (<player>5__1 == null)
					{
						return false;
					}
					if (AnnouncementConfig.EnableNoticeSystem.Value)
					{
						<>4__this.SendAnnouncementsToPlayer(connectionId);
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SchedulerCoroutine>d__22 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AnnouncementRouter <>4__this;

			private float <interval>5__1;

			private bool <sendToast>5__2;

			private bool <sendBanner>5__3;

			private bool <includeHost>5__4;

			private bool <playSound>5__5;

			private int <schedSoundType>5__6;

			private float <schedSoundVolume>5__7;

			private string <message>5__8;

			private float <duration>5__9;

			private int <fontSize>5__10;

			private AnnouncementData <data>5__11;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SchedulerCoroutine>d__22(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<message>5__8 = null;
				<data>5__11 = default(AnnouncementData);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this._lastScheduledTime = Time.time;
					break;
				case 1:
				{
					<>1__state = -1;
					ConfigEntry<bool> enableScheduledAnnouncement = AnnouncementConfig.EnableScheduledAnnouncement;
					if (enableScheduledAnnouncement == null || !enableScheduledAnnouncement.Value || !AnnouncementManager.IsHost() || !NetworkServer.active)
					{
						break;
					}
					<interval>5__1 = AnnouncementConfig.ScheduledAnnouncementInterval?.Value ?? 300f;
					if (Time.time - <>4__this._lastScheduledTime < <interval>5__1)
					{
						break;
					}
					<>4__this._lastScheduledTime = Time.time;
					<sendToast>5__2 = AnnouncementConfig.ScheduledAnnouncementToast?.Value ?? true;
					<sendBanner>5__3 = AnnouncementConfig.ScheduledAnnouncementBanner?.Value ?? false;
					<includeHost>5__4 = AnnouncementConfig.ScheduledAnnouncementIncludeHost?.Value ?? false;
					<playSound>5__5 = AnnouncementConfig.ScheduledAnnouncementPlaySound?.Value ?? false;
					<schedSoundType>5__6 = AnnouncementConfig.ScheduledSoundIndex?.Value ?? 0;
					<schedSoundVolume>5__7 = AnnouncementConfig.ScheduledSoundVolume?.Value ?? 0.5f;
					if (<sendToast>5__2)
					{
						<message>5__8 = AnnouncementConfig.JoinToastMessage?.Value ?? "Server Announcement";
						<duration>5__9 = AnnouncementConfig.ToastDuration?.Value ?? 5f;
						<fontSize>5__10 = AnnouncementConfig.ToastFontSize?.Value ?? 20;
						<>4__this.BroadcastScheduledToast(<message>5__8, <duration>5__9, <fontSize>5__10, <schedSoundType>5__6, <schedSoundVolume>5__7);
						if (<includeHost>5__4)
						{
							<>4__this._hostChannel.SendToastWithSoundOption(<message>5__8, <duration>5__9, <fontSize>5__10, force: true, <playSound>5__5);
						}
						<message>5__8 = null;
					}
					if (<sendBanner>5__3)
					{
						<data>5__11 = <>4__this.CreateBannerData();
						<>4__this.BroadcastScheduledBanner(<data>5__11, <schedSoundType>5__6, <schedSoundVolume>5__7);
						if (<includeHost>5__4)
						{
							<>4__this._hostChannel.SendBannerWithSoundOption(<data>5__11, force: true, <playSound>5__5);
						}
						<data>5__11 = default(AnnouncementData);
					}
					ServerAnnouncementsPlugin.Log.LogDebug((object)$"[Router] Scheduled announcement sent. Toast: {<sendToast>5__2}, Banner: {<sendBanner>5__3}, IncludeHost: {<includeHost>5__4}, PlaySound: {<playSound>5__5}");
					break;
				}
				}
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SharedSchedulerCoroutine>d__30 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AnnouncementRouter <>4__this;

			private ModeratorSharedContent <content>5__1;

			private float <interval>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SharedSchedulerCoroutine>d__30(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<content>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this._lastSharedScheduledTime = Time.time;
					break;
				case 1:
					<>1__state = -1;
					<content>5__1 = ModeratorContentManager.SharedContent;
					if (!<content>5__1.ScheduleEnabled || !AnnouncementManager.IsHost() || !NetworkServer.active)
					{
						break;
					}
					<interval>5__2 = <content>5__1.ScheduleInterval;
					if (<interval>5__2 < 5f)
					{
						<interval>5__2 = 5f;
					}
					if (!(Time.time - <>4__this._lastSharedScheduledTime < <interval>5__2))
					{
						<>4__this._lastSharedScheduledTime = Time.time;
						if (<content>5__1.ScheduleToast)
						{
							<>4__this.BroadcastScheduledToast(<content>5__1.ToastMessage, <content>5__1.ToastDuration, <content>5__1.ToastFontSize, <content>5__1.SoundType, <content>5__1.SoundVolume);
						}
						if (<content>5__1.ScheduleBanner)
						{
							<>4__this.BroadcastSharedBanner(force: true, bypassRateLimit: true);
						}
						ServerAnnouncementsPlugin.Log.LogDebug((object)$"[Router] Shared scheduled announcement sent. Toast: {<content>5__1.ScheduleToast}, Banner: {<content>5__1.ScheduleBanner}");
						<content>5__1 = null;
					}
					break;
				}
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static AnnouncementRouter _instance;

		private readonly HostChannel _hostChannel;

		private readonly ModClientChannel _modClientChannel;

		private readonly VanillaClientChannel _vanillaClientChannel;

		private float _lastBroadcastTime = 0f;

		private float _lastScheduledTime = 0f;

		private bool _schedulerRunning = false;

		private Coroutine _schedulerCoroutine = null;

		private float _lastSharedScheduledTime = 0f;

		private bool _sharedSchedulerRunning = false;

		private Coroutine _sharedSchedulerCoroutine = null;

		private bool _hostReceivedThisSession = false;

		public static AnnouncementRouter Instance => _instance ?? (_instance = new AnnouncementRouter());

		public bool IsSchedulerRunning => _schedulerRunning;

		public bool IsSharedSchedulerRunning => _sharedSchedulerRunning;

		private AnnouncementRouter()
		{
			_hostChannel = new HostChannel();
			_modClientChannel = new ModClientChannel();
			_vanillaClientChannel = new VanillaClientChannel();
		}

		public void ResetSession()
		{
			_hostReceivedThisSession = false;
			PlayerTypeManager.Reset();
			StopScheduler();
			StopSharedScheduler();
		}

		public void StartScheduler()
		{
			if (!_schedulerRunning && !((Object)(object)ServerAnnouncementsPlugin.Instance == (Object)null))
			{
				_schedulerCoroutine = ((MonoBehaviour)ServerAnnouncementsPlugin.Instance).StartCoroutine(SchedulerCoroutine());
				_schedulerRunning = true;
				ServerAnnouncementsPlugin.Log.LogInfo((object)"[Router] Scheduled announcements started.");
				ModeratorContentManager.OnServerStarted();
			}
		}

		public void StopScheduler()
		{
			if (_schedulerRunning)
			{
				if (_schedulerCoroutine != null && (Object)(object)ServerAnnouncementsPlugin.Instance != (Object)null)
				{
					((MonoBehaviour)ServerAnnouncementsPlugin.Instance).StopCoroutine(_schedulerCoroutine);
					_schedulerCoroutine = null;
				}
				_schedulerRunning = false;
				ServerAnnouncementsPlugin.Log.LogInfo((object)"[Router] Scheduled announcements stopped.");
			}
		}

		public float GetTimeUntilNextAnnouncement()
		{
			if (!_schedulerRunning)
			{
				return -1f;
			}
			float num = AnnouncementConfig.ScheduledAnnouncementInterval?.Value ?? 300f;
			float num2 = Time.time - _lastScheduledTime;
			return Mathf.Max(0f, num - num2);
		}

		public void ResetSchedulerTimer()
		{
			_lastScheduledTime = Time.time;
		}

		[IteratorStateMachine(typeof(<SchedulerCoroutine>d__22))]
		private IEnumerator SchedulerCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SchedulerCoroutine>d__22(0)
			{
				<>4__this = this
			};
		}

		public void StartSharedScheduler()
		{
			if (!_sharedSchedulerRunning && !((Object)(object)ServerAnnouncementsPlugin.Instance == (Object)null))
			{
				_sharedSchedulerCoroutine = ((MonoBehaviour)ServerAnnouncementsPlugin.Instance).StartCoroutine(SharedSchedulerCoroutine());
				_sharedSchedulerRunning = true;
				ServerAnnouncementsPlugin.Log.LogInfo((object)"[Router] Shared content scheduler started.");
			}
		}

		public void StopSharedScheduler()
		{
			if (_sharedSchedulerRunning)
			{
				if (_sharedSchedulerCoroutine != null && (Object)(object)ServerAnnouncementsPlugin.Instance != (Object)null)
				{
					((MonoBehaviour)ServerAnnouncementsPlugin.Instance).StopCoroutine(_sharedSchedulerCoroutine);
					_sharedSchedulerCoroutine = null;
				}
				_sharedSchedulerRunning = false;
				ServerAnnouncementsPlugin.Log.LogInfo((object)"[Router] Shared content scheduler stopped.");
			}
		}

		public float GetTimeUntilNextSharedAnnouncement()
		{
			if (!_sharedSchedulerRunning)
			{
				return -1f;
			}
			ModeratorSharedContent sharedContent = ModeratorContentManager.SharedContent;
			float scheduleInterval = sharedContent.ScheduleInterval;
			float num = Time.time - _lastSharedScheduledTime;
			return Mathf.Max(0f, scheduleInterval - num);
		}

		public void ResetSharedSchedulerTimer()
		{
			_lastSharedScheduledTime = Time.time;
		}

		public void UpdateSharedSchedulerState()
		{
			ModeratorSharedContent sharedContent = ModeratorContentManager.SharedContent;
			if (sharedContent.ScheduleEnabled && !_sharedSchedulerRunning)
			{
				StartSharedScheduler();
			}
			else if (!sharedContent.ScheduleEnabled && _sharedSchedulerRunning)
			{
				StopSharedScheduler();
			}
		}

		[IteratorStateMachine(typeof(<SharedSchedulerCoroutine>d__30))]
		private IEnumerator SharedSchedulerCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SharedSchedulerCoroutine>d__30(0)
			{
				<>4__this = this
			};
		}

		public void HandlePlayerConnected(int connectionId, ulong steamId = 0uL)
		{
			if (AnnouncementManager.IsHost())
			{
				PlayerInfo playerInfo = PlayerTypeManager.RegisterPlayer(connectionId, steamId);
				if (playerInfo.Type != 0)
				{
					((MonoBehaviour)ServerAnnouncementsPlugin.Instance).StartCoroutine(HandshakeAndNotifyCoroutine(connectionId));
				}
			}
		}

		public void HandlePlayerDisconnected(int connectionId)
		{
			PlayerTypeManager.UnregisterPlayer(connectionId);
		}

		[IteratorStateMachine(typeof(<HandshakeAndNotifyCoroutine>d__33))]
		private IEnumerator HandshakeAndNotifyCoroutine(int connectionId)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HandshakeAndNotifyCoroutine>d__33(0)
			{
				<>4__this = this,
				connectionId = connectionId
			};
		}

		private void SendAnnouncementsToPlayer(int connectionId)
		{
			PlayerInfo player = PlayerTypeManager.GetPlayer(connectionId);
			if (player == null || player.NotificationSent)
			{
				return;
			}
			float duration = AnnouncementConfig.ToastDuration?.Value ?? 10f;
			int fontSize = AnnouncementConfig.ToastFontSize?.Value ?? 20;
			if (AnnouncementConfig.ShowToastOnJoin.Value)
			{
				string value = AnnouncementConfig.JoinToastMessage.Value;
				if (!string.IsNullOrEmpty(value))
				{
					_modClientChannel.SendToast(connectionId, value, duration, fontSize, force: false);
					if (AnnouncementConfig.VanillaCompatMode.Value)
					{
						_vanillaClientChannel.SendToast(connectionId, value, duration, fontSize, force: false);
					}
				}
			}
			if (AnnouncementConfig.ShowBannerOnJoin.Value)
			{
				AnnouncementData data = CreateBannerData();
				if (!string.IsNullOrEmpty(data.Title) || !string.IsNullOrEmpty(data.Content))
				{
					_modClientChannel.SendBanner(connectionId, data, force: false);
					if (AnnouncementConfig.VanillaCompatMode.Value)
					{
						_vanillaClientChannel.SendBanner(connectionId, data, force: false);
					}
				}
			}
			PlayerTypeManager.MarkNotified(connectionId);
		}

		public void BroadcastToast(string message, float duration, int fontSize, bool force = false, bool bypassRateLimit = false, bool skipLocalDisplay = false)
		{
			if (!NetworkServer.active)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"[Router] BroadcastToast called but server not active.");
				return;
			}
			if (!bypassRateLimit && !CheckRateLimit())
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"[Router] Broadcast rate limited.");
				return;
			}
			message = TruncateMessage(message);
			if (!skipLocalDisplay && (!_hostReceivedThisSession || force))
			{
				_hostChannel.SendToast(0, message, duration, fontSize, force);
				_hostReceivedThisSession = true;
			}
			foreach (PlayerInfo client in PlayerTypeManager.GetClients())
			{
				_modClientChannel.SendToast(client.ConnectionId, message, duration, fontSize, force);
				if (AnnouncementConfig.VanillaCompatMode.Value)
				{
					_vanillaClientChannel.SendToast(client.ConnectionId, message, duration, fontSize, force);
				}
			}
			_lastBroadcastTime = Time.time;
		}

		public void BroadcastBanner(bool force = false, bool bypassRateLimit = false, bool skipLocalDisplay = false)
		{
			if (!NetworkServer.active)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"[Router] BroadcastBanner called but server not active.");
				return;
			}
			if (!bypassRateLimit && !CheckRateLimit())
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"[Router] Broadcast rate limited.");
				return;
			}
			AnnouncementData data = CreateBannerData();
			if (string.IsNullOrEmpty(data.Title) && string.IsNullOrEmpty(data.Content))
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"[Router] Banner has no content, skipping.");
				return;
			}
			if (!skipLocalDisplay && (!_hostReceivedThisSession || force))
			{
				_hostChannel.SendBanner(0, data, force);
				_hostReceivedThisSession = true;
			}
			foreach (PlayerInfo client in PlayerTypeManager.GetClients())
			{
				_modClientChannel.SendBanner(client.ConnectionId, data, force);
				if (AnnouncementConfig.VanillaCompatMode.Value)
				{
					_vanillaClientChannel.SendBanner(client.ConnectionId, data, force);
				}
			}
			_lastBroadcastTime = Time.time;
		}

		public void BroadcastSharedBanner(bool force = true, bool bypassRateLimit = false)
		{
			if (!NetworkServer.active)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"[Router] BroadcastSharedBanner called but server not active.");
				return;
			}
			if (!bypassRateLimit && !CheckRateLimit())
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"[Router] Broadcast rate limited.");
				return;
			}
			ModeratorSharedContent sharedContent = ModeratorContentManager.SharedContent;
			AnnouncementData data = new AnnouncementData(sharedContent.BannerTitle, sharedContent.BannerContent, 1, "", sharedContent.TitleFontSize, sharedContent.ContentFontSize, sharedContent.BannerExtraContent, sharedContent.ExtraFontSize, sharedContent.BannerHighlight, sharedContent.HighlightFontSize);
			if (string.IsNullOrEmpty(data.Title) && string.IsNullOrEmpty(data.Content))
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)"[Router] Shared banner has no content, skipping.");
				return;
			}
			_hostChannel.SendBanner(0, data, force);
			foreach (PlayerInfo client in PlayerTypeManager.GetClients())
			{
				_modClientChannel.SendBanner(client.ConnectionId, data, force);
				if (AnnouncementConfig.VanillaCompatMode.Value)
				{
					_vanillaClientChannel.SendBanner(client.ConnectionId, data, force);
				}
			}
			_lastBroadcastTime = Time.time;
			ServerAnnouncementsPlugin.Log.LogDebug((object)"[Router] Shared banner broadcasted.");
		}

		private void BroadcastScheduledToast(string message, float duration, int fontSize, int soundType, float soundVolume)
		{
			if (!NetworkServer.active)
			{
				return;
			}
			message = TruncateMessage(message);
			foreach (PlayerInfo client in PlayerTypeManager.GetClients())
			{
				_modClientChannel.SendScheduledToast(client.ConnectionId, message, duration, fontSize, soundType, soundVolume);
				if (AnnouncementConfig.VanillaCompatMode.Value)
				{
					_vanillaClientChannel.SendToast(client.ConnectionId, message, duration, fontSize, force: true);
				}
			}
		}

		private void BroadcastScheduledBanner(AnnouncementData data, int soundType, float soundVolume)
		{
			if (!NetworkServer.active)
			{
				return;
			}
			foreach (PlayerInfo client in PlayerTypeManager.GetClients())
			{
				_modClientChannel.SendScheduledBanner(client.ConnectionId, data, soundType, soundVolume);
				if (AnnouncementConfig.VanillaCompatMode.Value)
				{
					_vanillaClientChannel.SendBanner(client.ConnectionId, data, force: true);
				}
			}
		}

		public void HandleClientHandshakeResponse(int connectionId, ulong steamId)
		{
			if (connectionId > 0)
			{
				PlayerTypeManager.HandleHandshakeResponse(connectionId, steamId);
			}
			else if (steamId != 0)
			{
				PlayerTypeManager.HandleHandshakeResponseBySteamId(steamId);
			}
		}

		private IAnnouncementChannel GetChannelForType(PlayerType type)
		{
			return type switch
			{
				PlayerType.Host => _hostChannel, 
				PlayerType.ModClient => _modClientChannel, 
				_ => _vanillaClientChannel, 
			};
		}

		private bool CheckRateLimit()
		{
			float num = AnnouncementConfig.BroadcastCooldown?.Value ?? 3f;
			return Time.time - _lastBroadcastTime >= num;
		}

		private string TruncateMessage(string message)
		{
			if (!string.IsNullOrEmpty(message) && message.Length > 1000)
			{
				return message.Substring(0, 1000);
			}
			return message ?? "";
		}

		private AnnouncementData CreateBannerData()
		{
			return new AnnouncementData(AnnouncementConfig.BannerTitle.Value ?? "", AnnouncementConfig.BannerContent.Value ?? "", AnnouncementConfig.NoticeVersion.Value, "", AnnouncementConfig.BannerTitleFontSize?.Value ?? 24, AnnouncementConfig.BannerContentFontSize?.Value ?? 16, AnnouncementConfig.BannerExtraContent?.Value ?? "", AnnouncementConfig.BannerExtraContentFontSize?.Value ?? 14, AnnouncementConfig.BannerHighlight?.Value ?? "", AnnouncementConfig.BannerHighlightFontSize?.Value ?? 18);
		}
	}
	public static class CodeTalkerIntegration
	{
		private static bool _initialized;

		private static bool _available;

		private static bool _uiInitialized;

		public static bool IsAvailable => _available;

		public static event Action<string, bool, string> OnModResponseReceived;

		public static event Action OnModeratorContentSynced;

		public static void Initialize()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			try
			{
				if (CodeTalkerNetwork.RegisterBinaryListener<AnnouncementBinaryPacket>(new BinaryPacketListener(OnPacketReceived)))
				{
					_available = true;
					ServerAnnouncementsPlugin.Log.LogInfo((object)"CodeTalker integration initialized successfully!");
				}
				else
				{
					ServerAnnouncementsPlugin.Log.LogWarning((object)"CodeTalker listener registration failed.");
					_available = false;
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("CodeTalker integration failed: " + ex.Message));
				_available = false;
			}
		}

		private static void EnsureUIInitialized()
		{
			if (_uiInitialized)
			{
				return;
			}
			try
			{
				AnnouncementToastUI.Initialize();
				AnnouncementBannerUI.Initialize();
				_uiInitialized = true;
				ServerAnnouncementsPlugin.Log.LogDebug((object)"UI components initialized via CodeTalker packet handler.");
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("EnsureUIInitialized error: " + ex.Message));
			}
		}

		private static void OnPacketReceived(PacketHeader header, BinaryPacketBase packet)
		{
			try
			{
				if (!(packet is AnnouncementBinaryPacket announcementBinaryPacket))
				{
					return;
				}
				if (announcementBinaryPacket.Type == "ClientResponse")
				{
					if (AnnouncementManager.IsHost())
					{
						ulong senderID = header.SenderID;
						if (senderID != 0)
						{
							PlayerTypeManager.HandleHandshakeResponseBySteamId(senderID);
							PermissionHelper.BroadcastModeratorSync();
							ModeratorContentManager.BroadcastContentSync();
						}
					}
				}
				else if (announcementBinaryPacket.Type == "ModRequest")
				{
					if (AnnouncementManager.IsHost())
					{
						ulong senderID2 = header.SenderID;
						string senderSteamId = senderID2.ToString();
						ProcessModeratorRequest(announcementBinaryPacket, senderSteamId);
					}
				}
				else if (announcementBinaryPacket.Type == "ModContentUpdate")
				{
					if (AnnouncementManager.IsHost())
					{
						ulong senderID2 = header.SenderID;
						string text = senderID2.ToString();
						if (PermissionHelper.IsModerator(text))
						{
							ProcessModeratorContentUpdate(announcementBinaryPacket, text);
							return;
						}
						ServerAnnouncementsPlugin.Log.LogWarning((object)("[ModContentUpdate] Permission denied for " + text));
						SendModResponse(announcementBinaryPacket.RequestId ?? "content-update", success: false, "Permission denied");
					}
				}
				else if (announcementBinaryPacket.Type == "ModResponse")
				{
					if (header.SenderIsLobbyOwner)
					{
						ProcessReceivedPacket(announcementBinaryPacket);
					}
				}
				else if (!header.SenderIsLobbyOwner)
				{
					ServerAnnouncementsPlugin.Log.LogWarning((object)("Received CodeTalker " + announcementBinaryPacket.Type + " from non-host, ignoring."));
				}
				else
				{
					ProcessReceivedPacket(announcementBinaryPacket);
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogError((object)("Error processing CodeTalker packet: " + ex.Message));
			}
		}

		private static void ProcessModeratorRequest(AnnouncementBinaryPacket packet, string senderSteamId)
		{
			if (!PermissionHelper.IsModerator(senderSteamId))
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("[ModRequest] Permission denied for " + senderSteamId));
				SendModResponse(packet.RequestId, success: false, "Permission denied");
				return;
			}
			try
			{
				string title = packet.Title;
				if (title == "Toast")
				{
					AnnouncementRouter.Instance.BroadcastToast(packet.Content, packet.Duration, packet.ToastFontSize, packet.ForceShow);
					SendModResponse(packet.RequestId, success: true, "");
				}
				else if (title == "Banner")
				{
					AnnouncementRouter.Instance.BroadcastSharedBanner();
					SendModResponse(packet.RequestId, success: true, "");
				}
				else
				{
					ServerAnnouncementsPlugin.Log.LogWarning((object)("[ModRequest] Unknown request type: " + title));
					SendModResponse(packet.RequestId, success: false, "Unknown request type: " + title);
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogError((object)("[ModRequest] Error: " + ex.Message));
				SendModResponse(packet.RequestId, success: false, ex.Message);
			}
		}

		private static void SendModResponse(string requestId, bool success, string errorMessage)
		{
			if (_available)
			{
				AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
				{
					Type = "ModResponse",
					RequestId = requestId,
					Success = success,
					ErrorMessage = (errorMessage ?? "")
				};
				SendPacket(packet);
			}
		}

		private static void ProcessReceivedPacket(AnnouncementBinaryPacket packet)
		{
			EnsureUIInitialized();
			switch (packet.Type)
			{
			case "Toast":
				AnnouncementManager.Instance?.HandleToastReceived(packet.Content, packet.Duration, packet.ToastFontSize, packet.ForceShow, null, packet.SoundType, packet.SoundVolume);
				break;
			case "Banner":
			{
				AnnouncementData data = new AnnouncementData(packet.Title, packet.Content, packet.Version, "", packet.TitleFontSize, packet.ContentFontSize, packet.ExtraContent, packet.ExtraFontSize, packet.Highlight, packet.HighlightFontSize);
				AnnouncementManager.Instance?.HandleBannerReceived(data, packet.ForceShow, null, packet.SoundType, packet.SoundVolume);
				break;
			}
			case "Handshake":
				AnnouncementNetworkHandler.HandleHandshake("ServerAnnouncements_v2_CT");
				SendClientResponse();
				break;
			case "ModResponse":
				HandleModResponse(packet);
				break;
			case "PermSync":
				HandlePermissionSync(packet);
				break;
			case "ModContentSync":
				HandleModeratorContentSync(packet);
				break;
			default:
				ServerAnnouncementsPlugin.Log.LogWarning((object)("Unknown announcement type: " + packet.Type));
				break;
			}
		}

		private static void HandlePermissionSync(AnnouncementBinaryPacket packet)
		{
			string text = packet.Content ?? "";
			string[] moderatorIds = text.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			PermissionHelper.UpdateSyncedModeratorList(moderatorIds);
		}

		private static void HandleModeratorContentSync(AnnouncementBinaryPacket packet)
		{
			string serializedData = packet.ExtraContent ?? "";
			ModeratorContentManager.UpdateFromSync(serializedData);
			CodeTalkerIntegration.OnModeratorContentSynced?.Invoke();
		}

		private static void ProcessModeratorContentUpdate(AnnouncementBinaryPacket packet, string senderSteamId)
		{
			string data = packet.ExtraContent ?? "";
			ModeratorSharedContent content = ModeratorSharedContent.Deserialize(data);
			ModeratorContentManager.UpdateContent(content, senderSteamId);
		}

		private static void HandleModResponse(AnnouncementBinaryPacket packet)
		{
			if (!packet.Success && packet.ErrorMessage != null && packet.ErrorMessage.Contains("Permission denied"))
			{
				PermissionHelper.ClearSyncedModeratorList();
			}
			CodeTalkerIntegration.OnModResponseReceived?.Invoke(packet.RequestId, packet.Success, packet.ErrorMessage);
		}

		private static bool SendPacket(AnnouncementBinaryPacket packet)
		{
			if (!_available)
			{
				return false;
			}
			try
			{
				CodeTalkerNetwork.SendNetworkPacket((BinaryPacketBase)(object)packet);
				return true;
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogError((object)("Failed to send CodeTalker packet: " + ex.Message));
				return false;
			}
		}

		public static bool BroadcastToast(string message, float duration, int fontSize, bool forceShow)
		{
			if (!_available)
			{
				return false;
			}
			AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
			{
				Type = "Toast",
				Content = (message ?? ""),
				Duration = duration,
				ToastFontSize = fontSize,
				ForceShow = forceShow
			};
			return SendPacket(packet);
		}

		public static bool BroadcastBanner(string title, string content, string extraContent, int version, int titleFontSize, int contentFontSize, int extraFontSize, bool forceShow)
		{
			if (!_available)
			{
				return false;
			}
			AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
			{
				Type = "Banner",
				Title = (title ?? ""),
				Content = (content ?? ""),
				ExtraContent = (extraContent ?? ""),
				Version = version,
				TitleFontSize = titleFontSize,
				ContentFontSize = contentFontSize,
				ExtraFontSize = extraFontSize,
				ForceShow = forceShow
			};
			return SendPacket(packet);
		}

		public static bool SendHandshake()
		{
			if (!_available)
			{
				return false;
			}
			AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
			{
				Type = "Handshake",
				Content = "ServerAnnouncements_v1"
			};
			return SendPacket(packet);
		}

		public static bool SendClientResponse()
		{
			if (!_available)
			{
				return false;
			}
			int num = -1;
			try
			{
				if (NetworkClient.connection != null)
				{
					num = NetworkClient.connection.connectionId;
				}
			}
			catch
			{
			}
			AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
			{
				Type = "ClientResponse",
				Content = num.ToString()
			};
			return SendPacket(packet);
		}

		public static string SendModRequest(string requestType, string message, float duration, int fontSize, bool forceShow)
		{
			if (!_available)
			{
				return null;
			}
			if (!PermissionHelper.CanSendAnnouncements())
			{
				return null;
			}
			string text = Guid.NewGuid().ToString("N").Substring(0, 8);
			AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
			{
				Type = "ModRequest",
				Title = requestType,
				Content = (message ?? ""),
				Duration = duration,
				ToastFontSize = fontSize,
				ForceShow = forceShow,
				RequestId = text
			};
			if (SendPacket(packet))
			{
				return text;
			}
			return null;
		}

		public static bool BroadcastPermissionSync(string moderatorList)
		{
			if (!_available)
			{
				return false;
			}
			if (!AnnouncementManager.IsHost())
			{
				return false;
			}
			AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
			{
				Type = "PermSync",
				Content = (moderatorList ?? "")
			};
			return SendPacket(packet);
		}

		public static bool BroadcastModeratorContentSync(string serializedContent)
		{
			if (!_available)
			{
				return false;
			}
			if (!AnnouncementManager.IsHost())
			{
				return false;
			}
			AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
			{
				Type = "ModContentSync",
				ExtraContent = (serializedContent ?? "")
			};
			return SendPacket(packet);
		}

		public static bool SendModeratorContentUpdate(string serializedContent)
		{
			if (!_available)
			{
				return false;
			}
			if (!PermissionHelper.CanSendAnnouncements())
			{
				return false;
			}
			AnnouncementBinaryPacket packet = new AnnouncementBinaryPacket
			{
				Type = "ModContentUpdate",
				ExtraContent = (serializedContent ?? "")
			};
			return SendPacket(packet);
		}
	}
	public class AnnouncementBinaryPacket : BinaryPacketBase
	{
		public override string PacketSignature => "SA_ANN_v2";

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


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


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


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


		public int Version { get; set; }

		public float Duration { get; set; }

		public int TitleFontSize { get; set; }

		public int ContentFontSize { get; set; }

		public int ExtraFontSize { get; set; }

		public int ToastFontSize { get; set; }

		public bool ForceShow { get; set; }

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


		public bool Success { get; set; }

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


		public int SoundType { get; set; }

		public float SoundVolume { get; set; } = 0.5f;


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


		public int HighlightFontSize { get; set; }

		public override byte[] Serialize()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(EscapePipe(Type));
			stringBuilder.Append("|");
			stringBuilder.Append(EscapePipe(Title));
			stringBuilder.Append("|");
			stringBuilder.Append(EscapePipe(Content));
			stringBuilder.Append("|");
			stringBuilder.Append(EscapePipe(ExtraContent));
			stringBuilder.Append("|");
			stringBuilder.Append(Version);
			stringBuilder.Append("|");
			stringBuilder.Append(Duration.ToString("F2"));
			stringBuilder.Append("|");
			stringBuilder.Append(TitleFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(ContentFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(ExtraFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(ToastFontSize);
			stringBuilder.Append("|");
			stringBuilder.Append(ForceShow ? "1" : "0");
			stringBuilder.Append("|");
			stringBuilder.Append(EscapePipe(RequestId));
			stringBuilder.Append("|");
			stringBuilder.Append(Success ? "1" : "0");
			stringBuilder.Append("|");
			stringBuilder.Append(EscapePipe(ErrorMessage));
			stringBuilder.Append("|");
			stringBuilder.Append(SoundType);
			stringBuilder.Append("|");
			stringBuilder.Append(SoundVolume.ToString("F2"));
			stringBuilder.Append("|");
			stringBuilder.Append(EscapePipe(Highlight));
			stringBuilder.Append("|");
			stringBuilder.Append(HighlightFontSize);
			return Encoding.UTF8.GetBytes(stringBuilder.ToString());
			static string EscapePipe(string s)
			{
				return (s ?? "").Replace("|", "\\|").Replace("\n", "\\n");
			}
		}

		public override void Deserialize(byte[] data)
		{
			try
			{
				string @string = Encoding.UTF8.GetString(data);
				string[] array = SplitByUnescapedPipe(@string);
				if (array.Length >= 11)
				{
					Type = UnescapePipe(array[0]);
					Title = UnescapePipe(array[1]);
					Content = UnescapePipe(array[2]);
					ExtraContent = UnescapePipe(array[3]);
					int.TryParse(array[4], out var result);
					Version = result;
					float.TryParse(array[5], out var result2);
					Duration = result2;
					int.TryParse(array[6], out var result3);
					TitleFontSize = result3;
					int.TryParse(array[7], out var result4);
					ContentFontSize = result4;
					int.TryParse(array[8], out var result5);
					ExtraFontSize = result5;
					int.TryParse(array[9], out var result6);
					ToastFontSize = result6;
					ForceShow = array[10] == "1";
				}
				if (array.Length >= 18)
				{
					RequestId = UnescapePipe(array[11]);
					Success = array[12] == "1";
					ErrorMessage = UnescapePipe(array[13]);
					int.TryParse(array[14], out var result7);
					SoundType = result7;
					float.TryParse(array[15], out var result8);
					SoundVolume = result8;
					Highlight = UnescapePipe(array[16]);
					int.TryParse(array[17], out var result9);
					HighlightFontSize = result9;
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogError((object)("AnnouncementBinaryPacket.Deserialize error: " + ex.Message));
			}
			static string UnescapePipe(string s)
			{
				return (s ?? "").Replace("\\|", "|").Replace("\\n", "\n");
			}
		}

		private static string[] SplitByUnescapedPipe(string input)
		{
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < input.Length; i++)
			{
				if (input[i] == '|' && (i == 0 || input[i - 1] != '\\'))
				{
					list.Add(stringBuilder.ToString());
					stringBuilder.Clear();
				}
				else
				{
					stringBuilder.Append(input[i]);
				}
			}
			list.Add(stringBuilder.ToString());
			return list.ToArray();
		}
	}
	public static class AnnouncementNetworkHandler
	{
		private static bool _initialized;

		private static bool _serverHasNoticeMod;

		private static string _serverModSignature;

		private const string HANDSHAKE_PREFIX = "[NTC:HS]";

		private const string TOAST_PREFIX = "[NTC:T]";

		private const string BANNER_PREFIX = "[NTC:B]";

		private const string CLIENT_RESPONSE_PREFIX = "[NTC:CR]";

		public static bool ServerHasNoticeMod => _serverHasNoticeMod;

		public static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
			}
		}

		public static void ResetHandshake()
		{
			_serverHasNoticeMod = false;
			_serverModSignature = null;
			AnnouncementRouter.Instance.ResetSession();
		}

		public static void HandleHandshake(string signature)
		{
			_serverHasNoticeMod = true;
			_serverModSignature = signature;
		}

		public static bool IsSoloMode()
		{
			try
			{
				Type type = Type.GetType("AtlyssNetworkManager, Assembly-CSharp");
				if (type != null)
				{
					FieldInfo field = type.GetField("_current", BindingFlags.Static | BindingFlags.Public);
					if (field != null)
					{
						object value = field.GetValue(null);
						if (value != null)
						{
							FieldInfo field2 = type.GetField("_soloMode", BindingFlags.Instance | BindingFlags.Public);
							if (field2 != null)
							{
								return (bool)field2.GetValue(value);
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("IsSoloMode check failed: " + ex.Message));
			}
			return false;
		}

		public static void BroadcastToast(string message, float duration, bool skipLocalDisplay = false, bool forceShow = false, bool bypassRateLimit = false, bool skipVanillaCompat = false)
		{
			int fontSize = AnnouncementConfig.ToastFontSize?.Value ?? 20;
			AnnouncementRouter.Instance.BroadcastToast(message, duration, fontSize, forceShow, bypassRateLimit, skipLocalDisplay);
		}

		public static void BroadcastBanner(bool forceShow = false, bool skipLocalDisplay = false, bool bypassRateLimit = false, bool skipVanillaCompat = false)
		{
			AnnouncementRouter.Instance.BroadcastBanner(forceShow, bypassRateLimit, skipLocalDisplay);
		}

		public static void SendHandshake()
		{
		}

		public static bool TryParseHandshake(string message, out string signature)
		{
			signature = null;
			if (string.IsNullOrEmpty(message) || !message.StartsWith("[NTC:HS]"))
			{
				return false;
			}
			signature = message.Substring("[NTC:HS]".Length);
			if (signature.EndsWith("<>"))
			{
				signature = signature.Substring(0, signature.Length - 2);
			}
			return !string.IsNullOrEmpty(signature);
		}

		public static bool TryParseToast(string message, out string text, out float duration, out int fontSize, out bool forceShow, out int soundType, out float soundVolume, out bool isScheduled)
		{
			text = null;
			duration = 0f;
			fontSize = 20;
			forceShow = false;
			soundType = 0;
			soundVolume = 0.5f;
			isScheduled = false;
			if (string.IsNullOrEmpty(message) || !message.StartsWith("[NTC:T]"))
			{
				return false;
			}
			try
			{
				string text2 = message.Substring("[NTC:T]".Length);
				if (text2.EndsWith("<>"))
				{
					text2 = text2.Substring(0, text2.Length - 2);
				}
				if (text2.EndsWith("|SCHED"))
				{
					isScheduled = true;
					forceShow = true;
					text2 = text2.Substring(0, text2.Length - 6);
				}
				else if (text2.EndsWith("|FORCE"))
				{
					forceShow = true;
					text2 = text2.Substring(0, text2.Length - 6);
				}
				string[] array = text2.Split(new char[1] { '|' }, 5);
				if (array.Length >= 5)
				{
					if (!float.TryParse(array[0], out duration))
					{
						return false;
					}
					if (!int.TryParse(array[1], out fontSize))
					{
						fontSize = 20;
					}
					if (!int.TryParse(array[2], out soundType))
					{
						soundType = 0;
					}
					if (!float.TryParse(array[3], out soundVolume))
					{
						soundVolume = 0.5f;
					}
					text = array[4];
					return true;
				}
				if (array.Length >= 3)
				{
					if (!float.TryParse(array[0], out duration))
					{
						return false;
					}
					if (!int.TryParse(array[1], out fontSize))
					{
						fontSize = 20;
					}
					text = array[2];
					return true;
				}
				if (array.Length >= 2)
				{
					if (!float.TryParse(array[0], out duration))
					{
						return false;
					}
					text = array[1];
					return true;
				}
				return false;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryParseBanner(string message, out AnnouncementData data, out bool forceShow, out int soundType, out float soundVolume, out bool isScheduled)
		{
			data = default(AnnouncementData);
			soundType = 0;
			soundVolume = 0.5f;
			forceShow = false;
			isScheduled = false;
			if (string.IsNullOrEmpty(message) || !message.StartsWith("[NTC:B]"))
			{
				return false;
			}
			try
			{
				string text = message.Substring("[NTC:B]".Length);
				if (text.EndsWith("<>"))
				{
					text = text.Substring(0, text.Length - 2);
				}
				if (text.EndsWith("|SCHED"))
				{
					isScheduled = true;
					forceShow = true;
					text = text.Substring(0, text.Length - 6);
				}
				else if (text.EndsWith("|FORCE"))
				{
					forceShow = true;
					text = text.Substring(0, text.Length - 6);
				}
				string[] array = text.Split(new char[1] { '|' }, 11);
				if (array.Length >= 11)
				{
					if (!int.TryParse(array[0], out var result))
					{
						return false;
					}
					if (!int.TryParse(array[1], out var result2))
					{
						result2 = 24;
					}
					if (!int.TryParse(array[2], out var result3))
					{
						result3 = 16;
					}
					if (!int.TryParse(array[3], out var result4))
					{
						result4 = 14;
					}
					if (!int.TryParse(array[4], out var result5))
					{
						result5 = 18;
					}
					if (!int.TryParse(array[5], out soundType))
					{
						soundType = 0;
					}
					if (!float.TryParse(array[6], out soundVolume))
					{
						soundVolume = 0.5f;
					}
					data = new AnnouncementData(array[7], array[9].Replace("\\|", "|"), result, "", result2, result3, array[10].Replace("\\|", "|"), result4, array[8].Replace("\\|", "|"), result5);
					return true;
				}
				if (array.Length >= 9)
				{
					if (!int.TryParse(array[0], out var result6))
					{
						return false;
					}
					if (!int.TryParse(array[1], out var result7))
					{
						result7 = 24;
					}
					if (!int.TryParse(array[2], out var result8))
					{
						result8 = 16;
					}
					if (!int.TryParse(array[3], out var result9))
					{
						result9 = 14;
					}
					if (!int.TryParse(array[4], out var result10))
					{
						result10 = 18;
					}
					data = new AnnouncementData(array[5], array[7].Replace("\\|", "|"), result6, "", result7, result8, array[8].Replace("\\|", "|"), result9, array[6].Replace("\\|", "|"), result10);
					return true;
				}
				if (array.Length >= 7)
				{
					if (!int.TryParse(array[0], out var result11))
					{
						return false;
					}
					if (!int.TryParse(array[1], out var result12))
					{
						result12 = 24;
					}
					if (!int.TryParse(array[2], out var result13))
					{
						result13 = 16;
					}
					if (!int.TryParse(array[3], out var result14))
					{
						result14 = 14;
					}
					data = new AnnouncementData(array[4], array[5].Replace("\\|", "|"), result11, "", result12, result13, array[6].Replace("\\|", "|"), result14);
					return true;
				}
				if (array.Length >= 5)
				{
					if (!int.TryParse(array[0], out var result15))
					{
						return false;
					}
					if (!int.TryParse(array[1], out var result16))
					{
						result16 = 24;
					}
					if (!int.TryParse(array[2], out var result17))
					{
						result17 = 16;
					}
					data = new AnnouncementData(array[3], array[4].Replace("\\|", "|"), result15, "", result16, result17);
					return true;
				}
				if (array.Length >= 3)
				{
					if (!int.TryParse(array[0], out var result18))
					{
						return false;
					}
					data = new AnnouncementData(array[1], array[2].Replace("\\|", "|"), result18);
					return true;
				}
				return false;
			}
			catch
			{
				return false;
			}
		}
	}
	[HarmonyPatch]
	public static class NoticeNetworkPatches
	{
		private static readonly string[] VANILLA_PREFIXES = new string[4] { "[Notice]", "[Banner]", "  > ", "  * " };

		private static bool _uiInitialized = false;

		[HarmonyPatch(typeof(ChatBehaviour), "New_ChatMessage")]
		[HarmonyPrefix]
		private static bool OnReceiveChatMessage(string _message)
		{
			if (string.IsNullOrEmpty(_message))
			{
				return true;
			}
			try
			{
				string[] vANILLA_PREFIXES = VANILLA_PREFIXES;
				foreach (string value in vANILLA_PREFIXES)
				{
					if (_message.Contains(value))
					{
						return false;
					}
				}
				if (AnnouncementNetworkHandler.TryParseToast(_message, out var text, out var duration, out var fontSize, out var forceShow, out var soundType, out var soundVolume, out var isScheduled))
				{
					AnnouncementManager.Instance?.HandleToastReceived(text, duration, fontSize, forceShow, null, soundType, soundVolume);
					AnnouncementManager.Instance?.SetLastIsScheduled(isScheduled);
					return false;
				}
				if (AnnouncementNetworkHandler.TryParseBanner(_message, out var data, out var forceShow2, out var soundType2, out var soundVolume2, out var isScheduled2))
				{
					AnnouncementManager.Instance?.HandleBannerReceived(data, forceShow2, null, soundType2, soundVolume2);
					AnnouncementManager.Instance?.SetLastIsScheduled(isScheduled2);
					return false;
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("OnReceiveChatMessage error: " + ex.Message));
			}
			return true;
		}

		[HarmonyPatch(typeof(ChatBehaviour), "OnServerMessage")]
		[HarmonyPrefix]
		private static bool OnServerMessageReceived(ref object __0)
		{
			try
			{
				if (__0 == null)
				{
					return true;
				}
				Type type = __0.GetType();
				FieldInfo field = type.GetField("servMsg");
				if (field == null)
				{
					return true;
				}
				string text = field.GetValue(__0) as string;
				if (string.IsNullOrEmpty(text))
				{
					return true;
				}
				EnsureUIInitialized();
				string[] vANILLA_PREFIXES = VANILLA_PREFIXES;
				foreach (string value in vANILLA_PREFIXES)
				{
					if (text.Contains(value))
					{
						return false;
					}
				}
				if (AnnouncementNetworkHandler.TryParseHandshake(text, out var signature))
				{
					AnnouncementNetworkHandler.HandleHandshake(signature);
					SendClientResponse();
					return false;
				}
				if (text.StartsWith("[NTC:") && !AnnouncementNetworkHandler.ServerHasNoticeMod)
				{
					AnnouncementNetworkHandler.HandleHandshake("ServerAnnouncements_Auto");
				}
				if (AnnouncementManager.IsHost() && (text.StartsWith("[NTC:T]") || text.StartsWith("[NTC:B]")))
				{
					return false;
				}
				if (AnnouncementNetworkHandler.TryParseToast(text, out var text2, out var duration, out var fontSize, out var forceShow, out var soundType, out var soundVolume, out var isScheduled))
				{
					AnnouncementManager.Instance?.HandleToastReceived(text2, duration, fontSize, forceShow, null, soundType, soundVolume);
					AnnouncementManager.Instance?.SetLastIsScheduled(isScheduled);
					return false;
				}
				if (AnnouncementNetworkHandler.TryParseBanner(text, out var data, out var forceShow2, out var soundType2, out var soundVolume2, out var isScheduled2))
				{
					AnnouncementManager.Instance?.HandleBannerReceived(data, forceShow2, null, soundType2, soundVolume2);
					AnnouncementManager.Instance?.SetLastIsScheduled(isScheduled2);
					return false;
				}
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("OnServerMessageReceived error: " + ex.Message));
			}
			return true;
		}

		private static void EnsureUIInitialized()
		{
			if (_uiInitialized)
			{
				return;
			}
			try
			{
				AnnouncementToastUI.Initialize();
				AnnouncementBannerUI.Initialize();
				_uiInitialized = true;
			}
			catch (Exception ex)
			{
				ServerAnnouncementsPlugin.Log.LogWarning((object)("EnsureUIInitialized error: " + ex.Message));
			}
		}

		private static void SendClientResponse()
		{
			CodeTalkerIntegration.SendClientResponse();
		}
	}
	public enum PlayerType
	{
		Host,
		ModClient,
		VanillaClient,
		Pending
	}
	public class PlayerInfo
	{
		public int ConnectionId { get; set; }

		public ulong SteamId { get; set; }

		public PlayerType Type { get; set; }

		public DateTime ConnectedAt { get; set; }

		public DateTime? HandshakeSentAt { get; set; }

		public bool HandshakeResponseReceived { get; set; }

		public bool NotificationSent { get; set; }

		public string CharacterName { get; set; }

		public string GlobalNickname { get; set; }

		public PlayerInfo(int connectionId, ulong steamId = 0uL)
		{
			ConnectionId = connectionId;
			SteamId = steamId;
			Type = ((connectionId != 0) ? PlayerType.Pending : PlayerType.Host);
			ConnectedAt = DateTime.Now;
			HandshakeSentAt = null;
			HandshakeResponseReceived = false;
			NotificationSent = false;
			CharacterName = "";
			GlobalNickname = "";
		}

		public string GetDisplayString()
		{
			if (!string.IsNullOrEmpty(CharacterName) || !string.IsNullOrEmpty(GlobalNickname))
			{
				List<string> list = new List<string>();
				if (!string.IsNullOrEmpty(CharacterName))
				{
					list.Add(CharacterName);
				}
				if (!string.IsNullOrEmpty(GlobalNickname) && GlobalNickname != CharacterName)
				{
					list.Add("(" + GlobalNickname + ")");
				}
				if (SteamId != 0)
				{
					list.Add($"[{SteamId}]");
				}
				return (list.Count > 0) ? string.Join(" ", list) : $"[{SteamId}]";
			}
			if (SteamId != 0)
			{
				return PlayerTypeManager.GetDisplayStringBySteamId(SteamId.ToString());
			}
			return $"[{SteamId}]";
		}
	}
	public static class PlayerTypeManager
	{