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.Versioning;
using System.Threading;
using AutoBroadcast.Config;
using AutoBroadcast.Messaging;
using AutoBroadcast.Models;
using AutoBroadcast.Patches;
using AutoBroadcast.Scheduling;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Splatform;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("Nerdy Gamer Tools")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Server-side scheduled broadcast mod for Valheim.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Nerdy Gamer Tools AutoBroadcaster")]
[assembly: AssemblyTitle("NGT.AutoBroadcaster")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AutoBroadcast
{
	[BepInPlugin("NGT_Autobroadcaster", "Nerdy Gamer Tools AutoBroadcaster", "1.0.0")]
	public sealed class AutoBroadcastPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "NGT_Autobroadcaster";

		public const string PluginName = "Nerdy Gamer Tools AutoBroadcaster";

		public const string PluginVersion = "1.0.0";

		private MessageConfigService? _configService;

		private HourlyMessageScheduler? _scheduler;

		private Harmony? _harmony;

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("NGT_Autobroadcaster");
			_harmony.PatchAll(typeof(ZLogFilterPatch).Assembly);
			_configService = new MessageConfigService(((BaseUnityPlugin)this).Config, delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)message);
			}, delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			});
			_configService.Initialize();
			BroadcastDispatcher @object = new BroadcastDispatcher(delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)message);
			}, delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			}, (MonoBehaviour)(object)this);
			_scheduler = new HourlyMessageScheduler(() => (!_configService.IsEnabled) ? Array.Empty<ScheduledMessage>() : _configService.Messages, @object.Dispatch, delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)message);
			});
			((MonoBehaviour)this).StartCoroutine(_scheduler.Run());
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Nerdy Gamer Tools AutoBroadcaster initialized. Server-side scheduler is running.");
		}

		private void OnDestroy()
		{
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_harmony = null;
			_configService?.Dispose();
			_configService = null;
		}
	}
}
namespace AutoBroadcast.Scheduling
{
	internal sealed class HourlyMessageScheduler
	{
		[CompilerGenerated]
		private sealed class <Run>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public HourlyMessageScheduler <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				int num = <>1__state;
				HourlyMessageScheduler hourlyMessageScheduler = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					hourlyMessageScheduler.Tick(DateTime.Now);
				}
				else
				{
					<>1__state = -1;
					hourlyMessageScheduler.Tick(DateTime.Now);
				}
				float secondsUntilNextMinute = GetSecondsUntilNextMinute(DateTime.Now);
				<>2__current = (object)new WaitForSecondsRealtime(secondsUntilNextMinute);
				<>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 readonly Func<IReadOnlyList<ScheduledMessage>> _getMessages;

		private readonly Action<ScheduledMessage> _dispatch;

		private readonly Action<string> _logInfo;

		private readonly HashSet<string> _firedKeys = new HashSet<string>(StringComparer.Ordinal);

		private DateTime _lastPruneUtc = DateTime.MinValue;

		public HourlyMessageScheduler(Func<IReadOnlyList<ScheduledMessage>> getMessages, Action<ScheduledMessage> dispatch, Action<string> logInfo)
		{
			_getMessages = getMessages;
			_dispatch = dispatch;
			_logInfo = logInfo;
		}

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

		private void Tick(DateTime localNow)
		{
			string text = localNow.ToString("yyyyMMddHH");
			IReadOnlyList<ScheduledMessage> readOnlyList = _getMessages();
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				ScheduledMessage scheduledMessage = readOnlyList[i];
				if (scheduledMessage.Minute == localNow.Minute)
				{
					string item = $"{text}:{scheduledMessage.MessageId}:{scheduledMessage.Method}:{scheduledMessage.Minute}";
					if (!_firedKeys.Contains(item))
					{
						_firedKeys.Add(item);
						_dispatch(scheduledMessage);
					}
				}
			}
			PruneOldState(localNow);
		}

		private static float GetSecondsUntilNextMinute(DateTime now)
		{
			float num = (float)(new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, 0).AddMinutes(1.0) - now).TotalSeconds;
			return Mathf.Max(0.25f, num + 0.05f);
		}

		private void PruneOldState(DateTime localNow)
		{
			DateTime utcNow = DateTime.UtcNow;
			if (!(utcNow - _lastPruneUtc < TimeSpan.FromHours(2.0)))
			{
				_lastPruneUtc = utcNow;
				string keepPrefix = localNow.ToString("yyyyMMddHH");
				_firedKeys.RemoveWhere((string key) => !key.StartsWith(keepPrefix, StringComparison.Ordinal));
				_logInfo($"Scheduler state pruned. Active execution keys: {_firedKeys.Count}");
			}
		}
	}
}
namespace AutoBroadcast.Patches
{
	[HarmonyPatch(typeof(ZLog), "Log")]
	internal static class ZLogFilterPatch
	{
		private const string SuppressedSnippet = "Failed to get player info for player Steam_0";

