using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("NoAbomination")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("NoAbomination")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("455c9416-1048-44be-96cf-cd45598d67b4")]
[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")]
namespace NoForestAmbush;

[BepInPlugin("kumo.sulfur.no_forest_ambush", "No Forest Ambush", "1.3.0")]
public sealed class Plugin : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <CleanupBurst>d__14 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string reason;

		public Plugin <>4__this;

		private int <iterations>5__1;

		private float <interval>5__2;

		private int <i>5__3;

		private int <neutralized>5__4;

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

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

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

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

		private bool MoveNext()
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.cleanupBurstRunning = true;
				if (<>4__this.logActions.Value)
				{
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("Starting Forest Ambush cleanup burst: " + reason));
				}
				<iterations>5__1 = Mathf.Max(1, <>4__this.cleanupBurstIterations.Value);
				<interval>5__2 = Mathf.Max(0.05f, <>4__this.cleanupBurstInterval.Value);
				<i>5__3 = 0;
				break;
			case 1:
				<>1__state = -1;
				<i>5__3++;
				break;
			}
			if (<i>5__3 < <iterations>5__1)
			{
				<neutralized>5__4 = <>4__this.NeutralizeForestAmbushObjectsInLoadedScenes();
				if (<>4__this.logActions.Value && <neutralized>5__4 > 0)
				{
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("Cleanup pass neutralized Forest Ambush objects: " + <neutralized>5__4));
				}
				<>2__current = (object)new WaitForSeconds(<interval>5__2);
				<>1__state = 1;
				return true;
			}
			<>4__this.cleanupBurstRunning = false;
			if (<>4__this.logActions.Value)
			{
				((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("Finished Forest Ambush cleanup burst: " + reason));
			}
			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();
		}
	}

	[CompilerGenerated]
	private sealed class <SceneSignatureWatchLoop>d__11 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

		private int <currentSignature>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				<currentSignature>5__1 = <>4__this.ComputeSceneSignature();
				if (<currentSignature>5__1 != <>4__this.lastSceneSignature)
				{
					<>4__this.lastSceneSignature = <currentSignature>5__1;
					<>4__this.StartCleanupBurst("scene hierarchy changed");
				}
				break;
			}
			<>2__current = (object)new WaitForSeconds(Mathf.Max(0.25f, <>4__this.sceneSignatureCheckInterval.Value));
			<>1__state = 1;
			return true;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	internal static ManualLogSource Log;

	private ConfigEntry<bool> logActions;

	private ConfigEntry<float> sceneSignatureCheckInterval;

	private ConfigEntry<int> cleanupBurstIterations;

	private ConfigEntry<float> cleanupBurstInterval;

	private int lastSceneSignature;

	private bool cleanupBurstRunning;

	private readonly HashSet<int> neutralizedAmbushIds = new HashSet<int>();

	private void Awake()
	{
		Log = ((BaseUnityPlugin)this).Logger;
		logActions = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "LogActions", false, "Log neutralized Forest Ambush objects.");
		sceneSignatureCheckInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Performance", "SceneSignatureCheckInterval", 1f, "How often to cheaply check whether the loaded scene hierarchy changed.");
		cleanupBurstIterations = ((BaseUnityPlugin)this).Config.Bind<int>("Performance", "CleanupBurstIterations", 24, "How many cleanup passes to run after a scene hierarchy change.");
		cleanupBurstInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Performance", "CleanupBurstInterval", 0.2f, "Delay between cleanup passes during a cleanup burst.");
		SceneManager.sceneLoaded += OnSceneLoaded;
		lastSceneSignature = ComputeSceneSignature();
		StartCleanupBurst("startup");
		((MonoBehaviour)this).StartCoroutine(SceneSignatureWatchLoop());
		((BaseUnityPlugin)this).Logger.LogInfo((object)"No Forest Ambush 1.3.0 loaded.");
	}

	private void OnDestroy()
	{
		SceneManager.sceneLoaded -= OnSceneLoaded;
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		neutralizedAmbushIds.Clear();
		lastSceneSignature = ComputeSceneSignature();
		StartCleanupBurst("scene loaded");
	}

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

	private int ComputeSceneSignature()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		int num = 17;
		num = num * 31 + SceneManager.sceneCount;
		for (int i = 0; i < SceneManager.sceneCount; i++)
		{
			Scene sceneAt = SceneManager.GetSceneAt(i);
			if (((Scene)(ref sceneAt)).IsValid() && ((Scene)(ref sceneAt)).isLoaded)
			{
				num = num * 31 + ((Scene)(ref sceneAt)).name.GetHashCode();
				num = num * 31 + ((Scene)(ref sceneAt)).rootCount;
			}
		}
		return num;
	}

	private void StartCleanupBurst(string reason)
	{
		if (!cleanupBurstRunning)
		{
			((MonoBehaviour)this).StartCoroutine(CleanupBurst(reason));
		}
	}

	[IteratorStateMachine(typeof(<CleanupBurst>d__14))]
	private IEnumerator CleanupBurst(string reason)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <CleanupBurst>d__14(0)
		{
			<>4__this = this,
			reason = reason
		};
	}

	private int NeutralizeForestAmbushObjectsInLoadedScenes()
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		int num = 0;
		for (int i = 0; i < SceneManager.sceneCount; i++)
		{
			Scene sceneAt = SceneManager.GetSceneAt(i);
			if (((Scene)(ref sceneAt)).IsValid() && ((Scene)(ref sceneAt)).isLoaded)
			{
				GameObject[] rootGameObjects = ((Scene)(ref sceneAt)).GetRootGameObjects();
				GameObject[] array = rootGameObjects;
				foreach (GameObject val in array)
				{
					num += ScanTransformForForestAmbush(val.transform);
				}
			}
		}
		return num;
	}

	private int ScanTransformForForestAmbush(Transform transform)
	{
		if ((Object)(object)transform == (Object)null)
		{
			return 0;
		}
		GameObject gameObject = ((Component)transform).gameObject;
		if ((Object)(object)gameObject == (Object)null)
		{
			return 0;
		}
		if (IsForestAmbushRootName(((Object)gameObject).name))
		{
			int instanceID = ((Object)gameObject).GetInstanceID();
			if (neutralizedAmbushIds.Contains(instanceID))
			{
				return 0;
			}
			neutralizedAmbushIds.Add(instanceID);
			NeutralizeForestAmbushRoot(gameObject);
			return 1;
		}
		int num = 0;
		for (int num2 = transform.childCount - 1; num2 >= 0; num2--)
		{
			num += ScanTransformForForestAmbush(transform.GetChild(num2));
		}
		return num;
	}

	private void NeutralizeForestAmbushRoot(GameObject ambushRoot)
	{
		if ((Object)(object)ambushRoot == (Object)null)
		{
			return;
		}
		Transform val = ambushRoot.transform.Find("Contents");
		if ((Object)(object)val == (Object)null)
		{
			if (logActions.Value)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Forest Ambush has no Contents: " + GetPath(ambushRoot)));
			}
			return;
		}
		GameObject gameObject = ((Component)val).gameObject;
		DisableBehaviourComponentByTypeName(gameObject, "Animator");
		DisableBehaviourComponentByTypeName(gameObject, "AudioSource");
		for (int num = val.childCount - 1; num >= 0; num--)
		{
			Transform child = val.GetChild(num);
			if (!((Object)(object)child == (Object)null))
			{
				GameObject gameObject2 = ((Component)child).gameObject;
				string name = ((Object)gameObject2).name;
				if (ShouldDisableAmbushVisualObject(name))
				{
					if (logActions.Value)
					{
						((BaseUnityPlugin)this).Logger.LogInfo((object)("Disabled Forest Ambush visual object: " + GetPath(gameObject2)));
					}
					gameObject2.SetActive(false);
				}
			}
		}
		if (logActions.Value)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Neutralized Forest Ambush visuals only: " + GetPath(ambushRoot)));
		}
	}

	private static bool ShouldDisableAmbushVisualObject(string objectName)
	{
		if (string.IsNullOrEmpty(objectName))
		{
			return false;
		}
		if (objectName.StartsWith("Tree", StringComparison.OrdinalIgnoreCase))
		{
			return true;
		}
		if (objectName.IndexOf("Particles", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		return false;
	}

	private static bool IsForestAmbushRootName(string objectName)
	{
		if (string.IsNullOrEmpty(objectName))
		{
			return false;
		}
		return objectName.IndexOf("Event_Forest_Ambush", StringComparison.OrdinalIgnoreCase) >= 0 || objectName.IndexOf("Forest_Ambush", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static void DisableBehaviourComponentByTypeName(GameObject go, string typeName)
	{
		if ((Object)(object)go == (Object)null || string.IsNullOrEmpty(typeName))
		{
			return;
		}
		Component[] components = go.GetComponents<Component>();
		Component[] array = components;
		foreach (Component val in array)
		{
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			Type type = ((object)val).GetType();
			if (string.Equals(type.Name, typeName, StringComparison.OrdinalIgnoreCase))
			{
				Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.enabled = false;
				}
			}
		}
	}

	private static string GetPath(GameObject go)
	{
		if ((Object)(object)go == (Object)null)
		{
			return string.Empty;
		}
		string text = ((Object)go).name;
		Transform parent = go.transform.parent;
		while ((Object)(object)parent != (Object)null)
		{
			text = ((Object)parent).name + "/" + text;
			parent = parent.parent;
		}
		return text;
	}
}