using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AutoTerminalScanClassic.Managers;
using AutoTerminalScanClassic.Utils;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.aoirint.AutoTerminalScanClassic")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: AssemblyInformationalVersion("0.1.1+e0eed92637d6df60782d1459e7170af45e66a4f9")]
[assembly: AssemblyProduct("AutoTerminalScanClassic")]
[assembly: AssemblyTitle("com.aoirint.AutoTerminalScanClassic")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.1.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 AutoTerminalScanClassic
{
	public enum BroadcastMode
	{
		SelfOnly,
		HostOnly,
		Always
	}
	[BepInPlugin("com.aoirint.AutoTerminalScanClassic", "AutoTerminalScanClassic", "0.1.1")]
	[BepInProcess("Lethal Company.exe")]
	public class AutoTerminalScanClassic : BaseUnityPlugin
	{
		internal static Harmony harmony = new Harmony("com.aoirint.AutoTerminalScanClassic");

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

		internal static AutoTerminalScanManager AutoTerminalScanManager { get; } = new AutoTerminalScanManager();


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

		internal static ConfigEntry<BroadcastMode>? BroadcastModeConfig { get; private set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			EnabledConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Set to false to disable this mod.");
			BroadcastModeConfig = ((BaseUnityPlugin)this).Config.Bind<BroadcastMode>("General", "BroadcastMode", BroadcastMode.SelfOnly, "Controls whether this mod sends scan results to other players. If SelfOnly, you can still see scan results but not send to other players. If HostOnly, you send scan results to other players only when you are the host. If Always, you always send scan results to other players.");
			harmony.PatchAll();
			Logger.LogInfo((object)"Plugin AutoTerminalScanClassic v0.1.1 is loaded!");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.aoirint.AutoTerminalScanClassic";

		public const string PLUGIN_NAME = "AutoTerminalScanClassic";

		public const string PLUGIN_VERSION = "0.1.1";
	}
}
namespace AutoTerminalScanClassic.Generated
{
	internal static class ModInfo
	{
		public const string GUID = "com.aoirint.AutoTerminalScanClassic";

		public const string NAME = "AutoTerminalScanClassic";

		public const string VERSION = "0.1.1";
	}
}
namespace AutoTerminalScanClassic.Utils
{
	internal static class ChatUtils
	{
		internal static ManualLogSource Logger => AutoTerminalScanClassic.Logger;

		public static bool SendChatToSelfOnly(string message)
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				Logger.LogError((object)"HUDManager.Instance is null.");
				return false;
			}
			GameNetworkManager instance2 = GameNetworkManager.Instance;
			if ((Object)(object)instance2 == (Object)null)
			{
				Logger.LogError((object)"GameNetworkManager.Instance is null.");
				return false;
			}
			PlayerControllerB localPlayerController = instance2.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)null)
			{
				Logger.LogError((object)"gameNetworkManager.localPlayerController is null.");
				return false;
			}
			string playerUsername = localPlayerController.playerUsername;
			instance.AddChatMessage(message, playerUsername, -1, false);
			return true;
		}

		public static bool SendChatToEveryone(string message)
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				Logger.LogError((object)"HUDManager.Instance is null.");
				return false;
			}
			GameNetworkManager instance2 = GameNetworkManager.Instance;
			if ((Object)(object)instance2 == (Object)null)
			{
				Logger.LogError((object)"GameNetworkManager.Instance is null.");
				return false;
			}
			PlayerControllerB localPlayerController = instance2.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)null)
			{
				Logger.LogError((object)"gameNetworkManager.localPlayerController is null.");
				return false;
			}
			int num = (int)localPlayerController.playerClientId;
			instance.AddTextToChatOnServer(message, num);
			return true;
		}
	}
	internal static class NetworkUtils
	{
		internal static ManualLogSource Logger => AutoTerminalScanClassic.Logger;

		public static bool IsServer()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null)
			{
				Logger.LogError((object)"NetworkManager.Singleton is null.");
				return false;
			}
			return singleton.IsServer;
		}

		public static bool IsHost()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null)
			{
				Logger.LogError((object)"NetworkManager.Singleton is null.");
				return false;
			}
			return singleton.IsHost;
		}

		public static bool IsClient()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null)
			{
				Logger.LogError((object)"NetworkManager.Singleton is null.");
				return false;
			}
			return singleton.IsClient;
		}
	}
	internal static class TerminalUtils
	{
		internal static ManualLogSource Logger => AutoTerminalScanClassic.Logger;

		public static int? ScanItemCount()
		{
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			int num = 0;
			GrabbableObject[] array2 = array;
			foreach (GrabbableObject val in array2)
			{
				Item itemProperties = val.itemProperties;
				if ((Object)(object)itemProperties == (Object)null)
				{
					Logger.LogError((object)"grabbableObject.itemProperties is null.");
					return null;
				}
				if (itemProperties.isScrap && !val.isInShipRoom && !val.isInElevator)
				{
					num++;
				}
			}
			Logger.LogDebug((object)$"Scanned and found {num} items.");
			return num;
		}
	}
}
namespace AutoTerminalScanClassic.Patches
{
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatch
	{
		internal static ManualLogSource Logger => AutoTerminalScanClassic.Logger;

		[HarmonyPatch("FinishGeneratingNewLevelClientRpc")]
		[HarmonyPostfix]
		public static void FinishGeneratingNewLevelClientRpcPostfix(RoundManager __instance)
		{
			if (!NetworkUtils.IsClient())
			{
				Logger.LogDebug((object)"Not the client. Skipping FinishGeneratingNewLevelClientRpcPostfix.");
				return;
			}
			AutoTerminalScanManager autoTerminalScanManager = AutoTerminalScanClassic.AutoTerminalScanManager;
			if (autoTerminalScanManager == null)
			{
				Logger.LogError((object)"AutoTerminalScanManager is null.");
			}
			else
			{
				autoTerminalScanManager.ResetAndScanForNewLevel();
			}
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal class TimeOfDayPatch
	{
		internal static ManualLogSource Logger => AutoTerminalScanClassic.Logger;

		[HarmonyPatch("MoveTimeOfDay")]
		[HarmonyPostfix]
		public static void MoveTimeOfDayPostfix(TimeOfDay __instance)
		{
			if (!NetworkUtils.IsClient())
			{
				Logger.LogDebug((object)"Not the client. Skipping AdvanceHourAndSpawnNewBatchOfEnemiesPostfix.");
				return;
			}
			float num = __instance.globalTime - 100f;
			float globalTimeSpeedMultiplier = __instance.globalTimeSpeedMultiplier;
			if (!(num < globalTimeSpeedMultiplier))
			{
				AutoTerminalScanManager autoTerminalScanManager = AutoTerminalScanClassic.AutoTerminalScanManager;
				if (autoTerminalScanManager == null)
				{
					Logger.LogError((object)"AutoTerminalScanManager is null.");
				}
				else
				{
					autoTerminalScanManager.ScanAndSendChatOnce();
				}
			}
		}
	}
}
namespace AutoTerminalScanClassic.Managers
{
	internal class AutoTerminalScanManager
	{
		private int? itemCountOnLevelLoadedNullable;

		private bool hasSentChatToday;

		internal static ManualLogSource Logger => AutoTerminalScanClassic.Logger;

		public void ResetAndScanForNewLevel()
		{
			ConfigEntry<bool>? enabledConfig = AutoTerminalScanClassic.EnabledConfig;
			if (enabledConfig != null && !enabledConfig.Value)
			{
				hasSentChatToday = true;
				return;
			}
			itemCountOnLevelLoadedNullable = null;
			hasSentChatToday = false;
			int? num = TerminalUtils.ScanItemCount();
			if (!num.HasValue)
			{
				Logger.LogError((object)"itemCount is null.");
				return;
			}
			itemCountOnLevelLoadedNullable = num;
			Logger.LogDebug((object)("Level loaded scan complete." + $" itemCountOnLevelLoaded={num}"));
		}

		public void ScanAndSendChatOnce()
		{
			if (hasSentChatToday)
			{
				return;
			}
			ConfigEntry<bool>? enabledConfig = AutoTerminalScanClassic.EnabledConfig;
			if (enabledConfig != null && !enabledConfig.Value)
			{
				hasSentChatToday = true;
				Logger.LogDebug((object)"Not enabled.");
				return;
			}
			BroadcastMode broadcastMode = AutoTerminalScanClassic.BroadcastModeConfig?.Value ?? BroadcastMode.SelfOnly;
			if (!itemCountOnLevelLoadedNullable.HasValue)
			{
				Logger.LogError((object)"itemCountOnLevelLoaded is null.");
				return;
			}
			int value = itemCountOnLevelLoadedNullable.Value;
			int? num = TerminalUtils.ScanItemCount();
			if (!num.HasValue)
			{
				Logger.LogError((object)"itemCountOnHourAdvanced is null.");
				return;
			}
			int value2 = num.Value;
			int num2 = value2 - value;
			Logger.LogDebug((object)("Hour advanced scan complete. " + $" itemCountOnLevelLoaded={value}" + $" itemCountOnHourAdvanced={value2}" + $" itemCountDifference={num2}"));
			string text = $"{value} {num2}";
			if (broadcastMode switch
			{
				BroadcastMode.SelfOnly => ChatUtils.SendChatToSelfOnly(text) ? 1 : 0, 
				BroadcastMode.HostOnly => (NetworkUtils.IsHost() ? ChatUtils.SendChatToEveryone(text) : ChatUtils.SendChatToSelfOnly(text)) ? 1 : 0, 
				_ => ChatUtils.SendChatToEveryone(text) ? 1 : 0, 
			} == 0)
			{
				Logger.LogError((object)("Failed to send chat message. message=" + text));
				return;
			}
			Logger.LogDebug((object)("Sent chat message successfully. message=" + text));
			hasSentChatToday = true;
		}
	}
}