		private static bool Prefix(object o)
		{
			return !ShouldSuppress(o);
		}

		private static bool ShouldSuppress(object o)
		{
			string text = o?.ToString();
			if (!string.IsNullOrEmpty(text))
			{
				return text.IndexOf("Failed to get player info for player Steam_0", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}
	}
}
namespace AutoBroadcast.Models
{
	internal enum DeliveryMethod
	{
		Alert,
		Chat,
		Both
	}
	internal sealed class ScheduledMessage
	{
		public string MessageId { get; }

		public int Minute { get; }

		public DeliveryMethod Method { get; }

		public string Text { get; }

		public int AlertDurationSeconds { get; }

		public ScheduledMessage(string messageId, int minute, DeliveryMethod method, string text, int alertDurationSeconds)
		{
			if (string.IsNullOrWhiteSpace(messageId))
			{
				throw new ArgumentException("Message ID must not be empty.", "messageId");
			}
			if ((minute < 0 || minute > 59) ? true : false)
			{
				throw new ArgumentOutOfRangeException("minute", "Minute must be between 0 and 59.");
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				throw new ArgumentException("Message text must not be empty.", "text");
			}
			if (alertDurationSeconds < 1)
			{
				throw new ArgumentOutOfRangeException("alertDurationSeconds", "Alert duration must be at least 1 second.");
			}
			MessageId = messageId.Trim();
			Minute = minute;
			Method = method;
			Text = text.Trim();
			AlertDurationSeconds = alertDurationSeconds;
		}
	}
}
namespace AutoBroadcast.Messaging
{
	internal sealed class BroadcastDispatcher
	{
		[CompilerGenerated]
		private sealed class <RepeatAlertForDuration>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public int seconds;

			public string text;

			private int <repeats>5__2;

			private int <i>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<repeats>5__2 = Mathf.Max(0, Mathf.CeilToInt((float)seconds / 2f) - 1);
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					BroadcastCenterAlert(text);
					<i>5__3++;
					break;
				}
				if (<i>5__3 < <repeats>5__2)
				{
					<>2__current = (object)new WaitForSecondsRealtime(2f);
					<>1__state = 1;
					return true;
				}
				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();
			}
		}

		private readonly Action<string> _logInfo;

		private readonly Action<string> _logWarning;

		private readonly MonoBehaviour _coroutineHost;

		public BroadcastDispatcher(Action<string> logInfo, Action<string> logWarning, MonoBehaviour coroutineHost)
		{
			_logInfo = logInfo;
			_logWarning = logWarning;
			_coroutineHost = coroutineHost;
		}

		public void Dispatch(ScheduledMessage message)
		{
			if (message != null && ZNet.instance != null && ZNet.instance.IsServer())
			{
				switch (message.Method)
				{
				case DeliveryMethod.Alert:
					DispatchAlert(message);
					break;
				case DeliveryMethod.Chat:
					DispatchChat(message);
					break;
				case DeliveryMethod.Both:
					DispatchAlert(message);
					DispatchChat(message);
					break;
				default:
					_logWarning($"Unknown delivery method: {message.Method}");
					break;
				}
			}
		}

		private void DispatchAlert(ScheduledMessage message)
		{
			try
			{
				BroadcastCenterAlert(message.Text);
				if (message.AlertDurationSeconds > 2)
				{
					_coroutineHost.StartCoroutine(RepeatAlertForDuration(message.Text, message.AlertDurationSeconds));
				}
				_logInfo("Broadcasted alert: " + message.Text);
			}
			catch (Exception ex)
			{
				_logWarning("Failed to broadcast alert message: " + ex.Message);
			}
		}

