using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using Photon.Pun;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.muttfrommars.PeakMeneBong")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0")]
[assembly: AssemblyProduct("com.github.muttfrommars.PeakMeneBong")]
[assembly: AssemblyTitle("MeneBong")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.0.0")]
[module: UnverifiableCode]
[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;
		}
	}
}
[BepInPlugin("com.github.muttfrommars.PeakMeneBong", "MeneBong", "1.2.0")]
public class PrefabRedirector : BaseUnityPlugin
{
	private sealed class RedirectingPool : IPunPrefabPool
	{
		private readonly IPunPrefabPool _inner;

		private readonly RedirectMap _map;

		private readonly ManualLogSource _log;

		public RedirectingPool(IPunPrefabPool inner, RedirectMap map, ManualLogSource log)
		{
			_inner = inner;
			_map = map;
			_log = log;
		}

		public GameObject Instantiate(string prefabId, Vector3 position, Quaternion rotation)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			string text = prefabId;
			int num = text.LastIndexOfAny(new char[2] { '/', '\\' });
			if (num >= 0)
			{
				string text2 = text;
				int num2 = num + 1;
				text = text2.Substring(num2, text2.Length - num2);
			}
			if (text.EndsWith(".prefab", StringComparison.OrdinalIgnoreCase))
			{
				string text2 = text;
				text = text2.Substring(0, text2.Length - 7);
			}
			if (string.Equals(text, "bingbong", StringComparison.OrdinalIgnoreCase))
			{
				ManualLogSource log = _log;
				if (log != null)
				{
					log.LogInfo((object)("[Redirector/Pool] '" + prefabId + "' -> 'menebong'"));
				}
				prefabId = "menebong";
			}
			else
			{
				ManualLogSource log2 = _log;
				if (log2 != null)
				{
					log2.LogInfo((object)("[Redirector/Pool] requested '" + prefabId + "' (no redirect)"));
				}
			}
			return _inner.Instantiate(prefabId, position, rotation);
		}

