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.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ModSync.Networking;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("ModSync")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+fc6bc7fe0b23e6eb94f7536cdd35c7e2d3cd2055")]
[assembly: AssemblyProduct("ModSync")]
[assembly: AssemblyTitle("ModSync")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ModSync
{
	internal static class ConfigSync
	{
		private static readonly ManualLogSource Log = Plugin.Logger;

		internal static Dictionary<string, string> GetLocalConfigs()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			string configPath = Paths.ConfigPath;
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				if (pluginInfo.Key == "com.Jaz.modsync")
				{
					continue;
				}
				string path = Path.Combine(configPath, pluginInfo.Key + ".cfg");
				if (File.Exists(path))
				{
					try
					{
						dictionary[Path.GetFileName(path)] = File.ReadAllText(path);
					}
					catch (Exception ex)
					{
						Log.LogWarning((object)("[ConfigSync] Could not read config for " + pluginInfo.Key + ": " + ex.Message));
					}
				}
			}
			return dictionary;
		}

		internal static byte[] Serialize(Dictionary<string, string> configs)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8);
			binaryWriter.Write(configs.Count);
			foreach (KeyValuePair<string, string> config in configs)
			{
				binaryWriter.Write(config.Key);
				binaryWriter.Write(config.Value);
			}
			return memoryStream.ToArray();
		}

		internal static Dictionary<string, string> Deserialize(byte[] data)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			using MemoryStream input = new MemoryStream(data);
			using BinaryReader binaryReader = new BinaryReader(input, Encoding.UTF8);
			int num = binaryReader.ReadInt32();
			for (int i = 0; i < num; i++)
			{
				string key = binaryReader.ReadString();
				string value = binaryReader.ReadString();
				dictionary[key] = value;
			}
			return dictionary;
		}

		internal static int ApplyInMemory(Dictionary<string, string> receivedConfigs)
		{
			int num = 0;
			foreach (KeyValuePair<string, string> receivedConfig in receivedConfigs)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(receivedConfig.Key);
				if (!Chainloader.PluginInfos.TryGetValue(fileNameWithoutExtension, out var value))
				{
					Log.LogDebug((object)("[ConfigSync] Skipping config for uninstalled mod: " + fileNameWithoutExtension));
					continue;
				}
				ConfigFile config = value.Instance.Config;
				Dictionary<string, Dictionary<string, string>> dictionary = ParseIni(receivedConfig.Value);
				bool saveOnConfigSet = config.SaveOnConfigSet;
				config.SaveOnConfigSet = false;
				try
				{
					foreach (ConfigDefinition key in config.Keys)
					{
						if (dictionary.TryGetValue(key.Section, out var value2) && value2.TryGetValue(key.Key, out var value3))
						{
							ConfigEntryBase val = config[key];
							try
							{
								val.BoxedValue = TomlTypeConverter.ConvertToValue(value3, val.SettingType);
								num++;
							}
							catch (Exception ex)
							{
								Log.LogWarning((object)("[ConfigSync] Could not apply " + fileNameWithoutExtension + "/" + key.Section + "/" + key.Key + ": " + ex.Message));
							}
						}
					}
				}
				finally
				{
					config.SaveOnConfigSet = saveOnConfigSet;
				}
				Log.LogInfo((object)("[ConfigSync] Applied in-memory config for: " + fileNameWithoutExtension));
			}
			return num;
		}

		private static Dictionary<string, Dictionary<string, string>> ParseIni(string content)
		{
			Dictionary<string, Dictionary<string, string>> dictionary = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, string> value = null;
			string[] array = content.Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (string.IsNullOrEmpty(text) || text.StartsWith("#"))
				{
					continue;
				}
				if (text.StartsWith("[") && text.EndsWith("]"))
				{
					string key = text.Substring(1, text.Length - 2).Trim();
					if (!dictionary.TryGetValue(key, out value))
					{
						value = (dictionary[key] = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase));
					}
					continue;
				}
				int num = text.IndexOf('=');
				if (num > 0 && value != null)
				{
					string key2 = text.Substring(0, num).Trim();
					string value2 = text.Substring(num + 1).Trim();
					value[key2] = value2;
				}
			}
			return dictionary;
		}
	}
	internal static class ModChecker
	{
		internal static string[] GetLocalModList()
		{
			return (from kvp in Chainloader.PluginInfos
				where kvp.Key != "com.Jaz.modsync"
				select $"{kvp.Key}|{kvp.Value.Metadata.Version}" into s
				orderby s
				select s).ToArray();
		}

		internal static MismatchReport Compare(string[] localMods, string[] remoteMods)
		{
			HashSet<string> hashSet = new HashSet<string>(localMods);
			HashSet<string> hashSet2 = new HashSet<string>(remoteMods);
			string[] missingFromLocal = hashSet2.Except(hashSet).ToArray();
			string[] missingFromRemote = hashSet.Except(hashSet2).ToArray();
			return new MismatchReport(missingFromLocal, missingFromRemote);
		}
	}
	internal class MismatchReport
	{
		internal string[] MissingFromLocal { get; }

		internal string[] MissingFromRemote { get; }

		internal bool HasMismatches
		{
			get
			{
				if (MissingFromLocal.Length == 0)
				{
					return MissingFromRemote.Length != 0;
				}
				return true;
			}
		}

		internal MismatchReport(string[] missingFromLocal, string[] missingFromRemote)
		{
			MissingFromLocal = missingFromLocal;
			MissingFromRemote = missingFromRemote;
		}

		internal string FormatForDisplay()
		{
			List<string> list = new List<string>();
			if (MissingFromLocal.Length != 0)
			{
				list.Add("[ModSync] Mods you're missing:");
				string[] missingFromLocal = MissingFromLocal;
				foreach (string entry in missingFromLocal)
				{
					list.Add("  - " + FormatEntry(entry));
				}
			}
			if (MissingFromRemote.Length != 0)
			{
				list.Add("[ModSync] Mods the host doesn't have:");
				string[] missingFromLocal = MissingFromRemote;
				foreach (string entry2 in missingFromLocal)
				{
					list.Add("  + " + FormatEntry(entry2));
				}
			}
			return string.Join("\n", list);
		}

		private static string FormatEntry(string entry)
		{
			string[] array = entry.Split(new char[1] { '|' });
			if (array.Length != 2)
			{
				return entry;
			}
			return array[0] + " (v" + array[1] + ")";
		}
	}
	internal static class MyPluginInfo
	{
		internal const string PLUGIN_GUID = "com.Jaz.modsync";

		internal const string PLUGIN_NAME = "ModSync";

		internal const string PLUGIN_VERSION = "1.0.0";
	}
	[BepInPlugin("com.Jaz.modsync", "ModSync", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony _harmony = new Harmony("com.Jaz.modsync");

		internal static Plugin Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static ConfigEntry<bool> EnableModCheck { get; private set; }

		internal static ConfigEntry<bool> EnableConfigSync { get; private set; }

		internal static ConfigEntry<bool> NotifyOnMismatch { get; private set; }

		internal static ConfigEntry<bool> BlockJoinOnMismatch { get; private set; }

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			EnableModCheck = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableModCheck", true, "Check if players joining your room have the same mods installed.");
			EnableConfigSync = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableConfigSync", true, "Sync host's mod configs to clients when they join the room.");
			NotifyOnMismatch = ((BaseUnityPlugin)this).Config.Bind<bool>("ModCheck", "NotifyOnMismatch", true, "Show a notification when a mod mismatch is detected.");
			BlockJoinOnMismatch = ((BaseUnityPlugin)this).Config.Bind<bool>("ModCheck", "BlockJoinOnMismatch", false, "Kick clients that have different mods than the host. (Host only)");
			_harmony.PatchAll();
			((Component)this).gameObject.AddComponent<ModSyncNetwork>();
			Logger.LogInfo((object)"ModSync v1.0.0 loaded.");
		}

		private void OnDestroy()
		{
			_harmony.UnpatchSelf();
		}
	}
}
namespace ModSync.Networking
{
	public class ModSyncNetwork : MonoBehaviour, IInRoomCallbacks, IMatchmakingCallbacks, IOnEventCallback
	{
		[CompilerGenerated]
		private sealed class <ShowNotification>d__23 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					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 const byte EVT_REQUEST_MOD_SYNC = 145;

