using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.Json;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.BoneMenu.UI;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Bonelab;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Preferences;
using QuestGraphicsSettings;
using Unity.XR.Oculus;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering.Universal;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Core), "QuestGraphicsSettings", "3.0.0", "Jorink", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]
[assembly: AssemblyCompany("QuestGraphicsSettings")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5a626ac69b786cd219aabcf3540e5d6d37d8e63f")]
[assembly: AssemblyProduct("QuestGraphicsSettings")]
[assembly: AssemblyTitle("QuestGraphicsSettings")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace QuestGraphicsSettings;

public class Core : MelonMod
{
	private sealed class GraphicsPreset
	{
		public float RenderScale { get; set; }

		public float RenderDistance { get; set; }

		public bool DisableRenderDistanceTweaks { get; set; }

		public float LODBias { get; set; }

		public int FFRLevel { get; set; }
	}

	private MelonPreferences_Category category;

	private MelonPreferences_Entry<float> RenderScaleEntry;

	private MelonPreferences_Entry<float> RenderDistanceEntry;

	private MelonPreferences_Entry<bool> DisableRenderDistanceTweaksEntry;

	private MelonPreferences_Entry<float> LODBiasEntry;

	private MelonPreferences_Entry<int> FFRLevelEntry;

	private MelonPreferences_Entry<string> CustomPresetsEntry;

	private int ffrLevel;

	private Camera playerCamera;

	private Camera defaultRenderDistanceCamera;

	private bool hasDefaultRenderDistance;

	private float defaultRenderDistance;

	private float TimerStart;

	private bool ApplyNeeded = true;

	private Page defaultPage;

	private Page presetsPage;

	private GameObject pauseMenuButton;

	private string customPresetNameInput = string.Empty;

	private readonly Dictionary<string, FunctionElement> customPresetElements = new Dictionary<string, FunctionElement>(StringComparer.OrdinalIgnoreCase);

	private readonly Dictionary<string, GraphicsPreset> builtInPresets = new Dictionary<string, GraphicsPreset>(StringComparer.OrdinalIgnoreCase)
	{
		["low"] = new GraphicsPreset
		{
			RenderScale = 0.8f,
			RenderDistance = 60f,
			DisableRenderDistanceTweaks = true,
			LODBias = 1f,
			FFRLevel = 3
		},
		["medium"] = new GraphicsPreset
		{
			RenderScale = 1f,
			RenderDistance = 120f,
			DisableRenderDistanceTweaks = true,
			LODBias = 1.25f,
			FFRLevel = 3
		},
		["high"] = new GraphicsPreset
		{
			RenderScale = 1.5f,
			RenderDistance = 200f,
			DisableRenderDistanceTweaks = true,
			LODBias = 1.5f,
			FFRLevel = 3
		}
	};

	private readonly Dictionary<string, GraphicsPreset> customPresets = new Dictionary<string, GraphicsPreset>(StringComparer.OrdinalIgnoreCase);

	public override void OnInitializeMelon()
	{
		((MelonBase)this).OnInitializeMelon();
		SetupMelonPreferences();
		SetupBoneMenu();
		Hooking.OnLevelLoaded += OnLevelLoaded;
		Hooking.OnUIRigCreated += SetupPauseMenuButton;
	}

	public override void OnDeinitializeMelon()
	{
		((MelonBase)this).OnDeinitializeMelon();
		Hooking.OnLevelLoaded -= OnLevelLoaded;
		Hooking.OnUIRigCreated -= SetupPauseMenuButton;
	}

	private void OnLevelLoaded(LevelInfo levelInfo)
	{
		ApplySettings();
		TimerStart = Time.time;
		ApplyNeeded = true;
		SetupPauseMenuButton();
	}

	private void SetupBoneMenu()
	{
		//IL_000b: 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_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: 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_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: 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_01cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		defaultPage = Page.Root.CreatePage("Jorink", Color.red, 0, true).CreatePage("QuestGraphicsSettings", Color.red, 0, true);
		defaultPage.CreateFloat("Render Scale", Color.yellow, RenderScaleEntry.Value, 0.05f, 0.5f, 2f, (Action<float>)delegate(float a)
		{
			RenderScaleEntry.Value = a;
			SetRenderScale();
		});
		defaultPage.CreateFloat("LOD Bias", Color.yellow, LODBiasEntry.Value, 0.05f, 0.5f, 2f, (Action<float>)delegate(float a)
		{
			LODBiasEntry.Value = a;
			SetLODBias();
		});
		defaultPage.CreateInt("FFR Level", Color.green, FFRLevelEntry.Value, 1, 0, 3, (Action<int>)delegate(int a)
		{
			FFRLevelEntry.Value = a;
			SetFFR();
		});
		defaultPage.CreateFunction("Save Settings", Color.cyan, (Action)delegate
		{
			MelonPreferences.Save();
		});
		Page obj = defaultPage.CreatePage("Experimental", Color.yellow, 0, true);
		obj.CreateFloat("Render Distance", Color.green, RenderDistanceEntry.Value, 5f, 5f, 300f, (Action<float>)delegate(float a)
		{
			RenderDistanceEntry.Value = a;
			SetRenderDistance();
		});
		obj.CreateBool("Disable Render Distance Tweaks", Color.cyan, DisableRenderDistanceTweaksEntry.Value, (Action<bool>)delegate(bool a)
		{
			DisableRenderDistanceTweaksEntry.Value = a;
			SetRenderDistance();
		});
		presetsPage = defaultPage.CreatePage("Presets", Color.magenta, 0, true);
		presetsPage.CreateString("Custom Preset Name", Color.white, customPresetNameInput, (Action<string>)delegate(string value)
		{
			customPresetNameInput = NormalizePresetName(value);
		});
		presetsPage.CreateFunction("Save Manual Settings As Preset", Color.cyan, (Action)SaveCurrentAsCustomPreset);
		presetsPage.CreateFunction("Delete Preset", Color.red, (Action)RemoveCustomPreset);
		CreatePresetMenuEntry("low", isBuiltIn: true);
		CreatePresetMenuEntry("medium", isBuiltIn: true);
		CreatePresetMenuEntry("high", isBuiltIn: true);
		foreach (string key in customPresets.Keys)
		{
			CreatePresetMenuEntry(key, isBuiltIn: false);
		}
	}

	private void SetupPauseMenuButton()
	{
		if ((Object)(object)pauseMenuButton != (Object)null)
		{
			return;
		}
		try
		{
			TrySetupPauseMenuButton();
		}
		catch (Exception ex)
		{
			MelonLogger.Warning("Failed to set up pause menu button: " + ex.Message);
		}
	}

	private void TrySetupPauseMenuButton()
	{
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Expected O, but got Unknown
		UIRig uIRig = Player.UIRig;
		if ((Object)(object)uIRig == (Object)null)
		{
			return;
		}
		PreferencesPanelView panelView = uIRig.popUpMenu.preferencesPanelView;
		if (!((Object)(object)panelView == (Object)null))
		{
			Transform val = ((Il2CppArrayBase<GameObject>)(object)panelView.pages)[panelView.defaultPage].transform.Find("grid_Options");
			GameObject val2 = Object.Instantiate<GameObject>(((Component)val.Find("button_Control")).gameObject, val, false);
			((Object)val2).name = "button_QuestGraphicsSettings";
			Transform val3 = val.Find("button_Quit");
			if ((Object)(object)val3 != (Object)null)
			{
				val2.transform.SetSiblingIndex(val3.GetSiblingIndex());
			}
			Transform obj = val2.transform.Find("text_Control");
			TMP_Text val4 = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
			if ((Object)(object)val4 != (Object)null)
			{
				val4.text = "Graphics";
				((Object)((Component)val4).gameObject).name = "text_QuestGraphicsSettings";
			}
			Button component = val2.GetComponent<Button>();
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				OpenSettingsFromPauseMenu(panelView);
			}));
			pauseMenuButton = val2;
		}
	}

	private void OpenSettingsFromPauseMenu(PreferencesPanelView panelView)
	{
		int num = FindGUIMenuPageIndex(panelView);
		if (num >= 0)
		{
			panelView.PAGESELECT(num);
		}
		Menu.OpenPage(defaultPage);
	}

	private int FindGUIMenuPageIndex(PreferencesPanelView panelView)
	{
		GUIMenu instance = GUIMenu.Instance;
		GameObject val = ((instance != null) ? ((Component)instance).gameObject : null);
		if ((Object)(object)val == (Object)null)
		{
			return -1;
		}
		for (int i = 0; i < ((Il2CppArrayBase<GameObject>)(object)panelView.pages).Length; i++)
		{
			if ((Object)(object)((Il2CppArrayBase<GameObject>)(object)panelView.pages)[i] == (Object)(object)val)
			{
				return i;
			}
		}
		return -1;
	}

	private void SetupMelonPreferences()
	{
		category = MelonPreferences.CreateCategory("QuestGraphicsSettings");
		RenderScaleEntry = category.CreateEntry<float>("Render Scale", 1f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		RenderDistanceEntry = category.CreateEntry<float>("Render Distance", 200f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		DisableRenderDistanceTweaksEntry = category.CreateEntry<bool>("Disable Render Distance Tweaks", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		LODBiasEntry = category.CreateEntry<float>("LOD Bias", 1.5f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		FFRLevelEntry = category.CreateEntry<int>("FFR Level", 3, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		CustomPresetsEntry = category.CreateEntry<string>("Custom Presets", "{}", (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		LoadCustomPresets();
		MelonPreferences.Save();
		category.SaveToFile(true);
	}

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		((MelonMod)this).OnSceneWasLoaded(buildIndex, sceneName);
		ApplySettings();
		ApplyNeeded = true;
	}

	public override void OnUpdate()
	{
		((MelonBase)this).OnUpdate();
		if (ApplyNeeded && !(Time.time - TimerStart < 5f))
		{
			ApplySettings();
			ApplyNeeded = false;
			TimerStart = Time.time;
		}
	}

	private void ApplySettings()
	{
		SetRenderScale();
		SetRenderDistance();
		SetLODBias();
		SetFFR();
	}

	private void SetRenderScale()
	{
		UniversalRenderPipelineAsset asset = UniversalRenderPipeline.asset;
		if (!((Object)(object)asset == (Object)null))
		{
			asset.renderScale = RenderScaleEntry.Value;
		}
	}

	private void SetRenderDistance()
	{
		if ((Object)(object)playerCamera == (Object)null)
		{
			playerCamera = Object.FindObjectOfType<Camera>();
		}
		if (!((Object)(object)playerCamera == (Object)null))
		{
			if (!hasDefaultRenderDistance || (Object)(object)defaultRenderDistanceCamera != (Object)(object)playerCamera)
			{
				defaultRenderDistanceCamera = playerCamera;
				defaultRenderDistance = playerCamera.farClipPlane;
				hasDefaultRenderDistance = true;
			}
			if (DisableRenderDistanceTweaksEntry.Value)
			{
				playerCamera.farClipPlane = defaultRenderDistance;
				playerCamera.useOcclusionCulling = false;
			}
			else
			{
				playerCamera.farClipPlane = RenderDistanceEntry.Value;
				playerCamera.useOcclusionCulling = true;
			}
		}
	}

	private void SetLODBias()
	{
		QualitySettings.lodBias = LODBiasEntry.Value;
	}

	private void SetFFR()
	{
		ffrLevel = FFRLevelEntry.Value;
		Utils.useDynamicFoveatedRendering = false;
		Utils.foveatedRenderingLevel = ffrLevel;
	}

	private void ApplyPreset(string presetName)
	{
		if (string.Equals(presetName, "manual", StringComparison.OrdinalIgnoreCase))
		{
			ApplySettings();
			return;
		}
		if (!TryGetPreset(presetName, out var preset))
		{
			MelonLogger.Warning("Preset '" + presetName + "' was not found.");
			return;
		}
		RenderScaleEntry.Value = preset.RenderScale;
		RenderDistanceEntry.Value = preset.RenderDistance;
		DisableRenderDistanceTweaksEntry.Value = preset.DisableRenderDistanceTweaks;
		LODBiasEntry.Value = preset.LODBias;
		FFRLevelEntry.Value = preset.FFRLevel;
		ApplySettings();
		MelonPreferences.Save();
		category.SaveToFile(true);
	}

	private void SaveCurrentAsCustomPreset()
	{
		string text = NormalizePresetName(customPresetNameInput);
		if (string.IsNullOrWhiteSpace(text))
		{
			MelonLogger.Warning("Custom preset name cannot be empty.");
			return;
		}
		if (IsReservedPresetName(text))
		{
			MelonLogger.Warning("Preset name '" + text + "' is reserved.");
			return;
		}
		bool num = customPresets.ContainsKey(text);
		customPresets[text] = CreateCurrentPreset();
		CustomPresetsEntry.Value = JsonSerializer.Serialize(customPresets);
		MelonPreferences.Save();
		category.SaveToFile(true);
		if (!num)
		{
			CreatePresetMenuEntry(text, isBuiltIn: false);
		}
		MelonLogger.Msg(num ? ("Overwrote custom preset '" + text + "'.") : ("Saved custom preset '" + text + "'."));
	}

	private void LoadCustomPresets()
	{
		customPresets.Clear();
		if (string.IsNullOrWhiteSpace(CustomPresetsEntry.Value))
		{
			return;
		}
		try
		{
			Dictionary<string, GraphicsPreset> dictionary = JsonSerializer.Deserialize<Dictionary<string, GraphicsPreset>>(CustomPresetsEntry.Value);
			if (dictionary == null)
			{
				return;
			}
			foreach (var (text2, graphicsPreset2) in dictionary)
			{
				if (!IsReservedPresetName(text2) && graphicsPreset2 != null)
				{
					customPresets[text2] = graphicsPreset2;
				}
			}
		}
		catch (Exception ex)
		{
			MelonLogger.Warning("Failed to load custom presets: " + ex.Message);
			CustomPresetsEntry.Value = "{}";
		}
	}

	private void RemoveCustomPreset()
	{
		string text = NormalizePresetName(customPresetNameInput);
		if (string.IsNullOrWhiteSpace(text))
		{
			MelonLogger.Warning("Preset name cannot be empty.");
			return;
		}
		if (!customPresets.ContainsKey(text))
		{
			MelonLogger.Warning("Custom preset '" + text + "' does not exist.");
			return;
		}
		customPresets.Remove(text);
		CustomPresetsEntry.Value = JsonSerializer.Serialize(customPresets);
		MelonPreferences.Save();
		category.SaveToFile(true);
		if (customPresetElements.TryGetValue(text, out var value))
		{
			presetsPage.Remove((Element)(object)value);
			customPresetElements.Remove(text);
		}
	}

	private void CreatePresetMenuEntry(string presetName, bool isBuiltIn)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		if (presetsPage != null)
		{
			Color val = (isBuiltIn ? Color.yellow : Color.green);
			FunctionElement value = presetsPage.CreateFunction(presetName, val, (Action)delegate
			{
				ApplyPreset(presetName);
			});
			if (!isBuiltIn)
			{
				customPresetElements[presetName] = value;
			}
		}
	}

	private GraphicsPreset CreateCurrentPreset()
	{
		return new GraphicsPreset
		{
			RenderScale = RenderScaleEntry.Value,
			RenderDistance = RenderDistanceEntry.Value,
			DisableRenderDistanceTweaks = DisableRenderDistanceTweaksEntry.Value,
			LODBias = LODBiasEntry.Value,
			FFRLevel = FFRLevelEntry.Value
		};
	}

	private bool TryGetPreset(string presetName, out GraphicsPreset preset)
	{
		string key = NormalizePresetName(presetName);
		if (builtInPresets.TryGetValue(key, out preset))
		{
			return true;
		}
		return customPresets.TryGetValue(key, out preset);
	}

	private bool IsReservedPresetName(string presetName)
	{
		string text = NormalizePresetName(presetName);
		if (!string.Equals(text, "manual", StringComparison.OrdinalIgnoreCase))
		{
			return builtInPresets.ContainsKey(text);
		}
		return true;
	}

	private string NormalizePresetName(string presetName)
	{
		return presetName?.Trim() ?? string.Empty;
	}
}