using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using MKCConfig.Modules;
using MKCOptions;
using RandomMoonModule;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("TeleportOnStart")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("TeleportOnStart")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("cab8e5d2-d03f-45d6-87ae-c4c178e7df7e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("MrKixcat.MKCConfig", "MKCConfig", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
	public static Plugin Instance;

	public static Config ConfigInstance;

	private void Awake()
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		ConfigInstance = new Config(((BaseUnityPlugin)this).Config);
		if ((Object)(object)Instance == (Object)null)
		{
			Instance = this;
		}
		Harmony val = new Harmony("MrKixcat.MKCConfig");
		val.PatchAll(Assembly.GetExecutingAssembly());
		Debug.Log((object)"MKCConfig initialized!");
	}
}
public class ScrapReporterModule : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <DelayedReport>d__7 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public ScrapReporterModule <>4__this;

		private (int interior, int exterior) <counts>5__1;

		private string <msg>5__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(<>4__this.delaySeconds);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (!HasReported)
				{
					HasReported = true;
					<counts>5__1 = ScanScrapInScene();
					<msg>5__2 = $"Début de round ! Scrap : Intérieur = {<counts>5__1.interior}, Extérieur = {<counts>5__1.exterior}";
					SendChatMessage(<msg>5__2);
					Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
					<msg>5__2 = null;
				}
				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 static ManualLogSource Logger;

	private float delaySeconds = 1f;

	private static bool HasReported;

	public void Init(ManualLogSource logger, float delay = 1f)
	{
		Logger = logger;
		delaySeconds = delay;
	}

	public static (int interior, int exterior) ScanScrapInScene()
	{
		int num = 0;
		int num2 = 0;
		GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
		GrabbableObject[] array2 = array;
		foreach (GrabbableObject val in array2)
		{
			if (!((Object)(object)val == (Object)null) && val.itemProperties.isScrap && !val.isInShipRoom)
			{
				if (val.isInFactory && !val.itemProperties.itemName.Equals("Hive") && !val.itemProperties.itemName.Equals("Egg"))
				{
					num++;
				}
				else
				{
					num2++;
				}
			}
		}
		return (num, num2);
	}

	public static void SendChatMessage(string message)
	{
		HUDManager instance = HUDManager.Instance;
		PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
		if ((Object)(object)instance == (Object)null || (Object)(object)val == (Object)null || ((Object)TimeOfDay.Instance.currentLevel).name.Equals("CompanyBuildingLevel"))
		{
			Debug.LogWarning((object)"[ScrapReporter] Cannot send message, HUD or player null.");
		}
		else
		{
			instance.AddTextToChatOnServer(message, -1);
		}
	}

	public void StartScrapReport()
	{
		((MonoBehaviour)this).StartCoroutine(DelayedReport());
	}

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

	public static void ResetReportFlag()
	{
		HasReported = false;
	}
}
namespace MKCConfig.Modules
{
	public class TeleportModule : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <TeleportAllPlayersCoroutine>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public TeleportModule <>4__this;

			private float <configDelay>5__1;

			private RoundManager <rm>5__2;

			private GameObject[] <nodes>5__3;

			private PlayerControllerB[] <>s__4;

			private int <>s__5;

			private PlayerControllerB <player>5__6;

			private int <randomIndex>5__7;

			private Transform <randomNode>5__8;