		private const byte EVT_MOD_LIST_PAYLOAD = 146;

		private const byte EVT_CONFIG_PAYLOAD = 147;

		private void OnEnable()
		{
			PhotonNetwork.AddCallbackTarget((object)this);
		}

		private void OnDisable()
		{
			PhotonNetwork.RemoveCallbackTarget((object)this);
		}

		void IInRoomCallbacks.OnPlayerEnteredRoom(Player newPlayer)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				Plugin.Logger.LogInfo((object)("[ModSync] " + newPlayer.NickName + " joined — pushing mod list."));
				PushModListTo(newPlayer);
				if (Plugin.EnableConfigSync.Value)
				{
					PushConfigsTo(newPlayer);
				}
			}
		}

		void IInRoomCallbacks.OnPlayerLeftRoom(Player otherPlayer)
		{
		}

		void IInRoomCallbacks.OnRoomPropertiesUpdate(Hashtable propertiesThatChanged)
		{
		}

		void IInRoomCallbacks.OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps)
		{
		}

		void IInRoomCallbacks.OnMasterClientSwitched(Player newMasterClient)
		{
		}

		void IMatchmakingCallbacks.OnJoinedRoom()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.IsMasterClient)
			{
				Plugin.Logger.LogInfo((object)"[ModSync] Joined room — requesting mod sync from host.");
				RaiseEventOptions val = new RaiseEventOptions();
				val.TargetActors = new int[1] { PhotonNetwork.MasterClient.ActorNumber };
				RaiseEventOptions val2 = val;
				PhotonNetwork.RaiseEvent((byte)145, (object)null, val2, SendOptions.SendReliable);
			}
		}

		void IMatchmakingCallbacks.OnFriendListUpdate(List<FriendInfo> friendList)
		{
		}

		void IMatchmakingCallbacks.OnCreatedRoom()
		{
		}

		void IMatchmakingCallbacks.OnCreateRoomFailed(short returnCode, string message)
		{
		}

		void IMatchmakingCallbacks.OnJoinRoomFailed(short returnCode, string message)
		{
		}

		void IMatchmakingCallbacks.OnJoinRandomFailed(short returnCode, string message)
		{
		}

		void IMatchmakingCallbacks.OnLeftRoom()
		{
		}

		private static void PushModListTo(Player target)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.EnableModCheck.Value)
			{
				string[] localModList = ModChecker.GetLocalModList();
				RaiseEventOptions val = new RaiseEventOptions();
				val.TargetActors = new int[1] { target.ActorNumber };
				RaiseEventOptions val2 = val;
				PhotonNetwork.RaiseEvent((byte)146, (object)localModList, val2, SendOptions.SendReliable);
			}
		}

		private static void PushConfigsTo(Player target)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> localConfigs = ConfigSync.GetLocalConfigs();
			if (localConfigs.Count != 0)
			{
				byte[] array = ConfigSync.Serialize(localConfigs);
				RaiseEventOptions val = new RaiseEventOptions();
				val.TargetActors = new int[1] { target.ActorNumber };
				RaiseEventOptions val2 = val;
				PhotonNetwork.RaiseEvent((byte)147, (object)array, val2, SendOptions.SendReliable);
			}
		}

		void IOnEventCallback.OnEvent(EventData photonEvent)
		{
			switch (photonEvent.Code)
			{
			case 145:
				HandleModSyncRequest(photonEvent);
				break;
			case 146:
				HandleModListPayload(photonEvent);
				break;
			case 147:
				HandleConfigPayload(photonEvent);
				break;
			}
		}

		private void HandleModSyncRequest(EventData evt)
		{
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			Room currentRoom = PhotonNetwork.CurrentRoom;
			if (currentRoom != null && currentRoom.Players.TryGetValue(evt.Sender, out var value))
			{
				Plugin.Logger.LogInfo((object)("[ModSync] " + value.NickName + " requested mod sync."));
				PushModListTo(value);
				if (Plugin.EnableConfigSync.Value)
				{
					PushConfigsTo(value);
				}
			}
		}

		private void HandleModListPayload(EventData evt)
		{
			if (!Plugin.EnableModCheck.Value)
			{
				return;
			}
			if (!(evt.CustomData is string[] remoteMods))
			{
				Plugin.Logger.LogWarning((object)"[ModSync] Received malformed mod list payload.");
				return;
			}
			MismatchReport mismatchReport = ModChecker.Compare(ModChecker.GetLocalModList(), remoteMods);
			if (!mismatchReport.HasMismatches)
			{
				Plugin.Logger.LogInfo((object)"[ModSync] Mod list matches host.");
				return;
			}
			string text = mismatchReport.FormatForDisplay();
			Plugin.Logger.LogWarning((object)text);
			if (Plugin.NotifyOnMismatch.Value)
			{
				((MonoBehaviour)this).StartCoroutine(ShowNotification(text));
			}
			if (Plugin.BlockJoinOnMismatch.Value && PhotonNetwork.IsMasterClient && evt.Sender != PhotonNetwork.LocalPlayer.ActorNumber)
			{
				Room currentRoom = PhotonNetwork.CurrentRoom;
				if (currentRoom != null && currentRoom.Players.TryGetValue(evt.Sender, out var value))
				{
					Plugin.Logger.LogWarning((object)("[ModSync] Kicking " + value.NickName + " due to mod mismatch."));
					PhotonNetwork.CloseConnection(value);
				}
			}
		}

		private void HandleConfigPayload(EventData evt)
		{
			if (Plugin.EnableConfigSync.Value)
			{
				if (!(evt.CustomData is byte[] data))
				{
					Plugin.Logger.LogWarning((object)"[ModSync] Received malformed config payload.");
					return;
				}
				Plugin.Logger.LogInfo((object)"[ModSync] Received config bundle from host — applying in-memory...");
				int num = ConfigSync.ApplyInMemory(ConfigSync.Deserialize(data));
				Plugin.Logger.LogInfo((object)$"[ModSync] Applied {num} setting(s) from host config.");
			}
		}

		[IteratorStateMachine(typeof(<ShowNotification>d__23))]
		private IEnumerator ShowNotification(string message)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShowNotification>d__23(0);
		}
	}
}