using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("EquinoxsModUtils")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EquinoxsModUtils")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a197a340-3447-42f9-9cbf-125df5f6a400")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace EquinoxsModUtils;

public class FieldSearchInfo<T>
{
	internal string fieldName;

	internal T instance;

	internal bool classIsStatic;

	internal bool fieldIsStatic;

	private BindingFlags flags;

	internal Type Type => typeof(T);

	internal BindingFlags Flags => BindingFlags.NonPublic | (fieldIsStatic ? BindingFlags.Static : BindingFlags.Instance);

	public FieldSearchInfo(string fieldName, T instance, bool fieldIsStatic = false, bool classIsStatic = false)
	{
		this.fieldName = fieldName;
		this.instance = instance;
		this.fieldIsStatic = fieldIsStatic;
		this.fieldIsStatic = fieldIsStatic;
	}
}
internal static class EMULogging
{
	internal static void LogEMUInfo(string message)
	{
		EquinoxsModUtilsPlugin.Log.LogInfo((object)message);
	}

	internal static void LogEMUWarning(string message)
	{
		EquinoxsModUtilsPlugin.Log.LogWarning((object)message);
	}

	internal static void LogEMUError(string message)
	{
		EquinoxsModUtilsPlugin.Log.LogError((object)message);
	}
}
[BepInPlugin("com.equinox.EquinoxsModUtils", "EquinoxsModUtils", "1.1.0")]
public class EquinoxsModUtilsPlugin : BaseUnityPlugin
{
	internal const string MyGUID = "com.equinox.EquinoxsModUtils";

	private const string PluginName = "EquinoxsModUtils";

	private const string VersionString = "1.1.0";

	private static readonly Harmony Harmony = new Harmony("com.equinox.EquinoxsModUtils");

	internal static ManualLogSource Log = new ManualLogSource("EquinoxsModUtils");

	private void Awake()
	{
		((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
		((BaseUnityPlugin)this).Logger.LogInfo((object)"PluginName: EquinoxsModUtils, VersionString: 1.1.0 is loading...");
		((BaseUnityPlugin)this).Logger.LogInfo((object)"PluginName: EquinoxsModUtils, VersionString: 1.1.0 has loaded.");
		Log = ((BaseUnityPlugin)this).Logger;
	}
}
public static class EMU
{
	public static class Reflection
	{
		public static object GetPrivateField<T>(FieldSearchInfo<T> info)
		{
			FieldInfo field = info.Type.GetField(info.fieldName, info.Flags);
			if (field == null)
			{
				EMULogging.LogEMUError($"Could not find the field '{info.fieldName}' under type '{info.Type}'. Aborting attempt to get value");
				return null;
			}
			if (info.classIsStatic)
			{
				return field.GetValue(null);
			}
			return field.GetValue(info.instance);
		}

		public static object GetPrivateProperty<T>(FieldSearchInfo<T> info)
		{
			PropertyInfo property = info.Type.GetProperty(info.fieldName, info.Flags);
			if (property == null)
			{
				EMULogging.LogEMUError($"Could not find the property '{info.fieldName}' under type '{info.Type}'. Aborting attempt to get value");
				return null;
			}
			if (info.classIsStatic)
			{
				return property.GetValue(null);
			}
			return property.GetValue(info.instance);
		}

		public static void SetPrivateField<T>(FieldSearchInfo<T> info, object value)
		{
			FieldInfo field = info.Type.GetField(info.fieldName, info.Flags);
			if (field == null)
			{
				EMULogging.LogEMUError($"Could not find the field '{info.fieldName}' under type '{info.Type}'. Aborting attempt to set value");
			}
			else if (info.classIsStatic)
			{
				field.SetValue(null, value);
			}
			else
			{
				field.SetValue(info.instance, value);
			}
		}

		public static void InvokePrivateMethod<T>(FieldSearchInfo<T> info, object[] args)
		{
			MethodInfo method = info.Type.GetMethod(info.fieldName, info.Flags);
			if (method == null)
			{
				EMULogging.LogEMUError($"Could not find the method '{info.fieldName}' under type '{info.Type}'. Aborting attempt to invoke");
			}
			else if (info.classIsStatic)
			{
				method.Invoke(null, args);
			}
			else
			{
				method.Invoke(info.instance, args);
			}
		}
	}
}