		private void DispatchChat(ScheduledMessage message)
		{
			try
			{
				BroadcastConsoleStyledChatMessage(message.Text, message.Text);
				_logInfo("Broadcasted chat: " + message.Text);
			}
			catch (Exception arg)
			{
				_logWarning($"Failed to broadcast chat message: {arg}");
			}
		}

		private static void BroadcastCenterAlert(string text)
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ShowMessage", new object[2] { 2, text });
			}
		}

		private static void BroadcastConsoleStyledChatMessage(string formattedText, string fallbackText)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (ZRoutedRpc.instance == null)
			{
				Debug.Log((object)("[AutoBroadcaster] " + fallbackText));
				return;
			}
			UserInfo val = CreateServerConsoleUserInfo();
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ChatMessage", new object[4]
			{
				Vector3.zero,
				1,
				val,
				formattedText
			});
		}

		private static UserInfo CreateServerConsoleUserInfo()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			return new UserInfo
			{
				Name = "Server",
				UserId = CreateServerSenderId()
			};
		}

		private static PlatformUserID CreateServerSenderId()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			PlatformUserID result = default(PlatformUserID);
			if (PlatformUserID.TryParse("Steam_0", ref result))
			{
				return result;
			}
			PlatformUserID result2 = default(PlatformUserID);
			if (PlatformUserID.TryParse("PlayFab_0", ref result2))
			{
				return result2;
			}
			return PlatformUserID.None;
		}

		[IteratorStateMachine(typeof(<RepeatAlertForDuration>d__11))]
		private IEnumerator RepeatAlertForDuration(string text, int seconds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RepeatAlertForDuration>d__11(0)
			{
				text = text,
				seconds = seconds
			};
		}
	}
}
namespace AutoBroadcast.Config
{
	internal sealed class MessageConfigService : IDisposable
	{
		private readonly ConfigFile _configFile;

		private readonly Action<string> _logInfo;

		private readonly Action<string> _logWarning;

		private readonly object _sync = new object();

		private FileSystemWatcher? _watcher;

		private Timer? _reloadDebounceTimer;

		private ConfigEntry<bool>? _enableBroadcastingEntry;

		private ConfigEntry<int>? _broadcastCountEntry;

		private volatile ScheduledMessage[] _messages = Array.Empty<ScheduledMessage>();

		private volatile bool _isEnabled = true;

		public IReadOnlyList<ScheduledMessage> Messages => _messages;

		public bool IsEnabled => _isEnabled;

		public MessageConfigService(ConfigFile configFile, Action<string> logInfo, Action<string> logWarning)
		{
			_configFile = configFile;
			_logInfo = logInfo;
			_logWarning = logWarning;
		}

		public void Initialize()
		{
			_enableBroadcastingEntry = _configFile.Bind<bool>("Default Settings", "EnableBroadcasting", true, "Enable or disable scheduled automatic broadcasts.");
			_broadcastCountEntry = _configFile.Bind<int>("Default Settings", "AutoBroadcastCount", 3, "The number of message sections to be loaded from config.");
			LoadMessagesFromConfig();
			ConfigureWatcher();
		}

		public void Dispose()
		{
			lock (_sync)
			{
				_reloadDebounceTimer?.Dispose();
				_reloadDebounceTimer = null;
				if (_watcher != null)
				{
					_watcher.Changed -= OnConfigFileChanged;
					_watcher.Created -= OnConfigFileChanged;
					_watcher.Renamed -= OnConfigFileChanged;
					_watcher.Dispose();
					_watcher = null;
				}
			}
		}

