using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

[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("Empress")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EmpressCustomMenuVideos")]
[assembly: AssemblyTitle("EmpressCustomMenuVideos")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 EmpressCustomMenuVideos
{
	[BepInPlugin("empress.repo.custommenuvideos", "EmpressCustomMenuVideos", "1.0.0")]
	public sealed class EmpressCustomMenuVideosPlugin : BaseUnityPlugin
	{
		internal const string PluginGuid = "empress.repo.custommenuvideos";

		internal const string PluginName = "EmpressCustomMenuVideos";

		internal const string PluginVersion = "1.0.0";

		internal ConfigEntry<bool> EmpressEnabled;

		internal ConfigEntry<string> EmpressVideoFolder;

		internal ConfigEntry<bool> EmpressRandomizeVideos;

		internal ConfigEntry<bool> EmpressPickNewVideoEachMenuOpen;

		internal ConfigEntry<int> EmpressVideoVolume;

		internal ConfigEntry<bool> EmpressLoopVideo;

		internal ConfigEntry<int> EmpressBackgroundDim;

		internal ConfigEntry<bool> EmpressMuteVanillaMenuMusic;

		internal ConfigEntry<bool> EmpressMuteMenuSounds;

		internal ConfigEntry<bool> EmpressShowStatus;

		internal ConfigEntry<KeyCode> EmpressReloadKey;

		internal static EmpressCustomMenuVideosPlugin? Instance { get; private set; }

		internal ManualLogSource EmpressLog => ((BaseUnityPlugin)this).Logger;

		internal EmpressMenuVideoRuntime? EmpressRuntime { get; private set; }

		private void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			Instance = this;
			((Object)this).hideFlags = (HideFlags)(((Object)this).hideFlags | 0x3D);
			GameObject gameObject = ((Component)this).gameObject;
			((Object)gameObject).hideFlags = (HideFlags)(((Object)gameObject).hideFlags | 0x3D);
			EmpressEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Empress Menu Video", "Enabled", true, "Allows Empress to replace the main-menu background with local MP4 files.");
			EmpressVideoFolder = ((BaseUnityPlugin)this).Config.Bind<string>("Empress Menu Video", "VideoFolder", Path.Combine(Paths.ConfigPath, "EmpressCustomMenuVideos"), "Folder where Empress looks for MP4 menu videos. The folder is created automatically.");
			EmpressRandomizeVideos = ((BaseUnityPlugin)this).Config.Bind<bool>("Empress Menu Video", "RandomizeVideos", true, "Randomizes between MP4 files when more than one video is in the folder.");
			EmpressPickNewVideoEachMenuOpen = ((BaseUnityPlugin)this).Config.Bind<bool>("Empress Menu Video", "PickNewVideoEachMenuOpen", true, "Picks a fresh random video whenever the main menu opens.");
			EmpressVideoVolume = ((BaseUnityPlugin)this).Config.Bind<int>("Empress Menu Video", "Volume", 60, new ConfigDescription("Video volume from 0 to 100.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			EmpressLoopVideo = ((BaseUnityPlugin)this).Config.Bind<bool>("Empress Menu Video", "LoopVideo", true, "Loops the menu video.");
			EmpressBackgroundDim = ((BaseUnityPlugin)this).Config.Bind<int>("Empress Menu Video", "BackgroundDim", 18, new ConfigDescription("Black overlay dim amount from 0 to 100 so the menu stays readable.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			EmpressMuteVanillaMenuMusic = ((BaseUnityPlugin)this).Config.Bind<bool>("Empress Menu Video", "MuteVanillaMenuMusic", true, "Mutes vanilla menu music while Empress menu video audio is active.");
			EmpressMuteMenuSounds = ((BaseUnityPlugin)this).Config.Bind<bool>("Empress Menu Video", "MuteMenuSounds", true, "Mutes vanilla menu sounds while Empress menu video audio is active.");
			EmpressShowStatus = ((BaseUnityPlugin)this).Config.Bind<bool>("Empress Menu Video", "ShowStatus", true, "Shows a tiny Empress status tag while the menu video is loading or playing.");
			EmpressReloadKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Empress Controls", "ReloadKey", (KeyCode)289, "Reloads and re-picks the local MP4 menu video while on the main menu.");
			EmpressEnsureRuntime();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Empress custom menu videos are watching the title screen.");
		}

		internal EmpressMenuVideoRuntime EmpressEnsureRuntime()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if ((Object)(object)EmpressRuntime != (Object)null)
			{
				return EmpressRuntime;
			}
			GameObject val = new GameObject("EmpressCustomMenuVideos.Runtime")
			{
				hideFlags = (HideFlags)61
			};
			Object.DontDestroyOnLoad((Object)(object)val);
			EmpressRuntime = val.AddComponent<EmpressMenuVideoRuntime>();
			return EmpressRuntime;
		}
	}
	internal sealed class EmpressMenuVideoRuntime : MonoBehaviour
	{
		private static readonly FieldRef<ConstantMusic, AudioSource?> EmpressConstantMusicAudioSourceRef = AccessTools.FieldRefAccess<ConstantMusic, AudioSource>("audioSource");

		private static readonly FieldRef<LevelMusic, AudioSource?> EmpressLevelMusicAudioSourceRef = AccessTools.FieldRefAccess<LevelMusic, AudioSource>("audioSource");

		private readonly Dictionary<int, float> empressMutedAudioVolumes = new Dictionary<int, float>();

		private readonly HashSet<string> empressFailedVideos = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private Canvas? empressCanvas;

		private RawImage? empressVideoImage;

		private RawImage? empressDimImage;

		private Text? empressStatusText;

		private AspectRatioFitter? empressAspectFitter;

		private VideoPlayer? empressVideoPlayer;

		private AudioSource? empressAudioSource;

		private RenderTexture? empressRenderTexture;

		private GameObject? empressCameraPlane;

		private MeshRenderer? empressCameraPlaneRenderer;

		private Material? empressVideoMaterial;

		private string empressRequestedVideoPath = string.Empty;

		private string empressActivePlayableUrl = string.Empty;

		private string empressLastFolderPath = string.Empty;

		private string empressStatus = "Empress video idle";

		private bool empressWasInMenu;

		private bool empressForcePickNew;

		private float empressNextFolderScanTime;

		private int empressRequestVersion;

		private static EmpressCustomMenuVideosPlugin? EmpressPlugin => EmpressCustomMenuVideosPlugin.Instance;

		private static string EmpressDefaultVideoFolder => Path.Combine(Paths.ConfigPath, "EmpressCustomMenuVideos");

		private void Awake()
		{
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			EmpressEnsureVisuals();
		}

		private void OnEnable()
		{
			SceneManager.sceneLoaded += EmpressOnSceneLoaded;
		}

		private void OnDisable()
		{
			SceneManager.sceneLoaded -= EmpressOnSceneLoaded;
			EmpressSetVisible(visible: false);
			EmpressRestoreVanillaMenuAudio();
		}

		private void Update()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			EmpressCustomMenuVideosPlugin empressPlugin = EmpressPlugin;
			if ((Object)(object)empressPlugin == (Object)null)
			{
				return;
			}
			EmpressEnsureVisuals();
			bool flag = empressPlugin.EmpressEnabled.Value && EmpressIsMainMenuActive();
			if (Input.GetKeyDown(empressPlugin.EmpressReloadKey.Value))
			{
				EmpressResetVideoState("Empress reload requested");
				empressForcePickNew = true;
				empressNextFolderScanTime = 0f;
			}
			if (flag != empressWasInMenu)
			{
				empressWasInMenu = flag;
				if (!flag)
				{
					EmpressSetVisible(visible: false);
					EmpressSetCameraPlaneVisible(visible: false);
					EmpressPauseVideo();
					EmpressRestoreVanillaMenuAudio();
				}
				else
				{
					EmpressSetVisible(visible: true);
					EmpressSetCameraPlaneVisible(visible: true);
					empressForcePickNew = empressPlugin.EmpressPickNewVideoEachMenuOpen.Value;
					empressNextFolderScanTime = 0f;
				}
			}
			if (!flag)
			{
				EmpressUpdateStatusVisual();
				return;
			}
			EmpressSetVisible(visible: true);
			EmpressUpdateVolume();
			EmpressUpdateDim();
			EmpressUpdateAspect();
			EmpressUpdateCameraPlane();
			EmpressUpdateStatusVisual();
			string text = EmpressResolveVideoFolder(empressPlugin);
			if (!string.Equals(text, empressLastFolderPath, StringComparison.OrdinalIgnoreCase))
			{
				empressLastFolderPath = text;
				EmpressResetVideoState("Empress folder changed");
				empressForcePickNew = true;
				empressFailedVideos.Clear();
				empressNextFolderScanTime = 0f;
			}
			bool flag2 = !string.IsNullOrWhiteSpace(empressRequestedVideoPath) && !File.Exists(empressRequestedVideoPath);
			bool flag3 = string.IsNullOrWhiteSpace(empressRequestedVideoPath) || string.IsNullOrWhiteSpace(empressActivePlayableUrl);
			if (empressForcePickNew || flag2 || (Time.unscaledTime >= empressNextFolderScanTime && flag3))
			{
				empressNextFolderScanTime = Time.unscaledTime + 2f;
				string text2 = EmpressPickMenuVideo(empressPlugin, text, empressForcePickNew || flag2);
				empressForcePickNew = false;
				if (string.IsNullOrWhiteSpace(text2))
				{
					empressStatus = "Empress needs MP4s in " + text;
					EmpressPauseVideo();
					return;
				}
				if (!string.Equals(text2, empressRequestedVideoPath, StringComparison.OrdinalIgnoreCase))
				{
					EmpressPlayVideoPath(text2);
					return;
				}
			}
			if ((Object)(object)empressVideoPlayer != (Object)null && !string.IsNullOrWhiteSpace(empressActivePlayableUrl) && !empressVideoPlayer.isPlaying && empressVideoPlayer.isPrepared)
			{
				empressVideoPlayer.Play();
			}
		}

		private void LateUpdate()
		{
			EmpressCustomMenuVideosPlugin empressPlugin = EmpressPlugin;
			if (!((Object)(object)empressPlugin == (Object)null) && empressPlugin.EmpressEnabled.Value && EmpressIsMainMenuActive())
			{
				EmpressMuteVanillaMenuAudio();
			}
		}

		private void EmpressOnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			empressWasInMenu = false;
			empressStatus = "Empress scene changed";
			EmpressRestoreVanillaMenuAudio();
		}

		private void EmpressEnsureVisuals()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Expected O, but got Unknown
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Expected O, but got Unknown
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Expected O, but got Unknown
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Expected O, but got Unknown
			if (!((Object)(object)empressCanvas != (Object)null) || !((Object)(object)empressVideoPlayer != (Object)null) || !((Object)(object)empressVideoImage != (Object)null))
			{
				GameObject val = new GameObject("EmpressCustomMenuVideos.Canvas")
				{
					hideFlags = (HideFlags)61
				};
				val.transform.SetParent(((Component)this).transform, false);
				empressCanvas = val.AddComponent<Canvas>();
				empressCanvas.renderMode = (RenderMode)0;
				empressCanvas.sortingOrder = -30000;
				val.AddComponent<CanvasScaler>().uiScaleMode = (ScaleMode)1;
				GameObject val2 = new GameObject("Empress Video Surface")
				{
					hideFlags = (HideFlags)61
				};
				val2.transform.SetParent(val.transform, false);
				empressVideoImage = val2.AddComponent<RawImage>();
				((Graphic)empressVideoImage).raycastTarget = false;
				((Graphic)empressVideoImage).color = Color.white;
				empressAspectFitter = val2.AddComponent<AspectRatioFitter>();
				empressAspectFitter.aspectMode = (AspectMode)4;
				RectTransform rectTransform = ((Graphic)empressVideoImage).rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = Vector2.zero;
				rectTransform.offsetMax = Vector2.zero;
				GameObject val3 = new GameObject("Empress Pink Black Dim")
				{
					hideFlags = (HideFlags)61
				};
				val3.transform.SetParent(val.transform, false);
				empressDimImage = val3.AddComponent<RawImage>();
				((Graphic)empressDimImage).raycastTarget = false;
				empressDimImage.texture = (Texture)(object)Texture2D.whiteTexture;
				RectTransform rectTransform2 = ((Graphic)empressDimImage).rectTransform;
				rectTransform2.anchorMin = Vector2.zero;
				rectTransform2.anchorMax = Vector2.one;
				rectTransform2.offsetMin = Vector2.zero;
				rectTransform2.offsetMax = Vector2.zero;
				GameObject val4 = new GameObject("Empress Status Brand")
				{
					hideFlags = (HideFlags)61
				};
				val4.transform.SetParent(val.transform, false);
				empressStatusText = val4.AddComponent<Text>();
				((Graphic)empressStatusText).raycastTarget = false;
				empressStatusText.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
				empressStatusText.fontSize = 16;
				empressStatusText.alignment = (TextAnchor)8;
				((Graphic)empressStatusText).color = new Color(1f, 0.55f, 0.82f, 0.92f);
				RectTransform rectTransform3 = ((Graphic)empressStatusText).rectTransform;
				rectTransform3.anchorMin = Vector2.zero;
				rectTransform3.anchorMax = Vector2.one;
				rectTransform3.offsetMin = new Vector2(16f, 12f);
				rectTransform3.offsetMax = new Vector2(-18f, -12f);
				empressRenderTexture = new RenderTexture(1920, 1080, 0, (RenderTextureFormat)0)
				{
					name = "EmpressCustomMenuVideos.RenderTexture"
				};
				empressRenderTexture.Create();
				empressVideoImage.texture = (Texture)(object)empressRenderTexture;
				EmpressEnsureCameraPlane();
				GameObject val5 = new GameObject("Empress Video Player")
				{
					hideFlags = (HideFlags)61
				};
				val5.transform.SetParent(((Component)this).transform, false);
				empressAudioSource = val5.AddComponent<AudioSource>();
				empressAudioSource.playOnAwake = false;
				empressAudioSource.loop = true;
				empressAudioSource.spatialBlend = 0f;
				empressVideoPlayer = val5.AddComponent<VideoPlayer>();
				empressVideoPlayer.playOnAwake = false;
				empressVideoPlayer.renderMode = (VideoRenderMode)2;
				empressVideoPlayer.targetTexture = empressRenderTexture;
				empressVideoPlayer.audioOutputMode = (VideoAudioOutputMode)1;
				empressVideoPlayer.controlledAudioTrackCount = 1;
				empressVideoPlayer.EnableAudioTrack((ushort)0, true);
				empressVideoPlayer.SetTargetAudioSource((ushort)0, empressAudioSource);
				empressVideoPlayer.waitForFirstFrame = true;
				empressVideoPlayer.skipOnDrop = true;
				empressVideoPlayer.prepareCompleted += new EventHandler(EmpressVideoPrepared);
				empressVideoPlayer.errorReceived += new ErrorEventHandler(EmpressVideoError);
				EmpressSetVisible(visible: false);
			}
		}

		private string EmpressResolveVideoFolder(EmpressCustomMenuVideosPlugin plugin)
		{
			string text = plugin.EmpressVideoFolder.Value.Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				text = EmpressDefaultVideoFolder;
			}
			try
			{
				if (!Path.IsPathRooted(text))
				{
					text = Path.Combine(Paths.ConfigPath, text);
				}
				string fullPath = Path.GetFullPath(text);
				Directory.CreateDirectory(fullPath);
				return fullPath;
			}
			catch
			{
				Directory.CreateDirectory(EmpressDefaultVideoFolder);
				empressStatus = "Empress used the default video folder";
				return EmpressDefaultVideoFolder;
			}
		}

		private string? EmpressPickMenuVideo(EmpressCustomMenuVideosPlugin plugin, string folder, bool preferDifferent)
		{
			string[] array;
			try
			{
				Directory.CreateDirectory(folder);
				array = (from path in Directory.GetFiles(folder, "*.mp4", SearchOption.TopDirectoryOnly).Where(File.Exists)
					where !empressFailedVideos.Contains(path)
					select path).OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase).ToArray();
			}
			catch
			{
				empressStatus = "Empress could not scan the video folder";
				return null;
			}
			if (array.Length == 0 && empressFailedVideos.Count > 0)
			{
				empressFailedVideos.Clear();
				return null;
			}
			if (array.Length == 0)
			{
				return null;
			}
			if (array.Length == 1)
			{
				return array[0];
			}
			if (!plugin.EmpressRandomizeVideos.Value)
			{
				return array[0];
			}
			string[] array2 = (preferDifferent ? array.Where((string path) => !string.Equals(path, empressRequestedVideoPath, StringComparison.OrdinalIgnoreCase)).ToArray() : array);
			if (array2.Length == 0)
			{
				array2 = array;
			}
			return array2[Random.Range(0, array2.Length)];
		}

		private void EmpressPlayVideoPath(string videoPath)
		{
			if (!((Object)(object)empressVideoPlayer == (Object)null))
			{
				empressRequestVersion++;
				empressRequestedVideoPath = Path.GetFullPath(videoPath);
				empressActivePlayableUrl = new Uri(empressRequestedVideoPath).AbsoluteUri;
				empressStatus = "Empress is preparing " + Path.GetFileName(empressRequestedVideoPath);
				empressVideoPlayer.Stop();
				empressVideoPlayer.source = (VideoSource)1;
				empressVideoPlayer.url = empressActivePlayableUrl;
				empressVideoPlayer.isLooping = EmpressPlugin?.EmpressLoopVideo.Value ?? false;
				empressVideoPlayer.Prepare();
			}
		}

		private void EmpressResetVideoState(string status)
		{
			empressRequestVersion++;
			empressRequestedVideoPath = string.Empty;
			empressActivePlayableUrl = string.Empty;
			empressStatus = status;
			if ((Object)(object)empressVideoPlayer != (Object)null)
			{
				empressVideoPlayer.Stop();
			}
		}

		private void EmpressVideoPrepared(VideoPlayer source)
		{
			if (!((Object)(object)source != (Object)(object)empressVideoPlayer) && !string.IsNullOrWhiteSpace(empressActivePlayableUrl) && !(source.url != empressActivePlayableUrl))
			{
				empressStatus = "Empress menu video online";
				EmpressUpdateAspect();
				EmpressUpdateVolume();
				source.Play();
			}
		}

		private void EmpressVideoError(VideoPlayer source, string message)
		{
			if (!((Object)(object)source != (Object)(object)empressVideoPlayer))
			{
				if (!string.IsNullOrWhiteSpace(empressRequestedVideoPath))
				{
					empressFailedVideos.Add(empressRequestedVideoPath);
				}
				empressStatus = "Empress video error: " + message;
				empressRequestedVideoPath = string.Empty;
				empressActivePlayableUrl = string.Empty;
				empressForcePickNew = true;
				empressNextFolderScanTime = Time.unscaledTime + 1.5f;
			}
		}

		private void EmpressPauseVideo()
		{
			if ((Object)(object)empressVideoPlayer != (Object)null && empressVideoPlayer.isPlaying)
			{
				empressVideoPlayer.Pause();
			}
			if ((Object)(object)empressAudioSource != (Object)null && empressAudioSource.isPlaying)
			{
				empressAudioSource.Pause();
			}
		}

		private void EmpressSetVisible(bool visible)
		{
			if ((Object)(object)empressCanvas != (Object)null)
			{
				((Behaviour)empressCanvas).enabled = visible;
			}
			EmpressSetCameraPlaneVisible(visible);
		}

		private void EmpressUpdateVolume()
		{
			if (!((Object)(object)empressAudioSource == (Object)null) && !((Object)(object)EmpressPlugin == (Object)null))
			{
				empressAudioSource.volume = (float)Mathf.Clamp(EmpressPlugin.EmpressVideoVolume.Value, 0, 100) / 100f;
				empressAudioSource.loop = EmpressPlugin.EmpressLoopVideo.Value;
			}
		}

		private void EmpressUpdateDim()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)empressDimImage == (Object)null) && !((Object)(object)EmpressPlugin == (Object)null))
			{
				float num = (float)Mathf.Clamp(EmpressPlugin.EmpressBackgroundDim.Value, 0, 100) / 100f;
				((Graphic)empressDimImage).color = new Color(0.02f, 0f, 0.018f, num);
			}
		}

		private void EmpressUpdateAspect()
		{
			if (!((Object)(object)empressAspectFitter == (Object)null) && !((Object)(object)empressVideoPlayer == (Object)null) && empressVideoPlayer.width != 0 && empressVideoPlayer.height != 0)
			{
				empressAspectFitter.aspectRatio = (float)empressVideoPlayer.width / (float)empressVideoPlayer.height;
			}
		}

		private void EmpressEnsureCameraPlane()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			if (!((Object)(object)empressCameraPlane != (Object)null))
			{
				empressCameraPlane = new GameObject("Empress Video Camera Backdrop")
				{
					hideFlags = (HideFlags)61
				};
				empressCameraPlane.transform.SetParent(((Component)this).transform, false);
				empressCameraPlane.AddComponent<MeshFilter>().mesh = EmpressCreateQuadMesh();
				empressCameraPlaneRenderer = empressCameraPlane.AddComponent<MeshRenderer>();
				Shader val = Shader.Find("Unlit/Texture") ?? Shader.Find("UI/Default") ?? Shader.Find("Sprites/Default");
				empressVideoMaterial = new Material(val)
				{
					hideFlags = (HideFlags)61,
					mainTexture = (Texture)(object)empressRenderTexture
				};
				((Renderer)empressCameraPlaneRenderer).sharedMaterial = empressVideoMaterial;
				EmpressSetCameraPlaneVisible(visible: false);
			}
		}

		private void EmpressUpdateCameraPlane()
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			EmpressEnsureCameraPlane();
			if ((Object)(object)empressCameraPlane == (Object)null || (Object)(object)empressVideoMaterial == (Object)null || (Object)(object)empressVideoPlayer == (Object)null)
			{
				return;
			}
			Camera val = EmpressResolveMenuCamera();
			if ((Object)(object)val == (Object)null)
			{
				EmpressSetCameraPlaneVisible(visible: false);
				return;
			}
			empressVideoMaterial.mainTexture = (Texture)(object)empressRenderTexture;
			float num = Mathf.Max(val.nearClipPlane + 0.65f, 1.25f);
			float num2 = 2f * num * Mathf.Tan(val.fieldOfView * 0.5f * (MathF.PI / 180f));
			float num3 = ((val.aspect > 0.01f) ? val.aspect : Mathf.Max(1f, (float)Screen.width / (float)Mathf.Max(1, Screen.height)));
			float num4 = num2 * num3;
			float num5 = 1.7777778f;
			if (empressVideoPlayer.width != 0 && empressVideoPlayer.height != 0)
			{
				num5 = (float)empressVideoPlayer.width / (float)empressVideoPlayer.height;
			}
			float num6 = num4;
			float num7 = num2;
			if (num5 > num3)
			{
				num6 = num2 * num5;
			}
			else
			{
				num7 = num4 / Mathf.Max(0.01f, num5);
			}
			Transform transform = ((Component)val).transform;
			Transform transform2 = empressCameraPlane.transform;
			transform2.position = transform.position + transform.forward * num;
			transform2.rotation = transform.rotation;
			transform2.localScale = new Vector3(num6, num7, 1f);
			EmpressSetCameraPlaneVisible((Object)(object)empressCanvas != (Object)null && ((Behaviour)empressCanvas).enabled);
		}

		private void EmpressSetCameraPlaneVisible(bool visible)
		{
			if ((Object)(object)empressCameraPlaneRenderer != (Object)null)
			{
				((Renderer)empressCameraPlaneRenderer).enabled = visible;
			}
		}

		private static Camera? EmpressResolveMenuCamera()
		{
			if ((Object)(object)CameraNoPlayerTarget.instance != (Object)null)
			{
				Camera component = ((Component)CameraNoPlayerTarget.instance).GetComponent<Camera>();
				if ((Object)(object)component != (Object)null && ((Behaviour)component).enabled)
				{
					return component;
				}
			}
			Camera main = Camera.main;
			if ((Object)(object)main != (Object)null && ((Behaviour)main).enabled)
			{
				return main;
			}
			return ((IEnumerable<Camera>)Object.FindObjectsOfType<Camera>()).FirstOrDefault((Func<Camera, bool>)((Camera camera) => (Object)(object)camera != (Object)null && ((Behaviour)camera).enabled));
		}

		private static Mesh EmpressCreateQuadMesh()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			Mesh val = new Mesh
			{
				name = "EmpressMenuVideoQuad"
			};
			val.vertices = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(-0.5f, -0.5f, 0f),
				new Vector3(0.5f, -0.5f, 0f),
				new Vector3(-0.5f, 0.5f, 0f),
				new Vector3(0.5f, 0.5f, 0f)
			};
			val.uv = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(0f, 1f),
				new Vector2(1f, 1f)
			};
			val.triangles = new int[6] { 0, 2, 1, 2, 3, 1 };
			val.RecalculateBounds();
			return val;
		}

		private void EmpressUpdateStatusVisual()
		{
			if (!((Object)(object)empressStatusText == (Object)null) && !((Object)(object)EmpressPlugin == (Object)null))
			{
				bool flag = EmpressPlugin.EmpressShowStatus.Value && (Object)(object)empressCanvas != (Object)null && ((Behaviour)empressCanvas).enabled;
				((Behaviour)empressStatusText).enabled = flag;
				if (flag)
				{
					empressStatusText.text = "EMPRESS MENU VIDEO // " + empressStatus;
				}
			}
		}

		private void EmpressMuteVanillaMenuAudio()
		{
			EmpressCustomMenuVideosPlugin empressPlugin = EmpressPlugin;
			if ((Object)(object)empressPlugin == (Object)null || (!empressPlugin.EmpressMuteVanillaMenuMusic.Value && !empressPlugin.EmpressMuteMenuSounds.Value))
			{
				EmpressRestoreVanillaMenuAudio();
				return;
			}
			if (empressPlugin.EmpressMuteMenuSounds.Value)
			{
				AudioSource[] array = Object.FindObjectsOfType<AudioSource>();
				foreach (AudioSource source in array)
				{
					EmpressMuteAudioSource(source);
				}
			}
			if (empressPlugin.EmpressMuteVanillaMenuMusic.Value)
			{
				ConstantMusic[] array2 = Object.FindObjectsOfType<ConstantMusic>();
				foreach (ConstantMusic val in array2)
				{
					AudioSource source2 = EmpressConstantMusicAudioSourceRef.Invoke(val);
					EmpressMuteAudioSource(source2);
				}
				LevelMusic[] array3 = Object.FindObjectsOfType<LevelMusic>();
				foreach (LevelMusic val2 in array3)
				{
					AudioSource source3 = EmpressLevelMusicAudioSourceRef.Invoke(val2);
					EmpressMuteAudioSource(source3);
				}
			}
		}

		private void EmpressMuteAudioSource(AudioSource? source)
		{
			if (!((Object)(object)source == (Object)null) && source != empressAudioSource)
			{
				int instanceID = ((Object)source).GetInstanceID();
				if (!empressMutedAudioVolumes.ContainsKey(instanceID))
				{
					empressMutedAudioVolumes[instanceID] = source.volume;
				}
				source.volume = 0f;
			}
		}

		private void EmpressRestoreVanillaMenuAudio()
		{
			if (empressMutedAudioVolumes.Count == 0)
			{
				return;
			}
			AudioSource[] array = Object.FindObjectsOfType<AudioSource>();
			foreach (AudioSource val in array)
			{
				int instanceID = ((Object)val).GetInstanceID();
				if (empressMutedAudioVolumes.TryGetValue(instanceID, out var value))
				{
					val.volume = value;
				}
			}
			empressMutedAudioVolumes.Clear();
		}

		private static bool EmpressIsMainMenuActive()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)RunManager.instance != (Object)null && (Object)(object)RunManager.instance.levelCurrent != (Object)null && (Object)(object)RunManager.instance.levelMainMenu != (Object)null)
			{
				return RunManager.instance.levelCurrent == RunManager.instance.levelMainMenu;
			}
			if ((Object)(object)MainMenuOpen.instance != (Object)null || (Object)(object)Object.FindObjectOfType<MainMenuOpen>() != (Object)null)
			{
				return true;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name.IndexOf("menu", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return (Object)(object)MenuManager.instance != (Object)null;
			}
			return false;
		}
	}
}