using System;
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.Bootstrap;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using MaskedModelReplacement.Patches;
using ModelReplacement;
using ModelReplacement.Monobehaviors.Enemies;
using ModelReplacement.Scripts.Enemies;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("MaskedModelReplacement")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("MaskedModelReplacement")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e8c0087e-4258-4043-a787-7ded3d04acd6")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.1.0")]
namespace MaskedModelReplacement
{
	[BepInPlugin("CubeMath.MaskedModelReplacementMod", "Masked Model Replacement", "1.0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MaskedModelReplacementBase : BaseUnityPlugin
	{
		private const string modGUID = "CubeMath.MaskedModelReplacementMod";

		private const string modName = "Masked Model Replacement";

		private const string modVersion = "1.0.1.0";

		private readonly Harmony harmony = new Harmony("CubeMath.MaskedModelReplacementMod");

		public static MaskedModelReplacementBase Instance;

		public ManualLogSource Logger;

		public static bool modelReplacementPresent;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Logger = Logger.CreateLogSource("CubeMath.MaskedModelReplacementMod");
			Logger.LogInfo((object)"Init Masked Model Replacement");
			modelReplacementPresent = Chainloader.PluginInfos.ContainsKey("meow.ModelReplacementAPI");
			harmony.PatchAll(typeof(MaskedModelReplacementBase));
			harmony.PatchAll(typeof(MaskedPlayerEnemyPatch));
			if (modelReplacementPresent)
			{
				harmony.PatchAll(typeof(ModelReplacementPatch));
			}
		}
	}
}
namespace MaskedModelReplacement.Patches
{
	internal class MaskedPlayerEnemyPatch
	{
		public static int NumSpawnedThisLevel;

		public static int MaxHealth { get; private set; }

		[HarmonyPatch(typeof(MaskedPlayerEnemy), "Start")]
		[HarmonyPostfix]
		private static void Start(MaskedPlayerEnemy __instance)
		{
			if (!MaskedModelReplacementBase.modelReplacementPresent)
			{
				Random random = new Random(StartOfRound.Instance.randomMapSeed + NumSpawnedThisLevel);
				UnlockableSuit[] array = (from suit in Resources.FindObjectsOfTypeAll<UnlockableSuit>()
					where ((NetworkBehaviour)suit).IsSpawned
					select suit).ToArray();
				UnlockableSuit val = array[random.Next(array.ToArray().Length)];
				MaskedModelReplacementBase.Instance.Logger.LogInfo((object)$"target_suit {val}");
				__instance.SetSuit(val.suitID);
			}
			MaxHealth = ((EnemyAI)__instance).enemyHP;
			NumSpawnedThisLevel++;
		}
	}
	internal class ModelReplacementPatch
	{
		public static int NumSpawnedThisLevel;

		[HarmonyPatch(typeof(MaskedReplacementBase), "Awake")]
		[HarmonyPrefix]
		private static bool Awake(MaskedReplacementBase __instance, ref MaskedPlayerEnemy ___enemyAI)
		{
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			___enemyAI = ((Component)__instance).GetComponent<MaskedPlayerEnemy>();
			if (ModelReplacementAPI.MRAPI_NetworkingPresent)
			{
				return false;
			}
			PlayerControllerB mimickingPlayer = ___enemyAI.mimickingPlayer;
			bool flag = false;
			BodyReplacementBase val = null;
			BodyReplacementBase val2 = null;
			if ((Object)(object)mimickingPlayer != (Object)null)
			{
				BodyReplacementBase val3 = default(BodyReplacementBase);
				flag = ModelReplacementAPI.GetPlayerModelReplacement(mimickingPlayer, ref val3);
				val = val3;
			}
			else
			{
				Random random = new Random(StartOfRound.Instance.randomMapSeed + NumSpawnedThisLevel);
				List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
				UnlockableSuit[] array = (from suit in Resources.FindObjectsOfTypeAll<UnlockableSuit>()
					where ((NetworkBehaviour)suit).IsSpawned
					select suit).ToArray();
				int num = random.Next(array.Length);
				string unlockableName = unlockables[array[num].suitID].unlockableName;
				unlockableName = unlockableName.ToLower().Replace(" ", "");
				Dictionary<string, Type> dictionary = Traverse.Create(typeof(ModelReplacementAPI)).Field("RegisteredModelReplacements").GetValue() as Dictionary<string, Type>;
				if (dictionary.ContainsKey(unlockableName))
				{
					flag = true;
					Component obj = ((Component)StartOfRound.Instance.allPlayerScripts[0]).gameObject.AddComponent(dictionary[unlockableName]);
					val2 = (BodyReplacementBase)(object)((obj is BodyReplacementBase) ? obj : null);
					val2.suitName = unlockableName;
					val = val2;
				}
				else
				{
					UnlockableSuit val4 = array[num];
					___enemyAI.SetSuit(val4.suitID);
				}
				NumSpawnedThisLevel++;
			}
			if (!flag)
			{
				return false;
			}
			__instance.IsActive = true;
			__instance.replacementModel = Object.Instantiate<GameObject>(val.replacementModel);
			GameObject replacementModel = __instance.replacementModel;
			((Object)replacementModel).name = ((Object)replacementModel).name + "(Masked)";
			__instance.replacementModel.transform.localPosition = new Vector3(0f, 0f, 0f);
			__instance.replacementModel.SetActive(true);
			Renderer[] componentsInChildren = __instance.replacementModel.GetComponentsInChildren<Renderer>();
			foreach (Renderer obj2 in componentsInChildren)
			{
				obj2.shadowCastingMode = (ShadowCastingMode)1;
				((Component)obj2).gameObject.layer = val.viewState.VisibleLayer;
				obj2.enabled = ((Behaviour)__instance).enabled;
			}
			MaskedAvatarUpdater val5 = new MaskedAvatarUpdater();
			val5.AssignModelReplacement(((Component)___enemyAI).gameObject, __instance.replacementModel);
			Traverse.Create((object)__instance).Field("<avatar>k__BackingField").SetValue((object)val5);
			((Renderer)___enemyAI.rendererLOD0).enabled = false;
			((Renderer)___enemyAI.rendererLOD1).enabled = false;
			((Renderer)___enemyAI.rendererLOD2).enabled = false;
			((Renderer)___enemyAI.rendererLOD0).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)___enemyAI.rendererLOD1).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)___enemyAI.rendererLOD2).shadowCastingMode = (ShadowCastingMode)0;
			MeshRenderer[] componentsInChildren2 = ((Component)___enemyAI).gameObject.GetComponentsInChildren<MeshRenderer>();
			((Renderer)componentsInChildren2.Where((MeshRenderer x) => ((Object)((Component)x).gameObject).name == "LevelSticker").First()).enabled = false;
			((Renderer)componentsInChildren2.Where((MeshRenderer x) => ((Object)((Component)x).gameObject).name == "BetaBadge").First()).enabled = false;
			if ((Object)(object)val2 != (Object)null)
			{
				val2.IsActive = false;
				Object.Destroy((Object)(object)val2);
			}
			return false;
		}
	}
}