			private Vector3 <pos>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<rm>5__2 = null;
				<nodes>5__3 = null;
				<>s__4 = null;
				<player>5__6 = null;
				<randomNode>5__8 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Expected O, but got Unknown
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (HasTeleported)
					{
						return false;
					}
					HasTeleported = true;
					if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsHost)
					{
						return false;
					}
					<configDelay>5__1 = (float)Config.TeleportDelay.Value / 1000f;
					if (<configDelay>5__1 > 0f)
					{
						<>2__current = (object)new WaitForSeconds(<configDelay>5__1);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<rm>5__2 = RoundManager.Instance;
				if ((Object)(object)<rm>5__2 == (Object)null)
				{
					Debug.LogError((object)"[TeleportModule] RoundManager is null. Cannot teleport.");
					return false;
				}
				<nodes>5__3 = <rm>5__2.insideAINodes;
				if (<nodes>5__3 == null || <nodes>5__3.Length == 0)
				{
					Debug.LogError((object)"[TeleportModule] No inside AI nodes found (Array is empty).");
					return false;
				}
				if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.allPlayerScripts == null)
				{
					return false;
				}
				<>s__4 = StartOfRound.Instance.allPlayerScripts;
				for (<>s__5 = 0; <>s__5 < <>s__4.Length; <>s__5++)
				{
					<player>5__6 = <>s__4[<>s__5];
					if (!((Object)(object)<player>5__6 == (Object)null) && !<player>5__6.isPlayerDead && !(<player>5__6.playerUsername == ""))
					{
						<randomIndex>5__7 = Random.Range(0, <nodes>5__3.Length);
						if (!((Object)(object)<nodes>5__3[<randomIndex>5__7] == (Object)null))
						{
							<randomNode>5__8 = <nodes>5__3[<randomIndex>5__7].transform;
							<pos>5__9 = <rm>5__2.GetRandomNavMeshPositionInRadius(<randomNode>5__8.position, 15f, default(NavMeshHit));
							if (<pos>5__9 != Vector3.zero)
							{
								<>4__this.TeleportClientRpc(<player>5__6.playerClientId, <pos>5__9);
							}
							else
							{
								Debug.LogWarning((object)("[TeleportModule] Could not find valid NavMesh position for player " + <player>5__6.playerUsername + "."));
							}
							<randomNode>5__8 = null;
							<player>5__6 = null;
						}
					}
				}
				<>s__4 = null;
				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();
			}
		}

		public static TeleportModule Instance;

		public static bool HasTeleported;

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

		private void PerformTeleport(PlayerControllerB player, Vector3 pos)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00b0: Invalid comparison between Unknown and I4
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected I4, but got Unknown
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			Terminal val = Object.FindObjectOfType<Terminal>();
			if ((Object)(object)val != (Object)null && val.terminalInUse && player.inTerminalMenu)
			{
				val.QuitTerminal(true);
			}
			if (((NetworkBehaviour)player).IsOwner && (Object)(object)HUDManager.Instance != (Object)null)
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
			}
			player.TeleportPlayer(pos, false, 0f, true, true);
			player.isInsideFactory = true;
			player.isInElevator = false;
			player.isInHangarShipRoom = false;
			player.velocityLastFrame = Vector3.zero;
			if ((Object)(object)TimeOfDay.Instance != (Object)null && (int)TimeOfDay.Instance.currentLevelWeather != -1)
			{
				int num = (int)TimeOfDay.Instance.currentLevelWeather;
				if (num >= 0 && num < TimeOfDay.Instance.effects.Length)
				{
					TimeOfDay.Instance.effects[num].effectEnabled = false;
				}
			}
		}

		[ClientRpc]
		public void TeleportClientRpc(ulong clientId, Vector3 pos)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)StartOfRound.Instance == (Object)null))
			{
				PlayerControllerB val = ((IEnumerable<PlayerControllerB>)StartOfRound.Instance.allPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB p) => p.playerClientId == clientId));
				if ((Object)(object)val != (Object)null && ((NetworkBehaviour)val).IsOwner)
				{
					PerformTeleport(val, pos);
				}
			}
		}

		public static void ResetTeleportedFlag()
		{
			HasTeleported = false;
		}
	}
}
namespace MKCConfig.Patches
{
	[HarmonyPatch(typeof(StartOfRound))]
	internal class MasterPatch_RandomMoon
	{
		[HarmonyPrefix]
		[HarmonyPatch("StartGame")]
		private static void Prefix_StartGame()
		{
			if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsHost && Config.EnableRandomMoon.Value)
			{
				RandomMoonRouter.ResetStartedFlag();
				Debug.Log((object)"[RandomMoon] Routing to a random moon");
				RandomMoonRouter.RouteToRandomPlanet();
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class MasterPatch_ScrapReporter
	{
		[HarmonyPostfix]
		[HarmonyPatch("openingDoorsSequence")]
		private static void Postfix_LevelGenerated()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsHost && Config.EnableScrapReporter.Value)
			{
				ScrapReporterModule.ResetReportFlag();
				GameObject val = new GameObject("ScrapReporter");
				ScrapReporterModule scrapReporterModule = val.AddComponent<ScrapReporterModule>();
				scrapReporterModule.Init(null, 2f);
				((MonoBehaviour)scrapReporterModule).StartCoroutine(scrapReporterModule.DelayedReport());
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class MasterPatch_Teleport
	{
		[CompilerGenerated]
		private sealed class <WaitForDoorsThenTeleport>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private float <timeOut>5__1;

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

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

			[DebuggerHidden]
			public <WaitForDoorsThenTeleport>d__1(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;
					if ((Object)(object)StartOfRound.Instance == (Object)null)
					{
						return false;
					}
					Debug.Log((object)"[Teleport] Waiting for ship doors to open...");
					<timeOut>5__1 = 10f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)StartOfRound.Instance != (Object)null && !StartOfRound.Instance.shipDoorsEnabled && <timeOut>5__1 > 0f)
				{
					<timeOut>5__1 -= Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)TeleportModule.Instance == (Object)null)
				{
					return false;
				}
				Debug.Log((object)"[Teleport] Ship doors open (or timeout). Teleporting players...");
				((MonoBehaviour)TeleportModule.Instance).StartCoroutine(TeleportModule.Instance.TeleportAllPlayersCoroutine());
				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();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SceneManager_OnLoadComplete1")]
		private static void Postfix_SceneLoad()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)TimeOfDay.Instance == (Object)null || !Config.EnableTeleport.Value || (Object)(object)TimeOfDay.Instance.currentLevel == (Object)null || ((Object)TimeOfDay.Instance.currentLevel).name.Equals("CompanyBuildingLevel"))
			{
				return;
			}
			TeleportModule.ResetTeleportedFlag();
			if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.Singleton.IsHost && !((Object)(object)((Component)StartOfRound.Instance).gameObject == (Object)null))
			{
				if ((Object)(object)TeleportModule.Instance == (Object)null)
				{
					TeleportModule.Instance = ((Component)StartOfRound.Instance).gameObject.AddComponent<TeleportModule>();
				}
				((MonoBehaviour)TeleportModule.Instance).StartCoroutine(WaitForDoorsThenTeleport());
			}
		}

		[IteratorStateMachine(typeof(<WaitForDoorsThenTeleport>d__1))]
		private static IEnumerator WaitForDoorsThenTeleport()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForDoorsThenTeleport>d__1(0);
		}
	}
}
namespace RandomMoonModule
{
	public static class RandomMoonRouter
	{
		public static bool HasStarted = false;

