using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib;
using BubbleInfinity;
using HarmonyLib;
using LabFusion.Marrow.Integration;
using LabFusion.Network;
using LabFusion.Player;
using LabFusion.SDK.Extenders;
using LabFusion.Scene;
using LabFusion.Senders;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(HostAddon), "Bubble Infinity Host", "0.3.1", "Tapochnik", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 BubbleInfinity
{
	public sealed class HostAddon : MelonMod
	{
		internal static HostAddon Instance;

		internal static Transform Destination;

		private static float _nextLookup;

		private static readonly Dictionary<byte, float> LastRequest = new Dictionary<byte, float>();

		public override void OnInitializeMelon()
		{
			Instance = this;
			((MelonBase)this).LoggerInstance.Msg("Surface return: local native RigManager teleport; guests use existing Fusion RPC/PlayerRepTeleport packets. No guest addon required.");
		}

		public override void OnUpdate()
		{
			try
			{
				if (Time.unscaledTime >= _nextLookup)
				{
					_nextLookup = Time.unscaledTime + 0.5f;
					GameObject val = GameObject.Find("BI_Return_To_Surface_Destination");
					Destination = (Object.op_Implicit((Object)(object)val) ? val.transform : null);
				}
				if (Object.op_Implicit((Object)(object)Destination) && !(Shader.GetGlobalFloat("_BI_ReturnRequested") < 0.5f))
				{
					Shader.SetGlobalFloat("_BI_ReturnRequested", 0f);
					if (!NetworkInfo.HasServer || NetworkInfo.IsHost)
					{
						TeleportLocal();
					}
				}
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Warning("Return request: " + ex.Message);
			}
		}

		private static void TeleportLocal()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Destination) && Object.op_Implicit((Object)(object)Player.RigManager))
			{
				if (NetworkInfo.HasServer)
				{
					LocalPlayer.TeleportToPosition(Destination.position, Destination.forward);
				}
				else
				{
					Player.RigManager.Teleport(Destination.position, Destination.forward, true);
				}
				((MelonBase)Instance).LoggerInstance.Msg("Returned local player to surface without scene reload.");
			}
		}

		internal static bool HandleGuest(ReceivedMessage received)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Destination) || !NetworkInfo.IsHost)
			{
				return false;
			}
			RPCEvent val = default(RPCEvent);
			if (!((ReceivedMessage)(ref received)).ReadData<ComponentPathData>().TryGetComponent<RPCEvent, RPCEventExtender>(RPCEvent.HashTable, ref val) || !Object.op_Implicit((Object)(object)val) || ((Object)((Component)val).gameObject).name != "BI_Return_Request")
			{
				return false;
			}
			if (!((ReceivedMessage)(ref received)).Sender.HasValue)
			{
				return true;
			}
			byte value = ((ReceivedMessage)(ref received)).Sender.Value;
			PlayerID playerID = PlayerIDManager.GetPlayerID(value);
			if (playerID == null || !NetworkSceneManager.InCurrentLevel(playerID))
			{
				return true;
			}
			if (LastRequest.TryGetValue(value, out var value2) && Time.unscaledTime - value2 < 0.75f)
			{
				return true;
			}
			LastRequest[value] = Time.unscaledTime;
			if (value == PlayerIDManager.LocalSmallID)
			{
				TeleportLocal();
			}
			else
			{
				PlayerSender.SendPlayerTeleport(value, Destination.position);
			}
			((MelonBase)Instance).LoggerInstance.Msg("Sent standard Fusion surface teleport to player " + value + " (guest addon not required).");
			return true;
		}
	}
	[HarmonyPatch(typeof(RPCEventMessage), "OnHandleMessage")]
	internal static class ReturnRequestPatch
	{
		private static bool Prefix(ReceivedMessage received)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return !HostAddon.HandleGuest(received);
			}
			catch (Exception ex)
			{
				HostAddon instance = HostAddon.Instance;
				if (instance != null)
				{
					((MelonBase)instance).LoggerInstance.Warning("Guest return request: " + ex.Message);
				}
				return true;
			}
		}
	}
}