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 MelonLoader;
using MelonLoader.Preferences;
using QuestGraphicsSettings;
using Unity.XR.Oculus;
using UnityEngine;
using UnityEngine.Rendering.Universal;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Core), "QuestGraphicsSettings", "2.2.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+749465b67de512c55094281ec5c0b3c4eba9681e")]
[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 presetsPage;

	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 = false,
			LODBias = 1f,
			FFRLevel = 3
		},
		["medium"] = new GraphicsPreset
		{
			RenderScale = 1f,
			RenderDistance = 120f,
			DisableRenderDistanceTweaks = false,
			LODBias = 1.25f,
			FFRLevel = 3
		},
		["high"] = new GraphicsPreset
		{
			RenderScale = 1.5f,
			RenderDistance = 120f,
			DisableRenderDistanceTweaks = true,
			LODBias = 1.5f,
			FFRLevel = 3
		}
	};

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

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

	public override void OnDeinitializeMelon()
	{
		Hooking.OnLevelLoaded -= OnLevelLoaded;
	}

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

	private void SetupBoneMenu()
	{
		//IL_000a: 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)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		Page val = Page.Root.CreatePage("Jorink", Color.red, 0, true).CreatePage("QuestGraphicsSettings", Color.red, 0, true);
		val.CreateFloat("Render Scale", Color.yellow, RenderScaleEntry.Value, 0.05f, 0.5f, 2f, (Action<float>)delegate(float a)
		{
			RenderScaleEntry.Value = a;
			SetRenderScale();
		});
		val.CreateFloat("Render Distance", Color.green, RenderDistanceEntry.Value, 5f, 5f, 300f, (Action<float>)delegate(float a)
		{
			RenderDistanceEntry.Value = a;
			SetRenderDistance();
		});
		val.CreateBool("Disable Render Distance Tweaks", Color.cyan, DisableRenderDistanceTweaksEntry.Value, (Action<bool>)delegate(bool a)
		{
			DisableRenderDistanceTweaksEntry.Value = a;
			SetRenderDistance();
		});
		val.CreateFloat("LOD Bias", Color.yellow, LODBiasEntry.Value, 0.05f, 0.5f, 2f, (Action<float>)delegate(float a)
		{
			LODBiasEntry.Value = a;
			SetLODBias();
		});
		val.CreateInt("FFR Level", Color.green, FFRLevelEntry.Value, 1, 0, 3, (Action<int>)delegate(int a)
		{
			FFRLevelEntry.Value = a;
			SetFFR();
		});
		val.CreateFunction("Save Settings", Color.cyan, (Action)delegate
		{
			MelonPreferences.Save();
		});
		presetsPage = val.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 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", 120f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		DisableRenderDistanceTweaksEntry = category.CreateEntry<bool>("Disable Render Distance Tweaks", false, (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()
	{
		if (ApplyNeeded && !(Time.time - TimerStart < 5f))
		{
			ApplySettings();
			ApplyNeeded = false;
			TimerStart = Time.time;
		}
	}

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

	private void SetRenderScale()
	{
		SetRenderScale(null);
	}

	private void SetRenderScale(string presetName)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		UniversalRenderPipelineAsset asset = UniversalRenderPipeline.asset;
		if (!((Object)asset == (Object)null))
		{
			asset.renderScale = ResolvePreset(presetName).RenderScale;
		}
	}

	private void SetRenderDistance()
	{
		SetRenderDistance(null);
	}

	private void SetRenderDistance(string presetName)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Expected O, but got Unknown
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Expected O, but got Unknown
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Expected O, but got Unknown
		//IL_005d: Expected O, but got Unknown
		GraphicsPreset graphicsPreset = ResolvePreset(presetName);
		if ((Object)playerCamera == (Object)null)
		{
			playerCamera = Object.FindObjectOfType<Camera>();
		}
		if (!((Object)playerCamera == (Object)null))
		{
			if (!hasDefaultRenderDistance || (Object)defaultRenderDistanceCamera != (Object)playerCamera)
			{
				defaultRenderDistanceCamera = playerCamera;
				defaultRenderDistance = playerCamera.farClipPlane;
				hasDefaultRenderDistance = true;
			}
			if (graphicsPreset.DisableRenderDistanceTweaks)
			{
				playerCamera.farClipPlane = defaultRenderDistance;
				playerCamera.useOcclusionCulling = false;
			}
			else
			{
				playerCamera.farClipPlane = graphicsPreset.RenderDistance;
				playerCamera.useOcclusionCulling = true;
			}
		}
	}

	private void SetLODBias()
	{
		SetLODBias(null);
	}

	private void SetLODBias(string presetName)
	{
		QualitySettings.lodBias = ResolvePreset(presetName).LODBias;
	}

	private void SetFFR()
	{
		SetFFR(null);
	}

	private void SetFFR(string presetName)
	{
		ffrLevel = ResolvePreset(presetName).FFRLevel;
		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 GraphicsPreset ResolvePreset(string presetName)
	{
		if (string.IsNullOrWhiteSpace(presetName) || string.Equals(presetName, "manual", StringComparison.OrdinalIgnoreCase))
		{
			return CreateCurrentPreset();
		}
		if (TryGetPreset(presetName, out var preset))
		{
			return preset;
		}
		MelonLogger.Warning("Preset '" + presetName + "' was not found. Falling back to manual settings.");
		return CreateCurrentPreset();
	}

	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;
	}
}