		public static string MoonBlacklistStr = Config.MoonBlacklist.Value;

		private static List<string> MoonBlacklist = new List<string>();

		private static void SetupBlacklist()
		{
			MoonBlacklist.Clear();
			if (!string.IsNullOrEmpty(MoonBlacklistStr))
			{
				MoonBlacklist = (from s in MoonBlacklistStr.Split(new char[1] { ',' })
					select s.Trim().ToLowerInvariant()).ToList();
			}
		}

		public static void RouteToRandomPlanet()
		{
			if (HasStarted || (Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsHost)
			{
				return;
			}
			SetupBlacklist();
			if (TimeOfDay.Instance.daysUntilDeadline == 0 && TimeOfDay.Instance.profitQuota > TimeOfDay.Instance.quotaFulfilled)
			{
				StartOfRound.Instance.ChangeLevel(3);
				StartOfRound.Instance.ArriveAtLevel();
				HasStarted = true;
				return;
			}
			List<SelectableLevel> source = StartOfRound.Instance.levels.ToList();
			List<SelectableLevel> list = source.Where((SelectableLevel m) => !MoonBlacklist.Contains(((Object)m).name.Trim().ToLowerInvariant()) && ((Object)m).name != ((Object)TimeOfDay.Instance.currentLevel).name).ToList();
			if (list.Count == 0)
			{
				list = source.Where((SelectableLevel m) => ((Object)m).name != ((Object)TimeOfDay.Instance.currentLevel).name).ToList();
			}
			SelectableLevel val = list[Random.Range(0, list.Count)];
			StartOfRound.Instance.ChangeLevel(val.levelID);
			StartOfRound.Instance.ArriveAtLevel();
			HasStarted = true;
			Debug.Log((object)("[RandomMoonModule] Routed to moon " + ((Object)val).name + "."));
		}

		public static void ResetStartedFlag()
		{
			HasStarted = false;
		}
	}
}
namespace MKCOptions
{
	public class Config
	{
		public static ConfigEntry<bool> EnableTeleport;

		public static ConfigEntry<int> TeleportDelay;

		public static ConfigEntry<bool> EnableScrapReporter;

		public static ConfigEntry<bool> EnableRandomMoon;

		public static ConfigEntry<string> MoonBlacklist;

		public static ConfigEntry<bool> EnableClientLever;

		public Config(ConfigFile config)
		{
			EnableTeleport = config.Bind<bool>("TeleportOnStart", "Enable Teleport", true, "Teleport all players when a round starts.");
			TeleportDelay = config.Bind<int>("TeleportOnStart", "Teleport Delay", 0, "Delay before being teleported (ms)");
			EnableScrapReporter = config.Bind<bool>("ScrapReporter", "Enable Scrap Reporter", true, "Scan inside/outside scrap and send results in chat at round start.");
			EnableRandomMoon = config.Bind<bool>("RandomMoon", "Enable Random Moon", true, "Pick a random moon automatically when the ship starts.");
			MoonBlacklist = config.Bind<string>("RandomMoon", "Moon Blacklist", "CompanyBuildingLevel,LiquidationLevel", "Comma-separated list of moons to exclude.");
			EnableClientLever = config.Bind<bool>("ShipLever", "Enable Client Ship Lever", true, "Permet aux clients (non-hôtes) d'utiliser le levier de décollage du vaisseau.");
		}
	}
}