using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("EventChatNotifications")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EventChatNotifications")]
[assembly: AssemblyTitle("EventChatNotifications")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EventChatNotifications
{
	[BepInPlugin("sbg.eventchatnotifications", "EventChatNotifications", "0.4.1")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string ModGuid = "sbg.eventchatnotifications";

		public const string ModName = "EventChatNotifications";

		public const string ModVersion = "0.4.1";

		internal static ManualLogSource Log;

		private void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			new Harmony("sbg.eventchatnotifications").PatchAll();
			FirstPlaceTracker.Hook();
			Log.LogInfo((object)"EventChatNotifications v0.4.1 loaded.");
		}

		private void OnDestroy()
		{
			FirstPlaceTracker.Unhook();
		}
	}
	internal static class FirstPlaceTracker
	{
		private enum Metric
		{
			BestHoleScore,
			LongestChipIn,
			AvgFinishTime,
			ItemPickups,
			KORatio
		}

		private static readonly Metric[] AllMetrics = new Metric[5]
		{
			Metric.BestHoleScore,
			Metric.LongestChipIn,
			Metric.AvgFinishTime,
			Metric.ItemPickups,
			Metric.KORatio
		};

		private static readonly Dictionary<Metric, ulong> CurrentLeader = new Dictionary<Metric, ulong>();

		private static bool subscribed;

		internal static void Hook()
		{
			if (!subscribed)
			{
				CourseManager.PlayerStatesChanged += OnPlayerStatesChanged;
				subscribed = true;
			}
		}

		internal static void Unhook()
		{
			if (subscribed)
			{
				CourseManager.PlayerStatesChanged -= OnPlayerStatesChanged;
				CurrentLeader.Clear();
				subscribed = false;
			}
		}

		private static void OnPlayerStatesChanged(Operation<PlayerState> op, int index, PlayerState changed)
		{
			//IL_0012: 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)
			SyncList<PlayerState> playerStates = CourseManager.PlayerStates;
			if (playerStates == null)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < playerStates.Count; i++)
			{
				if (!playerStates[i].isSpectator && playerStates[i].isConnected)
				{
					num++;
				}
			}
			if (num >= 2)
			{
				Metric[] allMetrics = AllMetrics;
				foreach (Metric metric in allMetrics)
				{
					Reconcile(playerStates, metric);
				}
			}
		}

		private static void Reconcile(SyncList<PlayerState> states, Metric metric)
		{
			if (TryComputeLeader(states, metric, out var leaderGuid, out var valueLabel))
			{
				ulong value;
				bool flag = CurrentLeader.TryGetValue(metric, out value);
				if (!flag || value != leaderGuid)
				{
					CurrentLeader[metric] = leaderGuid;
					string text = Narrator.PlayerNameFromGuid(leaderGuid);
					string text2 = MetricLabel(metric);
					Narrator.Post(flag ? (text + " took first on " + text2 + " from " + Narrator.PlayerNameFromGuid(value) + " — " + valueLabel + ".") : (text + " took first on " + text2 + " — " + valueLabel + "."));
				}
			}
		}

		private static bool TryComputeLeader(SyncList<PlayerState> states, Metric metric, out ulong leaderGuid, out string valueLabel)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			leaderGuid = 0uL;
			valueLabel = null;
			bool flag = false;
			ulong num = 0uL;
			int num2 = int.MaxValue;
			float num3 = 0f;
			int num4 = 0;
			for (int i = 0; i < states.Count; i++)
			{
				PlayerState val = states[i];
				if (val.isSpectator || !val.isConnected || !IsEligible(val, metric))
				{
					continue;
				}
				bool flag2;
				if (!flag)
				{
					flag2 = true;
				}
				else if (UsesIntComparison(metric))
				{
					int num5 = ReadInt(val, metric);
					flag2 = (LowerIsBetter(metric) ? (num5 < num4) : (num5 > num4));
				}
				else
				{
					float num6 = ReadFloat(val, metric);
					flag2 = (LowerIsBetter(metric) ? (num6 < num3) : (num6 > num3));
				}
				if (flag2)
				{
					num = val.playerGuid;
					num2 = val.joinIndex;
					flag = true;
					if (UsesIntComparison(metric))
					{
						num4 = ReadInt(val, metric);
					}
					else
					{
						num3 = ReadFloat(val, metric);
					}
				}
				else if (HasTie(val, metric, num4, num3) && val.joinIndex < num2)
				{
					num = val.playerGuid;
					num2 = val.joinIndex;
				}
			}
			if (!flag)
			{
				return false;
			}
			leaderGuid = num;
			valueLabel = FormatValue(states, num, metric, num4, num3);
			return true;
		}

		private static bool IsEligible(PlayerState s, Metric metric)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			switch (metric)
			{
			case Metric.BestHoleScore:
				return (int)s.bestHoleScore > 0;
			case Metric.LongestChipIn:
				return s.longestChipIn > float.MinValue;
			case Metric.AvgFinishTime:
				if (s.avgFinishTime > 0f)
				{
					return s.finishes > 0;
				}
				return false;
			case Metric.ItemPickups:
				return s.itemPickups > 0;
			case Metric.KORatio:
				return s.matchKnockouts > 0;
			default:
				return false;
			}
		}

		private static bool UsesIntComparison(Metric m)
		{
			if (m != 0)
			{
				return m == Metric.ItemPickups;
			}
			return true;
		}

		private static bool LowerIsBetter(Metric m)
		{
			return m == Metric.AvgFinishTime;
		}

		private static int ReadInt(PlayerState s, Metric m)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected I4, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return m switch
			{
				Metric.BestHoleScore => (int)s.bestHoleScore, 
				Metric.ItemPickups => s.itemPickups, 
				_ => 0, 
			};
		}

		private static float ReadFloat(PlayerState s, Metric m)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return m switch
			{
				Metric.LongestChipIn => s.longestChipIn, 
				Metric.AvgFinishTime => s.avgFinishTime, 
				Metric.KORatio => ComputeKORatio(s), 
				_ => 0f, 
			};
		}

		private static float ComputeKORatio(PlayerState s)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(1, s.matchKnockedOut);
			return (float)s.matchKnockouts / (float)num;
		}

		private static bool HasTie(PlayerState s, Metric metric, int bestInt, float bestFloat)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (UsesIntComparison(metric))
			{
				return ReadInt(s, metric) == bestInt;
			}
			return Mathf.Approximately(ReadFloat(s, metric), bestFloat);
		}

		private static string FormatValue(SyncList<PlayerState> states, ulong leaderGuid, Metric metric, int bestInt, float bestFloat)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			switch (metric)
			{
			case Metric.BestHoleScore:
				return DescribeStrokesUnderPar((StrokesUnderParType)bestInt);
			case Metric.LongestChipIn:
				return $"{Mathf.RoundToInt(bestFloat)}m";
			case Metric.AvgFinishTime:
				return $"{bestFloat:0.0}s";
			case Metric.ItemPickups:
				return bestInt.ToString();
			case Metric.KORatio:
			{
				for (int i = 0; i < states.Count; i++)
				{
					if (states[i].playerGuid == leaderGuid)
					{
						PlayerState val = states[i];
						return $"{bestFloat:0.00} ({val.matchKnockouts}/{val.matchKnockedOut})";
					}
				}
				return bestFloat.ToString("0.00");
			}
			default:
				return string.Empty;
			}
		}

		private static string MetricLabel(Metric m)
		{
			return m switch
			{
				Metric.BestHoleScore => "best hole", 
				Metric.LongestChipIn => "longest chip-in", 
				Metric.AvgFinishTime => "average finish time", 
				Metric.ItemPickups => "item pickups", 
				Metric.KORatio => "K/O ratio", 
				_ => "stat", 
			};
		}

		private static string DescribeStrokesUnderPar(StrokesUnderParType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			return (type - 1) switch
			{
				5 => "Hole in One", 
				4 => "Condor", 
				3 => "Albatross", 
				2 => "Eagle", 
				1 => "Birdie", 
				0 => "Par", 
				_ => "—", 
			};
		}
	}
	internal static class Narrator
	{
		private const string Prefix = "<color=#9aa6ff><b>[Match]</b></color> ";

		internal static void Post(string message)
		{
			if (string.IsNullOrEmpty(message))
			{
				return;
			}
			try
			{
				TextChatUi.ShowMessage("<color=#9aa6ff><b>[Match]</b></color> " + message);
			}
			catch
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[chat-fallback] " + message));
				}
			}
		}

		internal static string PlayerNameFromGuid(ulong guid)
		{
			PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
			if ((Object)(object)localPlayerInfo != (Object)null && (Object)(object)localPlayerInfo.PlayerId != (Object)null && localPlayerInfo.PlayerId.Guid == guid)
			{
				return localPlayerInfo.PlayerId.PlayerNameNoRichText;
			}
			if (GameManager.RemotePlayers != null)
			{
				foreach (PlayerInfo remotePlayer in GameManager.RemotePlayers)
				{
					if (!((Object)(object)remotePlayer == (Object)null) && !((Object)(object)remotePlayer.PlayerId == (Object)null) && remotePlayer.PlayerId.Guid == guid)
					{
						return remotePlayer.PlayerId.PlayerNameNoRichText;
					}
				}
			}
			return "Someone";
		}

		internal static string DescribeStrokesUnderPar(StrokesUnderParType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected I4, but got Unknown
			return (type - 2) switch
			{
				4 => "scored a hole in one!", 
				2 => "landed an albatross!", 
				1 => "landed an eagle!", 
				0 => "landed a birdie!", 
				3 => "pulled off a condor!", 
				_ => null, 
			};
		}
	}
	[HarmonyPatch(typeof(InfoFeed), "UserCode_RpcShowMessage__StrokesMessageData")]
	internal static class Patch_StrokesMessage
	{
		private static void Postfix(StrokesMessageData messageData)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: 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)
			string text = Narrator.DescribeStrokesUnderPar(messageData.strokesUnderParType);
			if (text != null)
			{
				Narrator.Post(Narrator.PlayerNameFromGuid(messageData.playerGuid) + " " + text);
			}
		}
	}
	[HarmonyPatch(typeof(InfoFeed), "UserCode_RpcShowMessage__SpeedrunMessageData")]
	internal static class Patch_SpeedrunMessage
	{
		private static void Postfix(SpeedrunMessageData messageData)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Narrator.Post(Narrator.PlayerNameFromGuid(messageData.playerGuid) + " sprinted through the hole — that was fast!");
		}
	}
}