using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour.HookGen;
using MyceliumNetworking;
using On;
using Photon.Pun;

[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("alexandria-p.KeepCameraAfterDeath")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+1d3d9f3aa5e06c81550a1a42825c7ae7ab5db9e4")]
[assembly: AssemblyProduct("KeepCameraAfterDeath")]
[assembly: AssemblyTitle("alexandria-p.KeepCameraAfterDeath")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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;
		}
	}
}
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 KeepCameraAfterDeath
{
	[ContentWarningPlugin("alexandria-p.KeepCameraAfterDeath", "1.0.0", false)]
	[BepInPlugin("alexandria-p.KeepCameraAfterDeath", "KeepCameraAfterDeath", "1.0.0")]
	public class KeepCameraAfterDeath : BaseUnityPlugin
	{
		private const uint myceliumNetworkModId = 61812u;

		public static KeepCameraAfterDeath Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		public bool PlayerSettingEnableRewardForCameraReturn { get; private set; }

		public int PlayerSettingMetaCoinReward { get; private set; }

		public int PlayerSettingCashReward { get; private set; }

		public ItemInstanceData? PreservedCameraInstanceDataForHost { get; private set; }

		public (int cash, int mc)? PendingRewardForCameraReturn { get; private set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			HookAll();
			Logger.LogInfo((object)"humble.KeepCameraAfterDeath v1.0.1 is deprecated! This mod will do nothing");
		}

		internal static void HookAll()
		{
		}

		internal static void UnhookAll()
		{
			HookEndpointManager.RemoveAllOwnedBy((object)Assembly.GetExecutingAssembly());
		}

		public void SetPlayerSettingEnableRewardForCameraReturn(bool rewardEnabled)
		{
			PlayerSettingEnableRewardForCameraReturn = rewardEnabled;
		}

		public void SetPlayerSettingMetaCoinReward(int mcReward)
		{
			PlayerSettingMetaCoinReward = mcReward;
		}

		public void SetPlayerSettingCashReward(int cashReward)
		{
			PlayerSettingCashReward = cashReward;
		}

		public void SetPreservedCameraInstanceDataForHost(ItemInstanceData data)
		{
			if (MyceliumNetwork.IsHost)
			{
				PreservedCameraInstanceDataForHost = data;
			}
		}

		public void SetPendingRewardForAllPlayers()
		{
			if (MyceliumNetwork.IsHost)
			{
				MyceliumNetwork.RPC(61812u, "RPC_SetPendingRewardForCameraReturn", (ReliableType)1, new object[2] { PlayerSettingCashReward, PlayerSettingMetaCoinReward });
			}
		}

		[CustomRPC]
		public void RPC_SetPendingRewardForCameraReturn(int cash, int mc)
		{
			PendingRewardForCameraReturn = (cash, mc);
		}

		public void Command_ResetDataforDay()
		{
			if (MyceliumNetwork.IsHost)
			{
				MyceliumNetwork.RPC(61812u, "RPC_ResetDataforDay", (ReliableType)1, Array.Empty<object>());
			}
		}

		[CustomRPC]
		public void RPC_ResetDataforDay()
		{
			Instance.ClearData();
		}

		public void ClearData()
		{
			Instance.ClearPreservedCameraInstanceDataForHost();
			Instance.ClearPendingRewardForCameraReturn();
		}

		public void ClearPreservedCameraInstanceDataForHost()
		{
			if (MyceliumNetwork.IsHost)
			{
				PreservedCameraInstanceDataForHost = null;
			}
		}

		public void ClearPendingRewardForCameraReturn()
		{
			PendingRewardForCameraReturn = null;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "alexandria-p.KeepCameraAfterDeath";

		public const string PLUGIN_NAME = "KeepCameraAfterDeath";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace KeepCameraAfterDeath.Patches
{
	public class PersistentObjectsHolderPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_FindPersistantObjects <0>__PersistentObjectsHolder_FindPersistantObjects;
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__PersistentObjectsHolder_FindPersistantObjects;
			if (obj == null)
			{
				hook_FindPersistantObjects val = PersistentObjectsHolder_FindPersistantObjects;
				<>O.<0>__PersistentObjectsHolder_FindPersistantObjects = val;
				obj = (object)val;
			}
			PersistentObjectsHolder.FindPersistantObjects += (hook_FindPersistantObjects)obj;
		}

		private static void PersistentObjectsHolder_FindPersistantObjects(orig_FindPersistantObjects orig, PersistentObjectsHolder self)
		{
			//IL_0034: 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)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			List<VideoCamera> list = FindVideoCamerasInSet(self.m_PersistentObjects);
			orig.Invoke(self);
			if (!MyceliumNetwork.IsHost)
			{
				return;
			}
			int count = self.m_PersistentObjects.Count;
			VideoCamera item2 = default(VideoCamera);
			for (int num = count - 1; num >= 0; num--)
			{
				PersistentObjectInfo item = self.m_PersistentObjects[num];
				ItemInstanceData instanceData = ((PersistentObjectInfo)(ref item)).InstanceData;
				Guid guid = instanceData.m_guid;
				if (CameraHandler.TryGetCamera(guid, ref item2) && !list.Contains(item2))
				{
					KeepCameraAfterDeath.Instance.SetPreservedCameraInstanceDataForHost(instanceData);
					if (self.m_PersistentObjectDic.ContainsKey(((PersistentObjectInfo)(ref item)).Pickup))
					{
						self.m_PersistentObjectDic.Remove(((PersistentObjectInfo)(ref item)).Pickup);
					}
					self.m_PersistentObjects.Remove(item);
					break;
				}
			}
		}

		private static List<VideoCamera> FindVideoCamerasInSet(List<PersistentObjectInfo> persistantObjects)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			List<VideoCamera> list = new List<VideoCamera>();
			VideoCamera item = default(VideoCamera);
			foreach (PersistentObjectInfo persistantObject in persistantObjects)
			{
				PersistentObjectInfo current = persistantObject;
				ItemInstanceData instanceData = ((PersistentObjectInfo)(ref current)).InstanceData;
				Guid guid = instanceData.m_guid;
				if (CameraHandler.TryGetCamera(guid, ref item))
				{
					list.Add(item);
				}
			}
			return list;
		}
	}
	public class PlayerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Player_Update;
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__Player_Update;
			if (obj == null)
			{
				hook_Update val = Player_Update;
				<>O.<0>__Player_Update = val;
				obj = (object)val;
			}
			Player.Update += (hook_Update)obj;
		}

		private static void Player_Update(orig_Update orig, Player self)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			if (KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.HasValue && self.IsLocal && self.data.playerSetUpAndReady && SurfaceNetworkHandler.RoomStats != null && (int)TimeOfDayHandler.TimeOfDay == 10)
			{
				AddCashToRoom();
				AddMCToPlayers();
				KeepCameraAfterDeath.Instance.ClearPendingRewardForCameraReturn();
			}
			orig.Invoke(self);
			static void AddCashToRoom()
			{
				int item2 = KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.Value.cash;
				if (item2 > 0)
				{
					UserInterface.ShowMoneyNotification("Cash Received", $"${item2}", (MoneyCellType)1);
					if (MyceliumNetwork.IsHost)
					{
						SurfaceNetworkHandler.RoomStats.AddMoney(item2);
					}
				}
			}
			static void AddMCToPlayers()
			{
				int item = KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.Value.mc;
				if (item > 0)
				{
					MetaProgressionHandler.AddMetaCoins(item);
				}
			}
		}
	}
	public class SurfaceNetworkHandlerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_InitSurface <0>__SurfaceNetworkHandler_InitSurface;

			public static hook_NextDay <1>__SurfaceNetworkHandler_NextDay;
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: 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_003b: Expected O, but got Unknown
			object obj = <>O.<0>__SurfaceNetworkHandler_InitSurface;
			if (obj == null)
			{
				hook_InitSurface val = SurfaceNetworkHandler_InitSurface;
				<>O.<0>__SurfaceNetworkHandler_InitSurface = val;
				obj = (object)val;
			}
			SurfaceNetworkHandler.InitSurface += (hook_InitSurface)obj;
			object obj2 = <>O.<1>__SurfaceNetworkHandler_NextDay;
			if (obj2 == null)
			{
				hook_NextDay val2 = SurfaceNetworkHandler_NextDay;
				<>O.<1>__SurfaceNetworkHandler_NextDay = val2;
				obj2 = (object)val2;
			}
			SurfaceNetworkHandler.NextDay += (hook_NextDay)obj2;
		}

		private static void SurfaceNetworkHandler_InitSurface(orig_InitSurface orig, SurfaceNetworkHandler self)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			if (SurfaceNetworkHandler.RoomStats == null)
			{
				KeepCameraAfterDeath.Instance.ClearData();
			}
			if (MyceliumNetwork.IsHost && (int)TimeOfDayHandler.TimeOfDay == 10)
			{
				if (KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost != null)
				{
					self.m_VideoCameraSpawner.SpawnMe(true);
				}
				else if (KeepCameraAfterDeath.Instance.PlayerSettingEnableRewardForCameraReturn)
				{
					KeepCameraAfterDeath.Instance.SetPendingRewardForAllPlayers();
				}
			}
			orig.Invoke(self);
		}

		private static void SurfaceNetworkHandler_NextDay(orig_NextDay orig, SurfaceNetworkHandler self)
		{
			KeepCameraAfterDeath.Instance.Command_ResetDataforDay();
			orig.Invoke(self);
		}
	}
	public class VideoCameraPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_ConfigItem <0>__VideoCamera_ConfigItem;
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__VideoCamera_ConfigItem;
			if (obj == null)
			{
				hook_ConfigItem val = VideoCamera_ConfigItem;
				<>O.<0>__VideoCamera_ConfigItem = val;
				obj = (object)val;
			}
			VideoCamera.ConfigItem += (hook_ConfigItem)obj;
		}

		private static void VideoCamera_ConfigItem(orig_ConfigItem orig, VideoCamera self, ItemInstanceData data, PhotonView playerView)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			bool flag = (int)TimeOfDayHandler.TimeOfDay == 10;
			VideoInfoEntry val = default(VideoInfoEntry);
			bool flag2 = !data.TryGetEntry<VideoInfoEntry>(ref val) || val.videoID.id == Guid.Empty;
			bool flag3 = KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost != null;
			VideoInfoEntry val2 = default(VideoInfoEntry);
			if (MyceliumNetwork.IsHost && flag3 && flag && flag2 && KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost.TryGetEntry<VideoInfoEntry>(ref val2) && val2.videoID.id != Guid.Empty)
			{
				ManualLogSource logger = KeepCameraAfterDeath.Logger;
				Guid id = val2.videoID.id;
				logger.LogInfo((object)("KeepCameraAfterDeath: Restore camera footage: " + id));
				data.AddDataEntry((ItemDataEntry)(object)val2);
				KeepCameraAfterDeath.Instance.ClearPreservedCameraInstanceDataForHost();
			}
			orig.Invoke(self, data, playerView);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}