using System;
using System.Collections;
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 Landoria.SharedLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Landoria.GetMyTrophyBack")]
[assembly: AssemblyDescription("Returns trophies after guardian power selection.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Landoria")]
[assembly: AssemblyProduct("Landoria.GetMyTrophyBack")]
[assembly: AssemblyCopyright("Copyright © 2026 End3rbyte")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("66592EBD-C28B-46B8-996D-6D4BF2FB210F")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.17312")]
namespace Landoria.GetMyTrophyBack
{
	[BepInPlugin("Landoria.GetMyTrophyBack", "Landoria.GetMyTrophyBack", "1.0.0")]
	public sealed class GetMyTrophyBackPlugin : LandoriaPlugin
	{
		private const string PluginGuid = "Landoria.GetMyTrophyBack";

		private const string PluginName = "Landoria.GetMyTrophyBack";

		private const string PluginVersion = "1.0.0";

		internal static ModLog Log { get; private set; }

		private void Awake()
		{
			Log = InitializePlugin("Landoria.GetMyTrophyBack");
			Log.LogInfo("Landoria.GetMyTrophyBack 1.0.0 is loaded.");
		}

		private void OnDestroy()
		{
			ShutdownPlugin();
			Log = null;
		}
	}
	[HarmonyPatch(typeof(ItemStand), "DelayedPowerActivation")]
	internal static class DropTrophyAfterPowerActivationPatch
	{
		private static void Postfix(ItemStand __instance)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)__instance.m_guardianPower == (Object)null) && !(localPlayer.GetGuardianPowerName() != ((Object)__instance.m_guardianPower).name))
			{
				((MonoBehaviour)__instance).StartCoroutine(TrophyDropService.DropAfterDelay(__instance));
				GetMyTrophyBackPlugin.Log.LogDebug("Scheduled trophy drop for " + ((Object)__instance.m_guardianPower).name + ".");
			}
		}
	}
	[HarmonyPatch(typeof(ItemStand), "Awake")]
	internal static class RegisterTrophyDropRpcPatch
	{
		private static void Postfix(ItemStand __instance, ZNetView ___m_nview)
		{
			if (!((Object)(object)__instance.m_guardianPower == (Object)null) && !((Object)(object)___m_nview == (Object)null) && ___m_nview.GetZDO() != null)
			{
				___m_nview.Register("Landoria_DropGuardianTrophy", (Action<long>)delegate(long sender)
				{
					TrophyDropService.HandleDropRequest(__instance, ___m_nview, sender);
				});
				GetMyTrophyBackPlugin.Log.LogDebug("Registered trophy drop RPC for " + ((Object)__instance.m_guardianPower).name + ".");
			}
		}
	}
	internal static class TrophyDropService
	{
		internal const string RpcName = "Landoria_DropGuardianTrophy";

		private const float DropDelaySeconds = 5f;

		internal static IEnumerator DropAfterDelay(ItemStand itemStand)
		{
			yield return (object)new WaitForSeconds(5f);
			if (!((Object)(object)itemStand == (Object)null) && itemStand.HaveAttachment())
			{
				ZNetView netView = GetNetView(itemStand);
				if ((Object)(object)netView == (Object)null || !netView.IsValid())
				{
					GetMyTrophyBackPlugin.Log.LogWarning("Could not request the trophy drop because its network view is invalid.");
				}
				else
				{
					netView.InvokeRPC("Landoria_DropGuardianTrophy", Array.Empty<object>());
				}
			}
		}

		internal static void HandleDropRequest(ItemStand itemStand, ZNetView netView, long sender)
		{
			if (netView.IsOwner() && itemStand.HaveAttachment())
			{
				ZDO zDO = netView.GetZDO();
				string text = zDO.GetString(ZDOVars.s_item, "");
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
				if ((Object)(object)itemPrefab == (Object)null)
				{
					GetMyTrophyBackPlugin.Log.LogWarning("Could not drop missing trophy prefab " + text + ".");
					return;
				}
				SpawnTrophy(itemStand, itemPrefab, zDO);
				ClearAttachment(netView, zDO);
				GetMyTrophyBackPlugin.Log.LogDebug($"Dropped trophy {text} after power activation by peer {sender}.");
			}
		}

		private static ZNetView GetNetView(ItemStand itemStand)
		{
			if (!Object.op_Implicit((Object)(object)itemStand.m_netViewOverride))
			{
				return ((Component)itemStand).GetComponent<ZNetView>();
			}
			return itemStand.m_netViewOverride;
		}

		private static void SpawnTrophy(ItemStand itemStand, GameObject prefab, ZDO zdo)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			GetAttachmentOffset(prefab, out var position, out var rotation);
			Transform dropSpawnPoint = itemStand.m_dropSpawnPoint;
			GameObject obj = Object.Instantiate<GameObject>(prefab, dropSpawnPoint.position + position, dropSpawnPoint.rotation * rotation);
			obj.GetComponent<ItemDrop>().LoadFromExternalZDO(zdo);
			Rigidbody component = obj.GetComponent<Rigidbody>();
			if ((Object)(object)component != (Object)null)
			{
				component.linearVelocity = Vector3.up * 4f;
			}
			itemStand.m_effects.Create(dropSpawnPoint.position, Quaternion.identity, (Transform)null, 1f, -1);
		}

		private static void GetAttachmentOffset(GameObject prefab, out Vector3 position, out Quaternion rotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			rotation = Quaternion.identity;
			Transform val = prefab.transform.Find("attach");
			if ((Object)(object)prefab.transform.Find("attachobj") != (Object)null && (Object)(object)val != (Object)null)
			{
				position = val.localPosition;
				rotation = val.localRotation;
			}
		}

		private static void ClearAttachment(ZNetView netView, ZDO zdo)
		{
			zdo.Set(ZDOVars.s_item, "");
			zdo.Set(ZDOVars.s_type, 0, false);
			netView.InvokeRPC(ZNetView.Everybody, "SetVisualItem", new object[4] { "", 0, 0, 0 });
		}
	}
}
namespace Landoria.SharedLib
{
	public abstract class LandoriaPlugin : BaseUnityPlugin
	{
		private Harmony _harmony;

