using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DefaultNamespace;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ContentWarningHostOnlyLobby")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0+34b643bbda542a68bca944b7e0033ffeb995a662")]
[assembly: AssemblyProduct("ContentWarningHostOnlyLobby")]
[assembly: AssemblyTitle("ContentWarningHostOnlyLobby")]
[assembly: AssemblyVersion("1.2.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 ContentWarningHostOnlyLobby
{
	[ContentWarningPlugin("local.contentwarning.hostonlylobby", "1.2.0", true)]
	[BepInPlugin("local.contentwarning.hostonlylobby", "HostOnlyLobby", "1.2.0")]
	public sealed class HostOnlyLobbyPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "local.contentwarning.hostonlylobby";

		public const string PluginName = "HostOnlyLobby";

		public const string PluginVersion = "1.2.0";

		private Harmony? _harmony;

		private bool _wasInHostRoom;

		private int _lastSceneHandle = -1;

		private float _indicatorVisibleFrom;

		private float _indicatorVisibleUntil;

		private GUIStyle? _indicatorTitleStyle;

		private GUIStyle? _indicatorDetailStyle;

		internal static int MaxPlayers { get; private set; } = 8;

		internal static int RequiredSleepers { get; private set; } = 4;

		internal static bool ShowStatusIndicator { get; private set; } = true;

		internal static float IndicatorSeconds { get; private set; } = 12f;

		internal static ManualLogSource? Log { get; private set; }

		private void Awake()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			ConfigEntry<int> obj = ((BaseUnityPlugin)this).Config.Bind<int>("Lobby", "MaxPlayers", 8, "Maximum lobby size. Keep between 5 and 16 for cross-platform testing.");
			ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>("Interface", "ShowStatusIndicator", true, "Show a status card when the host enters a room or loads a world.");
			ConfigEntry<float> val2 = ((BaseUnityPlugin)this).Config.Bind<float>("Interface", "IndicatorSeconds", 12f, "How many seconds the status card remains visible. Keep between 3 and 30.");
			MaxPlayers = Clamp(obj.Value, 5, 16);
			RequiredSleepers = Math.Min(4, MaxPlayers);
			ShowStatusIndicator = val.Value;
			IndicatorSeconds = Mathf.Clamp(val2.Value, 3f, 30f);
			_harmony = new Harmony("local.contentwarning.hostonlylobby");
			_harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Lobby patches active. MaxPlayers={MaxPlayers}. Extra PC clients in slots 5+ also need this plugin for safe local spawning.");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Late joining is intentionally disabled; have everyone join before opening the house door.");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Spawn compatibility is active on this device for house, dive-bell return, and hospital spawns.");
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Status indicator enabled: {ShowStatusIndicator} ({IndicatorSeconds:0.#} seconds).");
			RunStartupDiagnostics();
		}

		private void Update()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient;
			Scene activeScene = SceneManager.GetActiveScene();
			int handle = ((Scene)(ref activeScene)).handle;
			if (ShowStatusIndicator && flag && (!_wasInHostRoom || handle != _lastSceneHandle))
			{
				_indicatorVisibleFrom = Time.realtimeSinceStartup + 1f;
				_indicatorVisibleUntil = _indicatorVisibleFrom + IndicatorSeconds;
				ManualLogSource logger = ((BaseUnityPlugin)this).Logger;
				activeScene = SceneManager.GetActiveScene();
				logger.LogInfo((object)("Status indicator scheduled in scene '" + ((Scene)(ref activeScene)).name + "'."));
			}
			_wasInHostRoom = flag;
			_lastSceneHandle = handle;
		}

		private void OnGUI()
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			if (ShowStatusIndicator && !(Time.realtimeSinceStartup < _indicatorVisibleFrom) && !(Time.realtimeSinceStartup > _indicatorVisibleUntil))
			{
				EnsureIndicatorStyles();
				float num = Mathf.Min(340f, (float)Screen.width - 32f);
				Rect val = default(Rect);
				((Rect)(ref val))..ctor((float)Screen.width - num - 16f, 18f, num, 72f);
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(((Rect)(ref val)).x, ((Rect)(ref val)).y, 5f, ((Rect)(ref val)).height);
				Rect val3 = default(Rect);
				((Rect)(ref val3))..ctor(((Rect)(ref val)).x + 18f, ((Rect)(ref val)).y + 10f, ((Rect)(ref val)).width - 28f, 24f);
				Rect val4 = new Rect(((Rect)(ref val)).x + 18f, ((Rect)(ref val)).y + 36f, ((Rect)(ref val)).width - 28f, 24f);
				Color color = GUI.color;
				GUI.color = new Color(0.055f, 0.071f, 0.102f, 0.94f);
				GUI.DrawTexture(val, (Texture)(object)Texture2D.whiteTexture);
				GUI.color = new Color(0.25f, 0.88f, 0.55f, 1f);
				GUI.DrawTexture(val2, (Texture)(object)Texture2D.whiteTexture);
				GUI.color = Color.white;
				GUI.Label(val3, "HOSTONLYLOBBY ATIVO", _indicatorTitleStyle);
				GUI.Label(val4, $"Sala do host  •  até {MaxPlayers} jogadores", _indicatorDetailStyle);
				GUI.color = color;
			}
		}

		private void OnDestroy()
		{
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Log = null;
		}

		private void EnsureIndicatorStyles()
		{
			//IL_001c: 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)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (_indicatorTitleStyle == null || _indicatorDetailStyle == null)
			{
				_indicatorTitleStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					fontSize = 15,
					fontStyle = (FontStyle)1
				};
				_indicatorTitleStyle.normal.textColor = Color.white;
				_indicatorDetailStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					fontSize = 12
				};
				_indicatorDetailStyle.normal.textColor = new Color(0.78f, 0.82f, 0.88f, 1f);
			}
		}

		private static int Clamp(int value, int minimum, int maximum)
		{
			if (value < minimum)
			{
				return minimum;
			}
			if (value > maximum)
			{
				return maximum;
			}
			return value;
		}

		internal static void LogSpawnRemap(int originalIndex, int safeIndex)
		{
			ManualLogSource? log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"Spawn compatibility remapped local slot {originalIndex} to vanilla spawn {safeIndex}.");
			}
		}

		private void RunStartupDiagnostics()
		{
			MethodBase[] array = new MethodBase[8]
			{
				AccessTools.Method(typeof(SteamLobbyHandler), "HostMatch", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(PhotonNetwork), "CreateRoom", new Type[4]
				{
					typeof(string),
					typeof(RoomOptions),
					typeof(TypedLobby),
					typeof(string[])
				}, (Type[])null),
				AccessTools.PropertyGetter(typeof(InviteFriendsTerminal), "IsGameFull"),
				AccessTools.Method(typeof(RichPresenceHandler), "SetGroupSize", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(BedBoss), "OnPlayerJoined", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(PlayerHandler), "AllPlayersInBed", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(PlayerHandler), "AllPlayersAsleep", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(SpawnHandler), "FindLocalSpawnIndex", (Type[])null, (Type[])null)
			};
			int num = 0;
			MethodBase[] array2 = array;
			foreach (MethodBase methodBase in array2)
			{
				Patches patchInfo = Harmony.GetPatchInfo(methodBase);
				bool flag = false;
				if (patchInfo != null)
				{
					foreach (string owner in patchInfo.Owners)
					{
						if (owner == "local.contentwarning.hostonlylobby")
						{
							flag = true;
							break;
						}
					}
				}
				if (flag)
				{
					num++;
					continue;
				}
				((BaseUnityPlugin)this).Logger.LogError((object)("Startup diagnostic failed: patch missing on " + methodBase.DeclaringType?.Name + "." + methodBase.Name + "."));
			}
			if (num == array.Length)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Startup diagnostics passed: {num}/{array.Length} host-side patches registered.");
			}
		}
	}
	internal static class HostOnlyLobbyRules
	{
		internal static byte PhotonRoomLimit => 0;

		internal static bool IsAtCapacity(int playerCount)
		{
			return playerCount >= HostOnlyLobbyPlugin.MaxPlayers;
		}

		internal static int RichPresenceMaximum(int requestedMaximum)
		{
			if (requestedMaximum > 4)
			{
				return requestedMaximum;
			}
			return HostOnlyLobbyPlugin.MaxPlayers;
		}

		internal static int BedAssignmentCount(int bedCount, int playerCount)
		{
			return Math.Min(4, Math.Min(bedCount, playerCount));
		}

		internal static bool EnoughPlayersReady(int alivePlayers, int readyPlayers)
		{
			int num = Math.Min(HostOnlyLobbyPlugin.RequiredSleepers, alivePlayers);
			if (num > 0)
			{
				return readyPlayers >= num;
			}
			return false;
		}

		internal static int SafeSpawnIndex(int originalIndex, int houseSpawnCount, int diveBellSpawnCount)
		{
			if (originalIndex <= 0)
			{
				return 0;
			}
			int num = Math.Min(houseSpawnCount, diveBellSpawnCount);
			if (num <= 1)
			{
				return 0;
			}
			return 1 + (originalIndex - 1) % (num - 1);
		}
	}
	[HarmonyPatch(typeof(SpawnHandler))]
	[HarmonyPriority(800)]
	internal static class SpawnHandlerPatches
	{
		private static readonly FieldInfo LocalSpawnIndexField = typeof(SpawnHandler).GetField("m_LocalSpawnIndex", BindingFlags.Instance | BindingFlags.NonPublic) ?? throw new MissingFieldException(typeof(SpawnHandler).FullName, "m_LocalSpawnIndex");

		private static readonly FieldInfo HouseSpawnsField = typeof(SpawnHandler).GetField("m_HouseSpawns", BindingFlags.Instance | BindingFlags.NonPublic) ?? throw new MissingFieldException(typeof(SpawnHandler).FullName, "m_HouseSpawns");

		private static readonly FieldInfo DiveBellSpawnsField = typeof(SpawnHandler).GetField("m_DiveBellSpawns", BindingFlags.Instance | BindingFlags.NonPublic) ?? throw new MissingFieldException(typeof(SpawnHandler).FullName, "m_DiveBellSpawns");

		[HarmonyPostfix]
		[HarmonyPatch("FindLocalSpawnIndex")]
		private static void FindLocalSpawnIndexPostfix(SpawnHandler __instance)
		{
			int num = (int)LocalSpawnIndexField.GetValue(__instance);
			Transform[] array = (Transform[])HouseSpawnsField.GetValue(__instance);
			Transform[] array2 = (Transform[])DiveBellSpawnsField.GetValue(__instance);
			int num2 = HostOnlyLobbyRules.SafeSpawnIndex(num, (array != null) ? array.Length : 0, (array2 != null) ? array2.Length : 0);
			if (num2 != num)
			{
				LocalSpawnIndexField.SetValue(__instance, num2);
				HostOnlyLobbyPlugin.LogSpawnRemap(num, num2);
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobbyHandler))]
	internal static class SteamLobbyPatches
	{
		private static readonly FieldInfo MaxPlayersField = typeof(SteamLobbyHandler).GetField("m_MaxPlayers", BindingFlags.Instance | BindingFlags.NonPublic) ?? throw new MissingFieldException(typeof(SteamLobbyHandler).FullName, "m_MaxPlayers");

		[HarmonyPrefix]
		[HarmonyPatch("HostMatch")]
		private static void HostMatchPrefix(SteamLobbyHandler __instance)
		{
			MaxPlayersField.SetValue(__instance, HostOnlyLobbyPlugin.MaxPlayers);
		}
	}
	[HarmonyPatch(typeof(PhotonNetwork))]
	internal static class PhotonRoomPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("CreateRoom", new Type[]
		{
			typeof(string),
			typeof(RoomOptions),
			typeof(TypedLobby),
			typeof(string[])
		})]
		private static void CreateRoomPrefix(ref RoomOptions roomOptions)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			if (roomOptions == null)
			{
				roomOptions = new RoomOptions();
			}
			roomOptions.MaxPlayers = HostOnlyLobbyRules.PhotonRoomLimit;
		}
	}
	[HarmonyPatch(typeof(InviteFriendsTerminal))]
	internal static class InviteTerminalPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static bool IsGameFullPrefix(ref bool __result)
		{
			__result = (Object)(object)PlayerHandler.instance != (Object)null && HostOnlyLobbyRules.IsAtCapacity(PlayerHandler.instance.players.Count);
			return false;
		}
	}
	[HarmonyPatch(typeof(RichPresenceHandler))]
	internal static class RichPresencePatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("SetGroupSize")]
		private static void SetGroupSizePrefix(ref int maxSize)
		{
			maxSize = HostOnlyLobbyRules.RichPresenceMaximum(maxSize);
		}
	}
	[HarmonyPatch(typeof(BedBoss))]
	[HarmonyPriority(800)]
	internal static class BedPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnPlayerJoined")]
		private static bool OnPlayerJoinedPrefix(BedBoss __instance)
		{
			if (!PhotonNetwork.IsMasterClient || (Object)(object)PlayerHandler.instance == (Object)null)
			{
				return false;
			}
			int num = HostOnlyLobbyRules.BedAssignmentCount(__instance.beds.Count, PlayerHandler.instance.players.Count);
			PhotonView component = ((Component)__instance).GetComponent<PhotonView>();
			for (int i = 0; i < num; i++)
			{
				Player val = PlayerHandler.instance.players[i];
				component.RPC("AssignBed", (RpcTarget)0, new object[2]
				{
					val.refs.view.ViewID,
					i
				});
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerHandler))]
	internal static class SleepPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("AllPlayersInBed")]
		private static void AllPlayersInBedPostfix(PlayerHandler __instance, ref bool __result)
		{
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < __instance.playersAlive.Count; i++)
			{
				if ((Object)(object)__instance.playersAlive[i].data.currentBed != (Object)null)
				{
					num++;
				}
			}
			__result = HostOnlyLobbyRules.EnoughPlayersReady(__instance.playersAlive.Count, num);
		}

		[HarmonyPostfix]
		[HarmonyPatch("AllPlayersAsleep")]
		private static void AllPlayersAsleepPostfix(PlayerHandler __instance, ref bool __result)
		{
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < __instance.playersAlive.Count; i++)
			{
				if (__instance.playersAlive[i].data.sleepAmount >= 0.9f)
				{
					num++;
				}
			}
			__result = HostOnlyLobbyRules.EnoughPlayersReady(__instance.playersAlive.Count, num);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}