using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.Barrel;
using On.EntityStates.Barrel;
using On.RoR2;
using RoR2;
using UnityEngine;
using UnityEngine.Networking;

[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("DarkenEmptyChests")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+cbd779ea0061b9e41b5c6092601d8323b2a1fd32")]
[assembly: AssemblyProduct("DarkenEmptyChests")]
[assembly: AssemblyTitle("DarkenEmptyChests")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace DarkenEmptyChests;

[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("icejaw.darkenemptychests", "Darken Empty Chests", "1.0.0")]
public class DarkenEmptyChests : BaseUnityPlugin
{
	public static ConfigEntry<float> BrightnessMultiplier;

	public static ConfigEntry<float> FadeOutTime;

	public static ConfigEntry<bool> ShouldApplyToAdaptiveChests;

	private const float default_BrightnessMultiplier = 0.5f;

	private const float default_FadeOutTime = 1f;

	private const bool default_ShouldApplyToAdaptiveChests = false;

	internal static DarkenEmptyChests Instance;

	public void Awake()
	{
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Expected O, but got Unknown
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Expected O, but got Unknown
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Expected O, but got Unknown
		Instance = this;
		BrightnessMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("DarkenEmptyChests", "BrightnessMultiplier", 0.5f, "How much to darken empty containers. (0 = completely black, 1 = normal)");
		FadeOutTime = ((BaseUnityPlugin)this).Config.Bind<float>("DarkenEmptyChests", "FadeOutTime", 1f, "How long containers should take to fade out, in seconds.");
		ShouldApplyToAdaptiveChests = ((BaseUnityPlugin)this).Config.Bind<bool>("DarkenEmptyChests", "ShouldApplyToAdaptiveChests", false, "Whether adaptive chests should fade out after use.");
		Opened.OnEnter += new hook_OnEnter(On_Opened_OnEnter);
		DelusionChestController.ResetChestForDelusion += new hook_ResetChestForDelusion(On_DelusionChestController_ResetChestForDelusion);
		Opened.OnEnter += new hook_OnEnter(On_Opened_OnEnter);
	}

	internal static void Log(LogLevel level, object data)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		((BaseUnityPlugin)Instance).Logger.Log(level, data);
	}

	private void On_Opened_OnEnter(orig_OnEnter orig, Opened self)
	{
		orig.Invoke(self);
		((Component)((EntityState)self).outer.commonComponents.modelLocator.modelTransform).gameObject.AddComponent<FadeObject>();
	}

	private void On_Opened_OnEnter(orig_OnEnter orig, EntityState self)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		orig.Invoke((Opened)self);
		if (ShouldApplyToAdaptiveChests.Value && NetworkServer.active)
		{
			Transform modelTransform = self.outer.commonComponents.modelLocator.modelTransform;
			((Component)modelTransform.GetChild(0)).gameObject.AddComponent<FadeObject>();
			((Component)modelTransform.GetChild(1)).gameObject.AddComponent<FadeObject>();
		}
	}

	private void On_DelusionChestController_ResetChestForDelusion(orig_ResetChestForDelusion orig, DelusionChestController self)
	{
		orig.Invoke(self);
		FadeObject component = ((Component)((Component)self).gameObject.GetComponent<ModelLocator>().modelTransform).GetComponent<FadeObject>();
		if ((Object)(object)component != (Object)null)
		{
			Object.Destroy((Object)(object)component);
		}
	}
}
public class FadeObject : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <InterpolateBrightnessAndFade>d__11 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public FadeObject <>4__this;

		private float <currentLerp>5__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			int num = <>1__state;
			FadeObject fadeObject = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<currentLerp>5__2 = 0f;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<currentLerp>5__2 <= 1f)
			{
				fadeObject.currentBrightness = Mathf.SmoothStep(1f, fadeObject.TargetBrightness, <currentLerp>5__2);
				<currentLerp>5__2 += Time.deltaTime / fadeObject.FadeOutTime;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			}
			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 <WaitUntilVisible>d__12 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public FadeObject <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			int num = <>1__state;
			FadeObject fadeObject = <>4__this;
			bool flag;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				flag = false;
				goto IL_004f;
			case 1:
				<>1__state = -1;
				flag = fadeObject.RenderersAreVisible();
				goto IL_004f;
			case 2:
				{
					<>1__state = -1;
					fadeObject.RefreshRenderers();
					SceneCamera.onSceneCameraPreRender += new SceneCameraDelegate(fadeObject.OnSceneCameraPreRender);
					return false;
				}
				IL_004f:
				if (!flag)
				{
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				}
				<>2__current = (object)new WaitForSecondsRealtime(0.05f);
				<>1__state = 2;
				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();
		}
	}

	private Renderer[] renderers;

	private readonly List<Color> originalColors = new List<Color>();

	private float currentBrightness = 1f;

	private float TargetBrightness => DarkenEmptyChests.BrightnessMultiplier.Value;

	private float FadeOutTime => DarkenEmptyChests.FadeOutTime.Value;

	private void Start()
	{
		renderers = ((Component)this).gameObject.GetComponentsInChildren<Renderer>();
		((MonoBehaviour)this).StartCoroutine(WaitUntilVisible());
		((MonoBehaviour)this).StartCoroutine(InterpolateBrightnessAndFade());
	}

	private void OnDestroy()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		SceneCamera.onSceneCameraPreRender -= new SceneCameraDelegate(OnSceneCameraPreRender);
		currentBrightness = 1f;
		OnSceneCameraPreRender(null);
	}

	private void RefreshRenderers()
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		renderers = ((Component)this).gameObject.GetComponentsInChildren<Renderer>();
		originalColors.Clear();
		Renderer[] array = renderers;
		foreach (Renderer val in array)
		{
			originalColors.Add(val.material.color);
		}
	}

	private bool RenderersAreVisible()
	{
		bool result = true;
		Renderer[] array = renderers;
		foreach (Renderer val in array)
		{
			if ((Object)(object)val == (Object)null)
			{
				RefreshRenderers();
				DarkenEmptyChests.Log((LogLevel)16, "Renderers became null, refreshing reference to renderers");
				result = false;
				break;
			}
			if (!val.isVisible)
			{
				result = false;
				break;
			}
		}
		return result;
	}

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

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

	private void OnSceneCameraPreRender(SceneCamera _)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < renderers.Length; i++)
		{
			Renderer renderer = renderers[i];
			Color color = originalColors[i];
			ChangeColor(renderer, color);
		}
	}

	private void ChangeColor(Renderer renderer, Color color)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			renderer.material.color = color * currentBrightness;
		}
		catch (NullReferenceException)
		{
			DarkenEmptyChests.Log((LogLevel)16, "Setting color failed, refreshing reference to renderers");
			RefreshRenderers();
		}
	}
}