		private bool _patchesApplied;

		protected ModLog InitializePlugin(string pluginGuid)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			ModLog modLog = new ModLog(((BaseUnityPlugin)this).Logger);
			Version version = ((object)this).GetType().Assembly.GetName().Version;
			modLog.LogInfo($"AssemblyVersion: {version}.");
			_harmony = new Harmony(pluginGuid);
			PatchOwnNamespace(modLog);
			return modLog;
		}

		protected void PatchOwnNamespace(ModLog log)
		{
			if (_patchesApplied)
			{
				log.LogDebug("Harmony patches are already active; skipping registration.");
				return;
			}
			string text = ((object)this).GetType().Namespace;
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				if (type.Namespace == text)
				{
					_harmony.CreateClassProcessor(type).Patch();
				}
			}
			_patchesApplied = true;
			log.LogDebug("Harmony patches were applied for the plugin namespace.");
		}

		protected void ShutdownPlugin()
		{
			if (_patchesApplied)
			{
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
				_patchesApplied = false;
			}
		}
	}
	public sealed class ModLog
	{
		private readonly ManualLogSource _logger;

		public ModLog(ManualLogSource logger)
		{
			_logger = logger;
		}

		public void LogFatal(object message)
		{
			Write((LogLevel)1, message);
		}

		public void LogError(object message)
		{
			Write((LogLevel)2, message);
		}

		public void LogWarning(object message)
		{
			Write((LogLevel)4, message);
		}

		public void LogMessage(object message)
		{
			Write((LogLevel)8, message);
		}

		public void LogInfo(object message)
		{
			Write((LogLevel)16, message);
		}

		public void LogDebug(object message)
		{
			Write((LogLevel)32, message);
		}

		public void Log(LogLevel level, object message)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Write(level, message);
		}

		private void Write(LogLevel level, object message)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			string arg = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
			_logger.Log(level, (object)$"[{arg}] {message}");
		}
	}
}