		private void ConfigureWatcher()
		{
			string configFilePath = _configFile.ConfigFilePath;
			string directoryName = Path.GetDirectoryName(configFilePath);
			string fileName = Path.GetFileName(configFilePath);
			if (string.IsNullOrWhiteSpace(directoryName) || string.IsNullOrWhiteSpace(fileName))
			{
				_logWarning("Could not configure config file watcher. Live reload is disabled.");
				return;
			}
			lock (_sync)
			{
				_watcher = new FileSystemWatcher(directoryName, fileName)
				{
					NotifyFilter = (NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.CreationTime),
					IncludeSubdirectories = false,
					EnableRaisingEvents = true
				};
				_watcher.Changed += OnConfigFileChanged;
				_watcher.Created += OnConfigFileChanged;
				_watcher.Renamed += OnConfigFileChanged;
				_reloadDebounceTimer = new Timer(delegate
				{
					ReloadFromDisk();
				}, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
			}
		}

		private void OnConfigFileChanged(object sender, FileSystemEventArgs e)
		{
			lock (_sync)
			{
				_reloadDebounceTimer?.Change(TimeSpan.FromMilliseconds(300.0), Timeout.InfiniteTimeSpan);
			}
		}

		private void ReloadFromDisk()
		{
			try
			{
				_configFile.Reload();
				LoadMessagesFromConfig();
				_logInfo($"Config reloaded. Parsed {_messages.Length} scheduled messages.");
			}
			catch (Exception ex)
			{
				_logWarning("Failed to reload config from disk: " + ex.Message);
			}
		}

		private void LoadMessagesFromConfig()
		{
			if (_broadcastCountEntry == null || _enableBroadcastingEntry == null)
			{
				_messages = Array.Empty<ScheduledMessage>();
				return;
			}
			_isEnabled = _enableBroadcastingEntry.Value;
			int num = Math.Max(0, _broadcastCountEntry.Value);
			List<ScheduledMessage> list = new List<ScheduledMessage>(num);
			for (int i = 1; i <= num; i++)
			{
				string text = $"Message {i:00}";
				if (!TryLoadMessageSection(text, out ScheduledMessage message2, out string error))
				{
					_logWarning("Skipped invalid section '" + text + "': " + error);
				}
				else
				{
					list.Add(message2);
				}
			}
			_messages = list.OrderBy((ScheduledMessage message) => message.Minute).ThenBy<ScheduledMessage, string>((ScheduledMessage message) => message.MessageId, StringComparer.Ordinal).ThenBy((ScheduledMessage message) => message.Method)
				.ToArray();
		}

		private bool TryLoadMessageSection(string sectionName, out ScheduledMessage? message, out string error)
		{
			message = null;
			error = string.Empty;
			ConfigEntry<string> val = _configFile.Bind<string>(sectionName, "MessageText", GetDefaultMessageText(sectionName), "The message to be displayed.");
			ConfigEntry<string> val2 = _configFile.Bind<string>(sectionName, "MessageType", GetDefaultMessageType(sectionName), "The message type (Chat, Alert, or Both).");
			ConfigEntry<int> obj = _configFile.Bind<int>(sectionName, "ScheduledMinuteOfHour", GetDefaultMessageMinute(sectionName), "Minute of each hour to broadcast (0-59).");
			ConfigEntry<int> val3 = _configFile.Bind<int>(sectionName, "MessageTime", 5, "Amount of time the Alert stays on screen (in seconds).");
			int value = obj.Value;
			if ((value < 0 || value > 59) ? true : false)
			{
				error = "Minute must be a number between 0 and 59.";
				return false;
			}
			if (!Enum.TryParse<DeliveryMethod>(val2.Value.Trim(), ignoreCase: true, out var result))
			{
				error = "MessageType must be Alert, Chat, or Both.";
				return false;
			}
			string text = val.Value.Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				error = "MessageText is empty.";
				return false;
			}
			if (val3.Value < 1)
			{
				error = "MessageTime must be at least 1.";
				return false;
			}
			message = new ScheduledMessage(sectionName, value, result, text, val3.Value);
			return true;
		}

		private static string GetDefaultMessageText(string sectionName)
		{
			return sectionName switch
			{
				"Message 01" => "Welcome to the server! Be respectful and have fun.", 
				"Message 02" => "Join Our Discord To Be Part of The Community.", 
				"Message 03" => "Thank-You For Downloading. Please Edit Your Configs.", 
				_ => "Edit this message.", 
			};
		}

		private static string GetDefaultMessageType(string sectionName)
		{
			return sectionName switch
			{
				"Message 01" => "Alert", 
				"Message 02" => "Chat", 
				"Message 03" => "Both", 
				_ => "Chat", 
			};
		}

		private static int GetDefaultMessageMinute(string sectionName)
		{
			return sectionName switch
			{
				"Message 01" => 15, 
				"Message 02" => 30, 
				"Message 03" => 45, 
				_ => 0, 
			};
		}
	}
}