using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSync.Lib;
using CSync.Util;
using FriendlyCompany.NetcodePatcher;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using ravingdead.FriendlyCompany.patch;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("FriendlyCompany")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.0.0.0")]
[assembly: AssemblyInformationalVersion("0.0.0-alpha.0.6+8dd8a9085d93af00abaf381e3e6d8c62065f37cc")]
[assembly: AssemblyProduct("FriendlyCompany")]
[assembly: AssemblyTitle("FriendlyCompany")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 ravingdead.FriendlyCompany
{
	[DataContract]
	public class ModConfig : SyncedConfig<ModConfig>
	{
		internal LogLevel DebugLevel = (LogLevel)16;

		[DataMember]
		public SyncedEntry<bool> ConfigEnableBees { get; private set; }

		public ModConfig(ConfigFile cfg)
			: base("ravingdead.FriendlyCompany")
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			ConfigManager.Register<ModConfig>(this);
			ConfigEnableBees = Extensions.BindSyncedEntry<bool>(cfg, "Toggles", "EnableBees", true, "Whether FriendlyBees should be enabled. Setting this to false will also disable any other features related to bees.");
			Plugin.Log.Log(DebugLevel, (object)$"{ConfigEnableBees.Key} = {ConfigEnableBees.Value}");
			((SyncedInstance<ModConfig>)(object)this).SyncComplete += delegate
			{
				if (!SyncedInstance<ModConfig>.IsHost && !NetworkManager.Singleton.IsServer)
				{
					Plugin.Log.LogInfo((object)"Config synced!");
				}
			};
		}
	}
	[BepInPlugin("ravingdead.FriendlyCompany", "FriendlyCompany", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal const string GUID = "ravingdead.FriendlyCompany";

		internal const string PLUGIN_NAME = "FriendlyCompany";

		internal const string VERSION = "1.1.0";

		private readonly Harmony _harmony = new Harmony("ravingdead.FriendlyCompany");

		public static Plugin Instance { get; set; }

		public static ModConfig ConfigInstance { get; internal set; }

		public static ManualLogSource Log => ((BaseUnityPlugin)Instance).Logger;

		public Plugin()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Instance = this;
		}

		private void Awake()
		{
			try
			{
				Log.LogInfo((object)"Loading mod...");
				Log.LogInfo((object)"Loading config...");
				ConfigInstance = new ModConfig(((BaseUnityPlugin)this).Config);
				Log.LogInfo((object)"Applying Patches...");
				ApplyPluginPatch();
				Log.LogMessage((object)"Loaded FriendlyCompany version 1.1.0 successfully.");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Unexpected error occured when initializing: " + ex.Message + "\nSource: " + ex.Source));
			}
		}

		private void ApplyPluginPatch()
		{
			if (ConfigInstance.ConfigEnableBees.Value)
			{
				_harmony.PatchAll(typeof(RedLocustBeesPatch));
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "FriendlyCompany";

		public const string PLUGIN_NAME = "FriendlyCompany";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ravingdead.FriendlyCompany.patch
{
	public class FriendlyBees : MonoBehaviour
	{
		private RedLocustBees __instance;

		public List<PlayerControllerB> MeanPlayers;

		public PlayerControllerB GetPlayerHeldBy()
		{
			return __instance.hive.playerHeldBy;
		}

		public bool GetIsHeld()
		{
			return __instance.hive.isHeld;
		}

		public bool GetIsHeldByEnemy()
		{
			return __instance.hive.isHeldByEnemy;
		}

		public bool IsPlayerMean(PlayerControllerB player)
		{
			return MeanPlayers.Contains(player);
		}

		public void PrintMeanies()
		{
			if (MeanPlayers.Count != 0)
			{
				Debug.Log((object)$"Mean players (Source: {((Object)__instance).GetInstanceID()})");
				for (int i = 0; i < MeanPlayers.Count; i++)
				{
					PlayerControllerB val = MeanPlayers[i];
					Debug.Log((object)$"[BLAME] {val.playerUsername} (client: {val.playerClientId} - actual: {val.actualClientId} - steam: {val.playerSteamId})");
				}
			}
		}

		public void Initialize(RedLocustBees instance)
		{
			Plugin.Log.LogInfo((object)$"Initializing FriendlyBees component on {((EnemyAI)instance).__getTypeName()} instance {((Object)this).GetInstanceID()}...");
			__instance = instance;
			MeanPlayers = new List<PlayerControllerB>();
		}

		public void AddMeanPlayer()
		{
			if (!IsPlayerMean(GetPlayerHeldBy()))
			{
				Plugin.Log.LogFatal((object)("Player " + GetPlayerHeldBy().playerUsername + " is now logged as a mean person >:O"));
				MeanPlayers.Add(GetPlayerHeldBy());
			}
			else
			{
				Plugin.Log.LogFatal((object)("Player " + GetPlayerHeldBy().playerUsername + " was already a mean person >:("));
			}
		}

		public void TargetMeanPlayer()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogInfo((object)("Target " + ((EnemyAI)__instance).targetPlayer.playerUsername + " is friendly, switching behavior..."));
			PlayerControllerB val = FindNearestMeanPlayer(strict: false, no_default: true);
			if ((Object)(object)val == (Object)null)
			{
				__instance.wasInChase = false;
				if (__instance.IsHiveMissing())
				{
					((EnemyAI)__instance).SwitchToBehaviourState(1);
					((EnemyAI)__instance).StartSearch(((Component)this).transform.position, __instance.searchForHive);
				}
				else
				{
					((EnemyAI)__instance).SwitchToBehaviourState(0);
					((EnemyAI)__instance).targetPlayer = val;
				}
			}
		}

		public PlayerControllerB FindNearestMeanPlayer(bool strict = false, bool no_default = false)
		{
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB[] allPlayersInLineOfSight = ((EnemyAI)__instance).GetAllPlayersInLineOfSight(360f, 16, (Transform)null, -1f, -1);
			PlayerControllerB val = null;
			if (allPlayersInLineOfSight != null)
			{
				float num = 3000f;
				int num2 = 0;
				int num3 = -1;
				for (int i = 0; i < allPlayersInLineOfSight.Length; i++)
				{
					if ((Object)(object)allPlayersInLineOfSight[i].currentlyHeldObjectServer != (Object)null)
					{
						if (num3 == -1 && allPlayersInLineOfSight[i].currentlyHeldObjectServer.itemProperties.itemId == 1531)
						{
							num3 = i;
							continue;
						}
						if ((Object)(object)allPlayersInLineOfSight[i].currentlyHeldObjectServer == (Object)(object)__instance.hive)
						{
							Plugin.Log.LogInfo((object)"Defaulting to hive thief (source: You shouldn't have done that.)");
							num3 = -1;
							val = allPlayersInLineOfSight[i];
							break;
						}
					}
					if ((!strict || (strict && (Object)(object)((EnemyAI)__instance).targetPlayer == (Object)null)) && IsPlayerMean(allPlayersInLineOfSight[i]))
					{
						float num4 = Vector3.Distance(((Component)this).transform.position, ((Component)allPlayersInLineOfSight[i]).transform.position);
						if (num4 < num)
						{
							num = num4;
							num2 = i;
						}
					}
				}
				if (num3 != -1 && Vector3.Distance(((Component)this).transform.position, ((Component)allPlayersInLineOfSight[num3]).transform.position) - num > 7f)
				{
					Plugin.Log.LogInfo((object)"Defaulting to nearest player (source: Small float difference to tie breaker.)");
					val = allPlayersInLineOfSight[num2];
				}
				else if ((Object)(object)val == (Object)null && !no_default)
				{
					Plugin.Log.LogInfo((object)"Defaulting to nearest player (source: No hive in sight.)");
					val = allPlayersInLineOfSight[num2];
				}
				else if ((Object)(object)val == (Object)null && no_default)
				{
					Plugin.Log.LogInfo((object)"Defaulting to null (source: No hive or mean player in sight.)");
				}
			}
			return val;
		}
	}
	[HarmonyPatch(typeof(RedLocustBees))]
	public class RedLocustBeesPatch
	{
		private static FriendlyBees friendlyBees;

		private static FriendlyBees GetComponent(RedLocustBees instance)
		{
			return ((Component)instance).gameObject.GetComponent<FriendlyBees>();
		}

		[HarmonyPatch(typeof(RedLocustBees), "Start")]
		[HarmonyPrefix]
		private static void StartPostFix(ref RedLocustBees __instance)
		{
			Plugin.Log.LogDebug((object)"Bees found!");
			friendlyBees = ((Component)__instance).gameObject.AddComponent<FriendlyBees>();
			friendlyBees.Initialize(__instance);
		}

		[HarmonyPatch(typeof(RedLocustBees), "DoAIInterval")]
		[HarmonyPrefix]
		private static void DoAIInterval_Pre(ref RedLocustBees __instance)
		{
			if (friendlyBees.GetIsHeld() && !friendlyBees.GetIsHeldByEnemy())
			{
				friendlyBees.AddMeanPlayer();
			}
			if ((Object)(object)((EnemyAI)__instance).targetPlayer != (Object)null && !friendlyBees.IsPlayerMean(((EnemyAI)__instance).targetPlayer))
			{
				friendlyBees.TargetMeanPlayer();
			}
		}

		[HarmonyPatch(typeof(RedLocustBees), "Update")]
		[HarmonyPostfix]
		private static void Update_Post(ref RedLocustBees __instance)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (((EnemyAI)__instance).currentBehaviourStateIndex != 1)
			{
				return;
			}
			PlayerControllerB closestPlayer = ((EnemyAI)__instance).GetClosestPlayer(false, false, false);
			if (friendlyBees.IsPlayerMean(closestPlayer))
			{
				return;
			}
			float num = Time.deltaTime * 0.7f;
			__instance.beesZappingMode = 0;
			__instance.ResetBeeZapTimer();
			((EnemyAI)__instance).agent.speed = 4f;
			((EnemyAI)__instance).agent.acceleration = 13f;
			if (!__instance.overrideBeeParticleTarget)
			{
				float num2 = Vector3.Distance(((Component)__instance).transform.position, ((Component)__instance.hive).transform.position);
				if ((Object)(object)__instance.hive != (Object)null && (num2 < 2f || (num2 < 5f && !Physics.Linecast(((EnemyAI)__instance).eye.position, ((Component)__instance.hive).transform.position + Vector3.up * 0.5f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))))
				{
					__instance.beeParticlesTarget.position = ((Component)__instance.hive).transform.position;
				}
				else
				{
					__instance.beeParticlesTarget.position = ((Component)__instance).transform.position + Vector3.up * 1.5f;
				}
			}
			__instance.beesIdle.volume = Mathf.Min(__instance.beesIdle.volume + num, 1f);
			if (!__instance.beesIdle.isPlaying)
			{
				__instance.beesIdle.Play();
			}
			__instance.beesDefensive.volume = Mathf.Max(__instance.beesDefensive.volume - num, 0f);
			if (__instance.beesDefensive.isPlaying && __instance.beesDefensive.volume <= 0f)
			{
				__instance.beesDefensive.Stop();
			}
			__instance.beesAngry.volume = Mathf.Max(__instance.beesAngry.volume - num, 0f);
			if (__instance.beesAngry.isPlaying && __instance.beesAngry.volume <= 0f)
			{
				__instance.beesAngry.Stop();
			}
		}

		[HarmonyPatch(typeof(RedLocustBees), "ChaseWithPriorities")]
		[HarmonyPrefix]
		private static bool ChaseWithPriorities_Pre(ref RedLocustBees __instance, ref PlayerControllerB __result)
		{
			__result = friendlyBees.FindNearestMeanPlayer(strict: true);
			return false;
		}

		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static bool OnCollideWithPlayer_Pre(Collider other, ref RedLocustBees __instance)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if (((EnemyAI)__instance).debugEnemyAI)
			{
				Debug.Log((object)(((Object)((Component)__instance).gameObject).name + ": Collided with player!"));
			}
			if (__instance.timeSinceHittingPlayer >= 0.4f)
			{
				PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
				if ((Object)(object)val != (Object)null && friendlyBees.IsPlayerMean(val))
				{
					friendlyBees.PrintMeanies();
					__instance.timeSinceHittingPlayer = 0f;
					if (val.health <= 10 || val.criticallyInjured)
					{
						__instance.BeeKillPlayerOnLocalClient((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
						__instance.BeeKillPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
					}
					else
					{
						val.DamagePlayer(10, true, true, (CauseOfDeath)11, 3, false, default(Vector3));
					}
					if (__instance.beesZappingMode != 3)
					{
						__instance.beesZappingMode = 3;
						__instance.EnterAttackZapModeServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
					}
				}
			}
			return false;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace FriendlyCompany.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}