using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib;
using BoneLib.BoneMenu;
using Il2CppSLZ.VRMK;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using TitanStrength;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(TitanStrengthMod), "Titan Strength", "1.0.0", "ChappieStudios", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("TitanStrength")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TitanStrength")]
[assembly: AssemblyTitle("TitanStrength")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace TitanStrength
{
	public sealed class TitanStrengthMod : MelonMod
	{
		private const float MenuStep = 5f;

		private const float MenuMin = 1f;

		private const float MenuMax = float.MaxValue;

		private MelonPreferences_Category _category;

		private MelonPreferences_Entry<bool> _enabled;

		private MelonPreferences_Entry<float> _strengthMultiplier;

		private MelonPreferences_Entry<float> _physHandMultiplier;

		private readonly Dictionary<string, float> _originalValues = new Dictionary<string, float>();

		private float _nextApplyTime;

		private bool _menuRegistered;

		public override void OnInitializeMelon()
		{
			_category = MelonPreferences.CreateCategory("TitanStrength");
			_enabled = _category.CreateEntry<bool>("Enabled", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			_strengthMultiplier = _category.CreateEntry<float>("AvatarStrengthMultiplier", 50f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			_physHandMultiplier = _category.CreateEntry<float>("HandForceMultiplier", 30f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			RegisterBoneMenu();
			((MelonBase)this).LoggerInstance.Msg("Titan Strength loaded. BoneMenu toggle is under Mods > Titan Strength. F8 toggles it too.");
		}

		public override void OnUpdate()
		{
			if (Input.GetKeyDown((KeyCode)289))
			{
				SetEnabled(!_enabled.Value);
			}
			if (!(Time.time < _nextApplyTime))
			{
				_nextApplyTime = Time.time + 0.75f;
				if (_enabled.Value)
				{
					ApplyStrength();
				}
				else
				{
					RestoreOriginals();
				}
			}
		}

		public override void OnDeinitializeMelon()
		{
			RestoreOriginals();
		}

		private void RegisterBoneMenu()
		{
			//IL_0023: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if (_menuRegistered)
			{
				return;
			}
			try
			{
				Page obj = Page.Root.CreatePage("Titan Strength", new Color(1f, 0.25f, 0.05f), 0, true);
				obj.CreateBool("Enabled", Color.green, _enabled.Value, (Action<bool>)SetEnabled);
				obj.CreateFloat("Avatar Strength", Color.yellow, _strengthMultiplier.Value, 5f, 1f, float.MaxValue, (Action<float>)delegate(float value)
				{
					_strengthMultiplier.Value = value;
					_category.SaveToFile(false);
					if (_enabled.Value)
					{
						ClearCachedOriginalsForReapply();
						ApplyStrength();
					}
				});
				obj.CreateFloat("Hand Force", Color.cyan, _physHandMultiplier.Value, 5f, 1f, float.MaxValue, (Action<float>)delegate(float value)
				{
					_physHandMultiplier.Value = value;
					_category.SaveToFile(false);
					if (_enabled.Value)
					{
						ClearCachedOriginalsForReapply();
						ApplyStrength();
					}
				});
				obj.CreateFunction("Reapply Now", Color.white, (Action)ApplyStrength);
				_menuRegistered = true;
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Warning("BoneMenu registration failed, F8 fallback still works: " + ex.Message);
			}
		}

		private void SetEnabled(bool enabled)
		{
			_enabled.Value = enabled;
			_category.SaveToFile(false);
			if (enabled)
			{
				ApplyStrength();
				((MelonBase)this).LoggerInstance.Msg("Titan Strength enabled.");
			}
			else
			{
				RestoreOriginals();
				((MelonBase)this).LoggerInstance.Msg("Titan Strength disabled.");
			}
		}

		private void ApplyStrength()
		{
			Avatar avatar = Player.Avatar;
			if ((Object)(object)avatar != (Object)null)
			{
				BoostFloatProperty(avatar, "_strengthUpper", _strengthMultiplier.Value);
				BoostFloatProperty(avatar, "_strengthLower", _strengthMultiplier.Value);
				BoostFloatProperty(avatar, "_strengthGrip", _strengthMultiplier.Value);
			}
			BoostHand(Player.LeftHand, "Left");
			BoostHand(Player.RightHand, "Right");
		}

		private void BoostHand(object hand, string side)
		{
			if (hand != null)
			{
				InvokeIfExists(hand, "SetGripStrength", _strengthMultiplier.Value);
				object propertyOrField = GetPropertyOrField(hand, "physHand");
				if (propertyOrField != null)
				{
					BoostFloatProperty(propertyOrField, "_forceMultiplier", _physHandMultiplier.Value, side + ".");
					BoostFloatProperty(propertyOrField, "gripMult", _strengthMultiplier.Value, side + ".");
					BoostFloatProperty(propertyOrField, "xPosForce", _physHandMultiplier.Value, side + ".");
					BoostFloatProperty(propertyOrField, "xNegForce", _physHandMultiplier.Value, side + ".");
					BoostFloatProperty(propertyOrField, "yPosForce", _physHandMultiplier.Value, side + ".");
					BoostFloatProperty(propertyOrField, "yNegForce", _physHandMultiplier.Value, side + ".");
					BoostFloatProperty(propertyOrField, "zPosForce", _physHandMultiplier.Value, side + ".");
					BoostFloatProperty(propertyOrField, "zNegForce", _physHandMultiplier.Value, side + ".");
				}
			}
		}

		private void BoostFloatProperty(object target, string name, float multiplier, string prefix = "")
		{
			Type type = target.GetType();
			string key = prefix + type.FullName + "." + name;
			MemberInfo memberInfo = FindPropertyOrField(type, name);
			if (memberInfo == null)
			{
				return;
			}
			float? num = ReadFloat(target, memberInfo);
			if (num.HasValue)
			{
				if (!_originalValues.ContainsKey(key))
				{
					_originalValues[key] = num.Value;
				}
				float value = Mathf.Max(_originalValues[key] * multiplier, multiplier);
				WriteFloat(target, memberInfo, value);
			}
		}

		private void RestoreOriginals()
		{
			Avatar avatar = Player.Avatar;
			if ((Object)(object)avatar != (Object)null)
			{
				RestoreFloatProperty(avatar, "_strengthUpper");
				RestoreFloatProperty(avatar, "_strengthLower");
				RestoreFloatProperty(avatar, "_strengthGrip");
			}
			RestoreHand(Player.LeftHand, "Left");
			RestoreHand(Player.RightHand, "Right");
		}

		private void RestoreHand(object hand, string side)
		{
			if (hand == null)
			{
				return;
			}
			object propertyOrField = GetPropertyOrField(hand, "physHand");
			if (propertyOrField != null)
			{
				string[] array = new string[8] { "_forceMultiplier", "gripMult", "xPosForce", "xNegForce", "yPosForce", "yNegForce", "zPosForce", "zNegForce" };
				foreach (string name in array)
				{
					RestoreFloatProperty(propertyOrField, name, side + ".");
				}
			}
		}

		private void RestoreFloatProperty(object target, string name, string prefix = "")
		{
			Type type = target.GetType();
			string key = prefix + type.FullName + "." + name;
			if (_originalValues.TryGetValue(key, out var value))
			{
				MemberInfo memberInfo = FindPropertyOrField(type, name);
				if (memberInfo != null)
				{
					WriteFloat(target, memberInfo, value);
				}
			}
		}

		private void ClearCachedOriginalsForReapply()
		{
			RestoreOriginals();
			_originalValues.Clear();
		}

		private static MemberInfo FindPropertyOrField(Type type, string name)
		{
			return (MemberInfo)(((object)type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) ?? ((object)type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)));
		}

		private static float? ReadFloat(object target, MemberInfo member)
		{
			try
			{
				if (member is PropertyInfo propertyInfo && propertyInfo.PropertyType == typeof(float))
				{
					return (float)propertyInfo.GetValue(target);
				}
				if (member is FieldInfo fieldInfo && fieldInfo.FieldType == typeof(float))
				{
					return (float)fieldInfo.GetValue(target);
				}
			}
			catch
			{
			}
			return null;
		}

		private static void WriteFloat(object target, MemberInfo member, float value)
		{
			try
			{
				if (member is PropertyInfo propertyInfo)
				{
					if (propertyInfo.CanWrite && propertyInfo.PropertyType == typeof(float))
					{
						propertyInfo.SetValue(target, value);
					}
				}
				else if (member is FieldInfo fieldInfo && fieldInfo.FieldType == typeof(float))
				{
					fieldInfo.SetValue(target, value);
				}
			}
			catch
			{
			}
		}

		private static object GetPropertyOrField(object target, string name)
		{
			MemberInfo memberInfo = FindPropertyOrField(target.GetType(), name);
			try
			{
				if (memberInfo is PropertyInfo propertyInfo)
				{
					return propertyInfo.GetValue(target);
				}
				if (memberInfo is FieldInfo fieldInfo)
				{
					return fieldInfo.GetValue(target);
				}
			}
			catch
			{
			}
			return null;
		}

		private static void InvokeIfExists(object target, string name, params object[] args)
		{
			try
			{
				target.GetType().GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(target, args);
			}
			catch
			{
			}
		}
	}
}