using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
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.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("Nozz")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2025 Nozz")]
[assembly: AssemblyFileVersion("1.0.1")]
[assembly: AssemblyInformationalVersion("1.0.0+46687e15bb7ca0b21b70c90a68f16d3d792c0dee")]
[assembly: AssemblyProduct("BagsForEveryone")]
[assembly: AssemblyTitle("BagsForEveryone")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BagsForEveryone
{
	[BepInPlugin("com.nozz.bagsforeveryone", "BagsForEveryone", "1.0.1")]
	public class BagsForEveryonePlugin : BaseUnityPlugin
	{
		private ConfigEntry<bool> _modEnabled;

		private HashSet<int> _playersWithBags = new HashSet<int>();

		private bool _gameStarted;

		private const int BAG_AMOUNT = 1;

		private const float SPAWN_DELAY = 2f;

		public static BagsForEveryonePlugin Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			_modEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ModEnabled", true, "Enable or disable automatic backpack spawning");
			Logger.LogInfo((object)"Plugin com.nozz.bagsforeveryone loaded successfully!");
			Logger.LogInfo((object)"Minimalist automatic backpack spawning system initialized");
		}

		private void Start()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
			((MonoBehaviour)this).StartCoroutine(MonitorGameState());
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			_gameStarted = false;
			_playersWithBags.Clear();
			Logger.LogInfo((object)("Scene changed to: " + ((Scene)(ref scene)).name + " - mod state reset"));
		}

		private IEnumerator MonitorGameState()
		{
			while (true)
			{
				if (!_modEnabled.Value)
				{
					yield return (object)new WaitForSeconds(1f);
					continue;
				}
				if (!IsInValidGameLevel())
				{
					yield return (object)new WaitForSeconds(1f);
					continue;
				}
				if (PhotonNetwork.IsConnected && PhotonNetwork.InRoom)
				{
					if (!_gameStarted)
					{
						_gameStarted = true;
						ManualLogSource logger = Logger;
						Scene activeScene = SceneManager.GetActiveScene();
						logger.LogInfo((object)("Game started in level: " + ((Scene)(ref activeScene)).name + " - spawning backpacks"));
						yield return (object)new WaitForSeconds(2f);
						SpawnBagsForAllPlayers();
					}
					else
					{
						CheckForNewPlayers();
					}
				}
				else if (_gameStarted)
				{
					_gameStarted = false;
					_playersWithBags.Clear();
					Logger.LogInfo((object)"Game session ended - resetting bag tracking");
				}
				yield return (object)new WaitForSeconds(1f);
			}
		}

		private bool IsInValidGameLevel()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (name.StartsWith("Level_") && int.TryParse(name.Substring(6), out var result))
			{
				if (result >= 0)
				{
					return result <= 13;
				}
				return false;
			}
			return false;
		}

		private void CheckForNewPlayers()
		{
			Player[] playerList = PhotonNetwork.PlayerList;
			foreach (Player val in playerList)
			{
				if (!_playersWithBags.Contains(val.ActorNumber))
				{
					Logger.LogInfo((object)("New player detected: " + val.NickName + " - spawning backpack"));
					((MonoBehaviour)this).StartCoroutine(SpawnBagsForPlayer(val));
				}
			}
		}

		private void SpawnBagsForAllPlayers()
		{
			if (!PhotonNetwork.IsConnected || !PhotonNetwork.IsMasterClient)
			{
				return;
			}
			Logger.LogInfo((object)"Automatically spawning backpacks for all players...");
			Player[] playerList = PhotonNetwork.PlayerList;
			foreach (Player val in playerList)
			{
				if (!_playersWithBags.Contains(val.ActorNumber))
				{
					((MonoBehaviour)this).StartCoroutine(SpawnBagsForPlayer(val));
				}
			}
		}

		private IEnumerator SpawnBagsForPlayer(Player player)
		{
			SpawnBagForPlayer(player);
			yield return (object)new WaitForSeconds(0.1f);
			_playersWithBags.Add(player.ActorNumber);
		}

		private void SpawnBagForPlayer(Player player)
		{
			try
			{
				Character playerCharacter = GetPlayerCharacter(player);
				if ((Object)(object)playerCharacter == (Object)null)
				{
					return;
				}
				Player playerComponent = GetPlayerComponent(player);
				if (!((Object)(object)playerComponent == (Object)null))
				{
					if (playerComponent.backpackSlot.hasBackpack)
					{
						Logger.LogInfo((object)("Player " + player.NickName + " already has a backpack, skipping"));
						return;
					}
					if (TryGiveBackpackToPlayer(playerComponent))
					{
						Logger.LogInfo((object)("Backpack given to player: " + player.NickName));
						return;
					}
					SpawnBackpackNearPlayer(playerCharacter);
					Logger.LogInfo((object)("Backpack spawned near player: " + player.NickName));
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error spawning backpack for " + player.NickName + ": " + ex.Message));
			}
		}

		private Character GetPlayerCharacter(Player player)
		{
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if ((Object)(object)allCharacter != (Object)null && ((MonoBehaviourPun)allCharacter).photonView.Owner == player)
				{
					return allCharacter;
				}
			}
			return null;
		}

		private Player GetPlayerComponent(Player photonPlayer)
		{
			Player[] array = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
			foreach (Player val in array)
			{
				if (((MonoBehaviourPun)val).photonView.Owner == photonPlayer)
				{
					return val;
				}
			}
			return null;
		}

		private bool TryGiveBackpackToPlayer(Player player)
		{
			try
			{
				ushort num = FindBackpackItemID();
				if (num == 0)
				{
					return false;
				}
				ItemSlot val = default(ItemSlot);
				return player.AddItem(num, (ItemInstanceData)null, ref val) && val is BackpackSlot;
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error giving backpack to player: " + ex.Message));
				return false;
			}
		}

		private ushort FindBackpackItemID()
		{
			try
			{
				ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
				if (instance?.itemLookup != null)
				{
					foreach (KeyValuePair<ushort, Item> item in instance.itemLookup)
					{
						if (item.Value is Backpack)
						{
							return item.Key;
						}
					}
				}
				Backpack[] array = Object.FindObjectsByType<Backpack>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				if (array.Length != 0)
				{
					return ((Item)array[0]).itemID;
				}
				return 0;
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error finding backpack item ID: " + ex.Message));
				return 0;
			}
		}

		private void SpawnBackpackNearPlayer(Character character)
		{
			//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_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_001a: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 val = character.Center + Vector3.up * 1f + Random.insideUnitSphere * 1.5f;
				val.y = Mathf.Max(val.y, character.Center.y);
				string text = FindBackpackPrefabName();
				if (!string.IsNullOrEmpty(text))
				{
					PhotonNetwork.InstantiateItemRoom(text, val, Quaternion.identity);
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error spawning backpack near player: " + ex.Message));
			}
		}

		private string FindBackpackPrefabName()
		{
			try
			{
				ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
				if (instance?.itemLookup != null)
				{
					foreach (KeyValuePair<ushort, Item> item in instance.itemLookup)
					{
						if (item.Value is Backpack)
						{
							return ((Object)((Component)item.Value).gameObject).name;
						}
					}
				}
				Backpack[] array = Object.FindObjectsByType<Backpack>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				if (array.Length != 0)
				{
					return ((Object)((Component)array[0]).gameObject).name;
				}
				return null;
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Error finding backpack prefab name: " + ex.Message));
				return null;
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			_playersWithBags.Clear();
		}
	}
	[GeneratedCode("BepInEx.PluginInfoProps", "1.0.0.0")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	internal static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.nozz.bagsforeveryone";

		public const string PLUGIN_NAME = "BagsForEveryone";

		public const string PLUGIN_VERSION = "1.0.1";
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "com.nozz.bagsforeveryone";

		public const string PLUGIN_NAME = "BagsForEveryone";

		public const string PLUGIN_VERSION = "1.0.1";
	}
}