		public void Destroy(GameObject gameObject)
		{
			_inner.Destroy(gameObject);
		}
	}

	public sealed class RedirectMap
	{
		private readonly Dictionary<string, string> _mapCI;

		public RedirectMap(Dictionary<string, string> mapCI)
		{
			_mapCI = mapCI;
		}

		public bool TryRedirect(string id, out string replacement)
		{
			if (id == null)
			{
				replacement = null;
				return false;
			}
			if (_mapCI.TryGetValue(id, out replacement))
			{
				return true;
			}
			string text;
			if (!id.EndsWith(".prefab", StringComparison.OrdinalIgnoreCase))
			{
				text = id;
			}
			else
			{
				string text2 = id;
				text = text2.Substring(0, text2.Length - 7);
			}
			string text3 = text;
			if ((object)text3 != id && _mapCI.TryGetValue(text3, out replacement))
			{
				return true;
			}
			int num = text3.LastIndexOfAny(new char[2] { '/', '\\' });
			if (num >= 0)
			{
				string text2 = text3;
				int num2 = num + 1;
				string key = text2.Substring(num2, text2.Length - num2);
				if (_mapCI.TryGetValue(key, out replacement))
				{
					return true;
				}
			}
			replacement = null;
			return false;
		}

		public bool TryRedirectByTrailingSegment(string path, out string replacement)
		{
			replacement = null;
			if (string.IsNullOrEmpty(path))
			{
				return false;
			}
			int num = path.LastIndexOfAny(new char[2] { '/', '\\' });
			if (num < 0)
			{
				return false;
			}
			int num2 = num + 1;
			string id = path.Substring(num2, path.Length - num2);
			return TryRedirect(id, out replacement);
		}
	}

	[CompilerGenerated]
	private sealed class <EnsureWrappedPool>d__7 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public PrefabRedirector <>4__this;

		private int <i>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <EnsureWrappedPool>d__7(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			int num = <>1__state;
			PrefabRedirector prefabRedirector = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<i>5__2 = 0;
				goto IL_0059;
			case 1:
				<>1__state = -1;
				<i>5__2++;
				goto IL_0059;
			case 2:
				{
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				IL_0059:
				if (<i>5__2 < 30)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				prefabRedirector.WrapIfNeeded();
				<i>5__2 = 0;
				break;
			}
			if (<i>5__2 < 300)
			{
				if (prefabRedirector.WrapIfNeeded())
				{
					((BaseUnityPlugin)prefabRedirector).Logger.LogInfo((object)"[Redirector] Re-wrapped pool after a late swap.");
				}
				<>2__current = null;
				<>1__state = 2;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private AssetBundle _bundle;

	private Harmony _harmony;

	private Material _menebongMat;

	private Texture2D _menebongTex;

	private static readonly RedirectMap Map = new RedirectMap(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "bingbong", "menebong" } });

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_030f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0319: Expected O, but got Unknown
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Expected O, but got Unknown
		Application.logMessageReceived += (LogCallback)delegate(string cond, string stack, LogType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			if ((int)type == 0 || (int)type == 4)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("[UnityLog] " + cond));
			}
		};
		try
		{
			string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			string text = Path.Combine(directoryName, "menebong");
			_bundle = (File.Exists(text) ? AssetBundle.LoadFromFile(text) : null);
			if ((Object)(object)_bundle == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Bundle 'menebong' not found (skipping). If 'menebong' is in Resources, this is fine.");
			}
			else
			{
				GameObject val = _bundle.LoadAsset<GameObject>("MeneBong.prefab");
				if ((Object)(object)val == (Object)null)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"MeneBong.prefab not found in bundle.");
				}
				else
				{
					if ((Object)(object)val.GetComponent<PhotonView>() == (Object)null)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)"MeneBong.prefab has no PhotonView; add one if this is network-spawned.");
					}
					try
					{
						_menebongMat = _bundle.LoadAsset<Material>("M_MeneBong.mat");
						if ((Object)(object)_menebongMat == (Object)null)
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)"M_MeneBong.mat not found in bundle.");
						}
						if ((Object)(object)_menebongMat != (Object)null)
						{
							string text2 = (((Object)(object)_menebongMat.shader != (Object)null) ? ((Object)_menebongMat.shader).name : "<null>");
							Shader val2 = ((!string.IsNullOrEmpty(text2)) ? Shader.Find(text2) : null);
							if ((Object)(object)_menebongMat.shader == (Object)null || !_menebongMat.shader.isSupported || ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)_menebongMat.shader))
							{
								try
								{
									if ((Object)(object)val2 == (Object)null)
									{
										((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not find runtime shader '" + text2 + "'. Material may render pink if its compiled backend is missing."));
									}
									else
									{
										Material val3 = new Material(val2);
										val3.CopyPropertiesFromMaterial(_menebongMat);
										_menebongMat = val3;
										((BaseUnityPlugin)this).Logger.LogInfo((object)("Rebound MeneBong material to runtime shader '" + ((Object)val2).name + "'."));
									}
								}
								catch (Exception ex)
								{
									((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to rebind MeneBong shader '" + text2 + "': " + ex.Message));
								}
							}
							_menebongTex = _bundle.LoadAsset<Texture2D>("t_menebong.png");
							if ((Object)(object)_menebongTex != (Object)null)
							{
								if (_menebongMat.HasProperty("_BaseMap"))
								{
									_menebongMat.SetTexture("_BaseMap", (Texture)(object)_menebongTex);
								}
								if (_menebongMat.HasProperty("_MainTex"))
								{
									_menebongMat.SetTexture("_MainTex", (Texture)(object)_menebongTex);
								}
							}
						}
						ApplyMenebongMaterial(val, _menebongMat);
						NetworkPrefabManager.RegisterNetworkPrefab("menebong", val);
						((BaseUnityPlugin)this).Logger.LogInfo((object)"Registered 'menebong' with NetworkPrefabManager using M_MeneBong.mat.");
					}
					catch (Exception ex2)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)("RegisterNetworkPrefab warning: " + ex2.Message));
					}
				}
			}
		}
		catch (Exception arg)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)$"Bundle/load error: {arg}");
		}
		((MonoBehaviour)this).StartCoroutine(EnsureWrappedPool());
		SceneManager.activeSceneChanged += delegate
		{
			((MonoBehaviour)this).StartCoroutine(EnsureWrappedPool());
		};
		_harmony = new Harmony("com.github.muttfrommars.PeakMeneBong");
		TryPatchPhotonInstantiate();
		TryPatchPeakLibSpawn();
		TryPatchResourcesLoad(optional: false);
	}

	private static void ApplyMenebongMaterial(GameObject root, Material mat)
	{
		if ((Object)(object)root == (Object)null || (Object)(object)mat == (Object)null)
		{
			return;
		}
		Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
		foreach (Renderer val in componentsInChildren)
		{
			Material[] sharedMaterials = val.sharedMaterials;
			if (sharedMaterials == null || sharedMaterials.Length == 0)
			{
				val.sharedMaterial = mat;
				continue;
			}
			for (int j = 0; j < sharedMaterials.Length; j++)
			{
				sharedMaterials[j] = mat;
			}
			val.sharedMaterials = sharedMaterials;
		}
	}

	[IteratorStateMachine(typeof(<EnsureWrappedPool>d__7))]
	private IEnumerator EnsureWrappedPool()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <EnsureWrappedPool>d__7(0)
		{
			<>4__this = this
		};
	}

	private bool WrapIfNeeded()
	{
		IPunPrefabPool prefabPool = PhotonNetwork.PrefabPool;
		if (prefabPool is RedirectingPool)
		{
			return false;
		}
		string text = ((object)prefabPool)?.GetType().FullName ?? "<null>";
		if (prefabPool == null)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"[Redirector] PhotonNetwork.PrefabPool is null; will try later.");
			return false;
		}
		PhotonNetwork.PrefabPool = (IPunPrefabPool)(object)new RedirectingPool(prefabPool, Map, ((BaseUnityPlugin)this).Logger);
		((BaseUnityPlugin)this).Logger.LogInfo((object)("[Redirector] Wrapped " + text + " with RedirectingPool."));
		return true;
	}

	private void TryPatchPhotonInstantiate()
	{
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Expected O, but got Unknown
		try
		{
			Type typeFromHandle = typeof(PhotonNetwork);
			MethodInfo methodInfo = AccessTools.Method(typeFromHandle, "Instantiate", new Type[5]
			{
				typeof(string),
				typeof(Vector3),
				typeof(Quaternion),
				typeof(byte),
				typeof(object[])
			}, (Type[])null);
			if (methodInfo != null)
			{
				_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PrefabRedirector), "Prefix_Photon_Instantiate", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Redirector] Patched PhotonNetwork.Instantiate.");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"[Redirector] PhotonNetwork.Instantiate overload not found (version mismatch?).");
			}
		}
		catch (Exception arg)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)$"Patch PhotonNetwork.Instantiate failed: {arg}");
		}
	}

	private void TryPatchPeakLibSpawn()
	{
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Expected O, but got Unknown
		try
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(NetworkPrefabManager), "SpawnNetworkPrefab", new Type[5]
			{
				typeof(string),
				typeof(Vector3),
				typeof(Quaternion),
				typeof(byte),
				typeof(object[])
			}, (Type[])null);
			if (methodInfo != null)
			{
				_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PrefabRedirector), "Prefix_PeakLib_Spawn", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Redirector] Patched NetworkPrefabManager.SpawnNetworkPrefab.");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"[Redirector] NetworkPrefabManager.SpawnNetworkPrefab not found.");
			}
		}
		catch (Exception arg)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)$"Patch SpawnNetworkPrefab failed: {arg}");
		}
	}

	private void TryPatchResourcesLoad(bool optional)
	{
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Expected O, but got Unknown
		try
		{
			MethodInfo method = typeof(Resources).GetMethod("Load", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
			if (method != null)
			{
				_harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(PrefabRedirector), "Prefix_Resources_Load", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Redirector] Patched Resources.Load(string).");
			}
			else if (!optional)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"[Redirector] Resources.Load(string) not found (unexpected).");
			}
		}
		catch (Exception arg)
		{
			if (!optional)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Patch Resources.Load failed: {arg}");
			}
		}
	}

	public static bool Prefix_Photon_Instantiate(ref string prefabName, Vector3 position, Quaternion rotation, byte group, object[] data)
	{
		if (Map.TryRedirect(prefabName, out string replacement))
		{
			Debug.Log((object)("[Redirector/Photon] '" + prefabName + "' -> '" + replacement + "'"));
			prefabName = replacement;
		}
		else
		{
			Debug.Log((object)("[Redirector/Photon] requested '" + prefabName + "' (no redirect)"));
		}
		return true;
	}

	public static bool Prefix_PeakLib_Spawn(ref string prefabId, Vector3 position, Quaternion rotation, byte group, object[] data)
	{
		if (Map.TryRedirect(prefabId, out string replacement))
		{
			Debug.Log((object)("[Redirector/PEAK] '" + prefabId + "' -> '" + replacement + "'"));
			prefabId = replacement;
		}
		else
		{
			Debug.Log((object)("[Redirector/PEAK] requested '" + prefabId + "' (no redirect)"));
		}
		return true;
	}

	public static bool Prefix_Resources_Load(ref string path)
	{
		if (Map.TryRedirect(path, out string replacement))
		{
			Debug.Log((object)("[Redirector/Resources] '" + path + "' -> '" + replacement + "'"));
			path = replacement;
		}
		else if (Map.TryRedirectByTrailingSegment(path, out replacement))
		{
			Debug.Log((object)("[Redirector/Resources] (trail) '" + path + "' -> '" + replacement + "'"));
			path = replacement;
		}
		return true;
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}