using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
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 HarmonyLib;
using ItemSpawnSync.Core;
using ItemSpawnSync.Data;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using Peak;
using Photon.Pun;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;

[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.flonou.Peak-ItemSpawnSync")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.9.4.0")]
[assembly: AssemblyInformationalVersion("0.9.4+029ec5c3f80bb7881d77c7348208025a66eb7575")]
[assembly: AssemblyProduct("com.github.flonou.Peak-ItemSpawnSync")]
[assembly: AssemblyTitle("ItemSpawnSync")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 ItemSpawnSync
{
	[BepInPlugin("com.github.flonou.Peak-ItemSpawnSync", "ItemSpawnSync", "0.9.4")]
	public class Plugin : BaseUnityPlugin
	{
		public bool EnableKeyTrigger = true;

		public ConfigEntry<bool>? DisableSpawningConfig;

		public ConfigEntry<string>? FileNameConfig;

		public ConfigEntry<KeyboardShortcut>? LoadDataKeyConfig;

		public ConfigEntry<KeyboardShortcut>? ExportLootDataKeyConfig;

		public ConfigEntry<KeyboardShortcut>? SaveDataKeyConfig;

		public ConfigEntry<bool>? SpawnIfNoDataFoundConfig;

		public ConfigEntry<KeyboardShortcut>? TriggerSpawnKeyConfig;

		public ConfigEntry<KeyboardShortcut>? ImportLootDataKeyConfig;

		private static string? dataDirectory;

		private Harmony? harmony;

		private static readonly JsonSerializerSettings jsonSettings = new JsonSerializerSettings
		{
			ReferenceLoopHandling = (ReferenceLoopHandling)1,
			Formatting = (Formatting)0,
			ContractResolver = (IContractResolver)(object)new ContractResolver()
		};

		public const string Id = "com.github.flonou.Peak-ItemSpawnSync";

		public static Plugin? Instance { get; private set; }

		public bool IsSpawnDataLocked => SpawnerSyncManager.Instance.IsDataLocked;

		public KeyboardShortcut LoadDataKey => LoadDataKeyConfig.Value;

		public static ManualLogSource? Log { get; private set; }

		public KeyboardShortcut SaveDataKey => SaveDataKeyConfig.Value;

		public KeyboardShortcut TriggerSpawnKey => TriggerSpawnKeyConfig.Value;

		public KeyboardShortcut ExportLootDataKey => ExportLootDataKeyConfig.Value;

		public KeyboardShortcut ImportLootDataKey => ImportLootDataKeyConfig.Value;

		public static string DataDirectory => dataDirectory;

		public static string Name => "ItemSpawnSync";

		public static string Version => "0.9.4";

		public event Action<string>? OnSpawnDataSaved;

		public event Action<List<Spawner>>? OnSpawnersTriggered;

		public event Action<List<Spawner>>? OnSpawnDataSpawnedInLevel;

		public event Action<string>? OnSpawnDataLoaded;

		public string GetSpawnDataAsJson()
		{
			MapSpawnerData currentMapData = SpawnerSyncManager.Instance.CurrentMapData;
			return JsonConvert.SerializeObject((object)currentMapData);
		}

		public bool LoadSpawnDataInCurrentLevel(MapSpawnerData data, bool lockData = false)
		{
			bool flag = SpawnerSyncManager.Instance.LoadMapSpawnerDataInCurrentLevel(data, lockData);
			if (flag)
			{
				Log.LogMessage((object)($"Loaded spawn data with {data.Spawners.Count} spawners" + (lockData ? " (LOCKED)" : "")));
			}
			if (SpawnerSyncManager.Instance.DisableSpawning)
			{
				SpawnerSyncManager.Instance.SpawnItemsFromStartSpawners();
			}
			return flag;
		}

		public MapSpawnerData? LoadSpawnDataFromFile(string filename)
		{
			try
			{
				string text = Path.Combine(dataDirectory, filename);
				if (!File.Exists(text))
				{
					Log.LogError((object)("Spawn data file not found: " + text));
					return null;
				}
				string text2 = File.ReadAllText(text);
				MapSpawnerData mapSpawnerData = JsonConvert.DeserializeObject<MapSpawnerData>(text2);
				if (mapSpawnerData != null)
				{
					Log.LogMessage((object)("Loaded spawn data from: " + text));
					Log.LogMessage((object)$"  Spawners: {mapSpawnerData.Spawners.Count}");
					Log.LogMessage((object)$"  Items: {CountTotalItems(mapSpawnerData)}");
				}
				else
				{
					Log.LogError((object)("Failed to deserialize spawn data from json " + text2));
				}
				this.OnSpawnDataLoaded?.Invoke(text);
				return mapSpawnerData;
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Failed to load spawn data: " + ex.Message));
				return null;
			}
		}

		public bool LoadSpawnDataFromJson(string json, bool lockData = false)
		{
			try
			{
				MapSpawnerData mapSpawnerData = JsonConvert.DeserializeObject<MapSpawnerData>(json);
				if (mapSpawnerData != null)
				{
					return true;
				}
				Log.LogError((object)("Could not deserialize spawn data from JSON: " + json));
				return false;
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Failed to load spawn data from JSON: " + ex.Message));
				return false;
			}
		}

		public void SaveCurrentSpawnData()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MapSpawnerData mapSpawnerData = SpawnerSyncManager.Instance?.CurrentMapData;
				if (mapSpawnerData == null || mapSpawnerData.Spawners.Count == 0)
				{
					Log.LogWarning((object)"No spawn data to save. Start capture first and trigger spawners.");
					return;
				}
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				string path = $"{name}_spawn_data_{DateTime.Now:yyyyMMdd_HHmmss}.json";
				string text = Path.Combine(dataDirectory, path);
				string contents = JsonConvert.SerializeObject((object)mapSpawnerData, (Formatting)1, jsonSettings);
				File.WriteAllText(text, contents);
				Log.LogMessage((object)("Saved spawn data to: " + text));
				Log.LogMessage((object)$"  Spawners: {mapSpawnerData.Spawners.Count}");
				Log.LogMessage((object)$"  Items: {CountTotalItems(mapSpawnerData)}");
				this.OnSpawnDataSaved?.Invoke(text);
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Failed to save spawn data: " + ex.Message));
			}
		}

		protected void Awake()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			TriggerSpawnKeyConfig = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Controls", "TriggerSpawnKey", new KeyboardShortcut((KeyCode)285, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Key to trigger all spawners");
			SaveDataKeyConfig = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Controls", "SaveDataKey", new KeyboardShortcut((KeyCode)286, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Key to save current spawn data to file");
			LoadDataKeyConfig = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Controls", "LoadDataKey", new KeyboardShortcut((KeyCode)287, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Key to load spawn data from file");
			ExportLootDataKeyConfig = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Controls", "ExportLootDataKey", new KeyboardShortcut((KeyCode)288, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Key to export loot data to file");
			ImportLootDataKeyConfig = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Controls", "ImportLootDataKey", new KeyboardShortcut((KeyCode)289, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Key to import loot data from file");
			DisableSpawningConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DisableSpawning", false, "If true, prevents any item spawning unless from loaded data");
			SpawnIfNoDataFoundConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "SpawnIfNoDataFound", false, "If true, spawners without loaded data will spawn normally");
			FileNameConfig = ((BaseUnityPlugin)this).Config.Bind<string>("General", "DefaultFileName", "spawn_data.json", "Default filename to load spawn data.");
			dataDirectory = Path.Combine(Paths.ConfigPath, "ItemSpawnSync");
			Directory.CreateDirectory(dataDirectory);
			SpawnerSyncManager.Instance.Initialize(Log);
			SpawnerSyncManager.Instance.EnableKeyTrigger = EnableKeyTrigger;
			SpawnerSyncManager.Instance.DisableSpawning = DisableSpawningConfig.Value;
			SpawnerSyncManager.Instance.SpawnIfNoDataFound = SpawnIfNoDataFoundConfig.Value;
			Log.LogMessage((object)("Plugin " + Name + " is loaded!"));
			Log.LogMessage((object)("Data directory: " + dataDirectory));
			harmony = new Harmony(Name);
			harmony.PatchAll();
			Log.LogMessage((object)"Harmony patches applied");
			Log.LogMessage((object)"Controls:");
			Log.LogMessage((object)$"  {TriggerSpawnKey} - Trigger all spawners");
			Log.LogMessage((object)$"  {SaveDataKey} - Save spawn data to file");
			Log.LogMessage((object)$"  {LoadDataKey} - Load spawn data from file");
			Log.LogMessage((object)$"  {ExportLootDataKey} - Export loot data to file");
			Log.LogMessage((object)$"  {ImportLootDataKey} - Import loot data from file");
			SceneManager.sceneUnloaded += OnSceneUnloaded;
		}

		protected void OnSceneUnloaded(Scene arg0)
		{
			if (((Scene)(ref arg0)).name.StartsWith("Level_"))
			{
				SpawnerSyncManager.Instance.ClearSpawnedData(((Scene)(ref arg0)).name);
			}
		}

		protected void Update()
		{
			//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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0036: 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)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut val = TriggerSpawnKey;
			if (((KeyboardShortcut)(ref val)).IsDown())
			{
				SpawnerSyncManager.Instance.CaptureSpawns();
			}
			val = SaveDataKey;
			if (((KeyboardShortcut)(ref val)).IsDown())
			{
				SaveCurrentSpawnData();
			}
			val = LoadDataKey;
			if (((KeyboardShortcut)(ref val)).IsDown())
			{
				MapSpawnerData mapSpawnerData = LoadSpawnDataFromFile(FileNameConfig.Value);
				if (mapSpawnerData != null)
				{
					LoadSpawnDataInCurrentLevel(mapSpawnerData);
				}
			}
			val = ExportLootDataKey;
			if (((KeyboardShortcut)(ref val)).IsDown())
			{
				LootDataContainer.ExportLootData();
			}
			val = ImportLootDataKey;
			if (((KeyboardShortcut)(ref val)).IsDown())
			{
				LootDataContainer.ImportLootData();
			}
		}

		private int CountTotalItems(MapSpawnerData data)
		{
			int num = 0;
			foreach (SpawnerInstanceData spawner in data.Spawners)
			{
				num += spawner.SpawnedItems.Count;
			}
			return num;
		}

		private void OnDestroy()
		{
			Harmony? obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}

		public void PublishSpawnersTriggered(List<Spawner> spawners)
		{
			this.OnSpawnersTriggered?.Invoke(spawners);
		}

		public void PublishSpawnDataSpawnedInLevel(List<Spawner> spawners)
		{
			this.OnSpawnDataSpawnedInLevel?.Invoke(spawners);
		}
	}
}
namespace ItemSpawnSync.Patches
{
	[HarmonyPatch(typeof(SpawnedItemTracker), "SpawnAndTrackFromItemHistory")]
	public class SpawnedItemTrackerPatch
	{
		private static bool Prefix(SpawnedItemTracker __instance, ref List<PhotonView> __result, ref List<SpawnRecord> ____historyFromSave)
		{
			if (____historyFromSave == null)
			{
				ManualLogSource? log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)(((Object)__instance).name + ": _historyFromSave is null, initializing empty list"));
				}
				____historyFromSave = new List<SpawnRecord>();
				__result = new List<PhotonView>();
				return true;
			}
			return true;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class SpawnedItemTrackerHasSpawnHistoryPatch
	{
		private static bool Prefix(SpawnedItemTracker __instance, ref bool __result)
		{
			SpawnerSyncManager instance = SpawnerSyncManager.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (instance.UseLoadedSpawnData)
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	public class SpawnerSpawnItemsPatch
	{
		public static event Action<List<PhotonView>>? OnItemsSpawned;

		private static IEnumerable<MethodBase> TargetMethods()
		{
			List<Type> list = new List<Type>();
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					IEnumerable<Type> collection = from t in assembly.GetTypes()
						where t.IsClass && !t.IsAbstract && typeof(Spawner).IsAssignableFrom(t)
						select t;
					list.AddRange(collection);
				}
				catch
				{
				}
			}
			foreach (Type item in list)
			{
				MethodInfo method = item.GetMethod("SpawnItems", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(List<Transform>) }, null);
				if (method != null)
				{
					yield return method;
				}
			}
		}

		private static bool Prefix(Spawner __instance, List<Transform> spawnSpots, ref List<PhotonView> __result)
		{
			SpawnerSyncManager instance = SpawnerSyncManager.Instance;
			SpawnedItemTracker val = default(SpawnedItemTracker);
			if (!((Component)__instance).TryGetComponent<SpawnedItemTracker>(ref val))
			{
				val = ((Component)__instance).gameObject.AddComponent<SpawnedItemTracker>();
				val.Init();
			}
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (instance.UseLoadedSpawnData)
			{
				if (instance.HasSpawnerData(__instance))
				{
					SpawnerInstanceData spawnerData = instance.GetSpawnerData(__instance);
					if (spawnerData == null)
					{
						__result = new List<PhotonView>();
						return instance.SpawnIfNoDataFound;
					}
					__result = instance.SpawnItemsFromData(__instance, spawnerData);
					SpawnerSpawnItemsPatch.OnItemsSpawned?.Invoke(__result);
					return false;
				}
				__result = new List<PhotonView>();
				return instance.SpawnIfNoDataFound;
			}
			__result = new List<PhotonView>();
			if (instance.DisableSpawning)
			{
				return instance.CapturingSpawn;
			}
			return true;
		}
	}
}
namespace ItemSpawnSync.Data
{
	public class ContractResolver : DefaultContractResolver
	{
		protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			JsonProperty val = ((DefaultContractResolver)this).CreateProperty(member, memberSerialization);
			val.Writable = true;
			val.Readable = true;
			return val;
		}

		protected override List<MemberInfo> GetSerializableMembers(Type objectType)
		{
			if (objectType.Name.Contains("AnonymousType"))
			{
				return objectType.GetProperties(BindingFlags.Instance | BindingFlags.Public).Cast<MemberInfo>().ToList();
			}
			return (from f in objectType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where f.IsPublic || ((MemberInfo)f).GetCustomAttribute<SerializeField>() != null
				select f).Cast<MemberInfo>().ToList();
		}
	}
	public class LootDataContainer
	{
		protected static string LootDataFileName = "LootData.json";

		public static Dictionary<string, Dictionary<string, int>> SpawnData = new Dictionary<string, Dictionary<string, int>>();

		public static void ImportLootData()
		{
			string text = Path.Combine(Plugin.DataDirectory, LootDataFileName);
			if (!File.Exists(text))
			{
				ManualLogSource? log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("Loot data file not found at " + text));
				}
				return;
			}
			string text2 = File.ReadAllText(text);
			SpawnData = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, int>>>(text2) ?? new Dictionary<string, Dictionary<string, int>>();
			ManualLogSource? log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogMessage((object)("Loot data imported from " + text));
			}
			ApplyLootData();
		}

		public static void ExportLootData()
		{
			ExtractLootData();
			string contents = JsonConvert.SerializeObject((object)SpawnData, (Formatting)1);
			string text = Path.Combine(Plugin.DataDirectory, LootDataFileName);
			File.WriteAllText(text, contents);
			ManualLogSource? log = Plugin.Log;
			if (log != null)
			{
				log.LogMessage((object)("Loot data exported to " + text));
			}
		}

		private unsafe static void ApplyLootData()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			if (LootData.AllSpawnWeightData == null)
			{
				LootData.PopulateLootData();
			}
			if (LootData.AllSpawnWeightData == null)
			{
				ManualLogSource? log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)"No loot data found to export.");
				}
				return;
			}
			Item val = default(Item);
			foreach (KeyValuePair<string, Dictionary<string, int>> spawnDatum in SpawnData)
			{
				string key = spawnDatum.Key;
				foreach (SpawnPool key2 in LootData.AllSpawnWeightData.Keys)
				{
					if (!(((object)(*(SpawnPool*)(&key2))/*cast due to .constrained prefix*/).ToString() == key))
					{
						continue;
					}
					foreach (KeyValuePair<string, int> item in spawnDatum.Value)
					{
						string itemName = item.Key;
						int value = item.Value;
						KeyValuePair<ushort, Item> keyValuePair = SingletonAsset<ItemDatabase>.Instance.itemLookup.FirstOrDefault((KeyValuePair<ushort, Item> kvp) => ItemDatabase.TryGetItem(kvp.Key, ref val) && ((Object)((Component)val).gameObject).name == itemName);
						if (LootData.AllSpawnWeightData[key2].ContainsKey(keyValuePair.Key))
						{
							LootData.AllSpawnWeightData[key2].Remove(keyValuePair.Key);
						}
						if (value > 0)
						{
							LootData.AllSpawnWeightData[key2].Add(keyValuePair.Key, value);
							continue;
						}
						ManualLogSource? log2 = Plugin.Log;
						if (log2 != null)
						{
							log2.LogInfo((object)("Skipping item " + itemName + " with zero spawn weight in pool " + key));
						}
					}
					break;
				}
			}
		}

		private static void ExtractLootData()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (LootData.AllSpawnWeightData == null)
			{
				LootData.PopulateLootData();
			}
			if (LootData.AllSpawnWeightData == null)
			{
				ManualLogSource? log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)"No loot data found to export.");
				}
				return;
			}
			Item val = default(Item);
			foreach (KeyValuePair<SpawnPool, Dictionary<ushort, int>> allSpawnWeightDatum in LootData.AllSpawnWeightData)
			{
				string key = ((object)allSpawnWeightDatum.Key/*cast due to .constrained prefix*/).ToString();
				Dictionary<string, int> dictionary = new Dictionary<string, int>();
				SpawnData.Add(key, dictionary);
				foreach (KeyValuePair<ushort, int> item in allSpawnWeightDatum.Value)
				{
					if (ItemDatabase.TryGetItem(item.Key, ref val))
					{
						LootData component = ((Component)val).GetComponent<LootData>();
						int value = item.Value;
						dictionary.Add(((Object)((Component)val).gameObject).name, value);
					}
				}
			}
		}
	}
	[Serializable]
	public class SpawnedItemData
	{
		public string ItemPrefabName = string.Empty;

		public Vector3 Position;

		public Quaternion Rotation;

		public int ViewID;
	}
	[Serializable]
	public class SpawnerInstanceData
	{
		public string SpawnerTypeName = string.Empty;

		public int SpawnerInstanceID;

		public Vector3 SpawnerPosition;

		public List<SpawnedItemData> SpawnedItems = new List<SpawnedItemData>();
	}
	[Serializable]
	public class MapSpawnerData
	{
		public List<SpawnerInstanceData> Spawners = new List<SpawnerInstanceData>();
	}
}
namespace ItemSpawnSync.Core
{
	public class SpawnerSyncManager : MonoBehaviour
	{
		public bool DisableSpawning;

		public bool EnableKeyTrigger;

		public bool SpawnIfNoDataFound;

		protected MethodInfo ForceSyncForFramesMethod = typeof(Item).GetMethod("ForceSyncForFrames", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static SpawnerSyncManager? instance;

		private ManualLogSource? logger;

		private Dictionary<int, Spawner> spawnerRegistry = new Dictionary<int, Spawner>();

		private Dictionary<Spawner, SpawnerInstanceData> spawnerToDataMap = new Dictionary<Spawner, SpawnerInstanceData>();

		public bool CapturingSpawn { get; internal set; }

		public MapSpawnerData? CurrentMapData { get; private set; }

		public static SpawnerSyncManager Instance
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Expected O, but got Unknown
				if ((Object)(object)instance == (Object)null)
				{
					GameObject val = new GameObject("SpawnerSyncManager");
					instance = val.AddComponent<SpawnerSyncManager>();
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				return instance;
			}
		}

		public bool IsDataLocked { get; private set; }

		public bool UseLoadedSpawnData { get; private set; }

		public Dictionary<int, Item> OriginalIdToItemMap { get; private set; } = new Dictionary<int, Item>();

		public void CaptureSpawns()
		{
			CurrentMapData = new MapSpawnerData();
			TriggerAllSpawners();
		}

		public static List<Spawner> FindAllSpawnersInScene()
		{
			return Object.FindObjectsByType<Spawner>((FindObjectsInactive)1, (FindObjectsSortMode)0).ToList();
		}

		public SpawnerInstanceData? GetSpawnerData(Spawner spawner)
		{
			if (!spawnerToDataMap.TryGetValue(spawner, out SpawnerInstanceData value))
			{
				return null;
			}
			return value;
		}

		public bool HasSpawnerData(Spawner spawner)
		{
			return spawnerToDataMap.ContainsKey(spawner);
		}

		public void Initialize(ManualLogSource logger)
		{
			this.logger = logger;
		}

		public bool LoadMapSpawnerDataInCurrentLevel(MapSpawnerData data, bool lockData = false)
		{
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			if (IsDataLocked)
			{
				ManualLogSource? obj = logger;
				if (obj != null)
				{
					obj.LogWarning((object)"Spawn data is locked. Cannot load new data.");
				}
				return false;
			}
			CurrentMapData = data;
			spawnerRegistry.Clear();
			spawnerToDataMap.Clear();
			List<Spawner> list = FindAllSpawnersInScene();
			HashSet<SpawnerInstanceData> matchedData = new HashSet<SpawnerInstanceData>();
			ManualLogSource? obj2 = logger;
			if (obj2 != null)
			{
				obj2.LogMessage((object)$"Found {list.Count} spawners in scene, attempting to match with {data.Spawners.Count} data entries");
			}
			int num = 0;
			foreach (Spawner spawner in list)
			{
				if (!((Object)(object)((MonoBehaviourPun)spawner).photonView != (Object)null) || ((MonoBehaviourPun)spawner).photonView.ViewID < 0)
				{
					continue;
				}
				SpawnerInstanceData spawnerInstanceData = data.Spawners.FirstOrDefault((SpawnerInstanceData d) => d.SpawnerInstanceID == ((MonoBehaviourPun)spawner).photonView.ViewID && !matchedData.Contains(d));
				if (spawnerInstanceData != null)
				{
					spawnerToDataMap[spawner] = spawnerInstanceData;
					matchedData.Add(spawnerInstanceData);
					num++;
					ManualLogSource? obj3 = logger;
					if (obj3 != null)
					{
						obj3.LogInfo((object)$"Matched spawner {((Object)spawner).name} by ViewID {((MonoBehaviourPun)spawner).photonView.ViewID}");
					}
				}
			}
			int num2 = 0;
			List<Spawner> list2 = list.Where((Spawner s) => !spawnerToDataMap.ContainsKey(s)).ToList();
			List<SpawnerInstanceData> list3 = data.Spawners.Where((SpawnerInstanceData d) => !matchedData.Contains(d)).ToList();
			foreach (Spawner spawner2 in list2)
			{
				SpawnerInstanceData spawnerInstanceData2 = (from d in list3
					where d.SpawnerTypeName == ((object)spawner2).GetType().Name
					orderby Vector3.Distance(((Component)spawner2).transform.position, d.SpawnerPosition)
					select d).FirstOrDefault();
				if (spawnerInstanceData2 == null)
				{
					continue;
				}
				float num3 = Vector3.Distance(((Component)spawner2).transform.position, spawnerInstanceData2.SpawnerPosition);
				if (num3 < 0.01f)
				{
					spawnerToDataMap[spawner2] = spawnerInstanceData2;
					matchedData.Add(spawnerInstanceData2);
					list3.Remove(spawnerInstanceData2);
					num2++;
					ManualLogSource? obj4 = logger;
					if (obj4 != null)
					{
						obj4.LogInfo((object)$"Matched spawner {((Object)spawner2).name} at position {spawnerInstanceData2.SpawnerPosition} by proximity ({num3:F3}m)");
					}
				}
			}
			ManualLogSource? obj5 = logger;
			if (obj5 != null)
			{
				obj5.LogMessage((object)$"Matched {num} spawners by ViewID, {num2} by proximity. Total: {spawnerToDataMap.Count}/{data.Spawners.Count}");
			}
			UseLoadedSpawnData = true;
			if (lockData)
			{
				IsDataLocked = true;
				ManualLogSource? obj6 = logger;
				if (obj6 != null)
				{
					obj6.LogMessage((object)$"Started replaying spawner data with {data.Spawners.Count} spawners (LOCKED)");
				}
			}
			else
			{
				ManualLogSource? obj7 = logger;
				if (obj7 != null)
				{
					obj7.LogMessage((object)$"Started replaying spawner data with {data.Spawners.Count} spawners");
				}
			}
			return true;
		}

		public List<PhotonView> SpawnItemsFromData(Spawner spawner, SpawnerInstanceData data)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			List<PhotonView> list = new List<PhotonView>();
			try
			{
				foreach (SpawnedItemData spawnedItem in data.SpawnedItems)
				{
					if (OriginalIdToItemMap.ContainsKey(spawnedItem.ViewID))
					{
						ManualLogSource? obj = logger;
						if (obj != null)
						{
							obj.LogInfo((object)$"Skipping spawn of {spawnedItem.ItemPrefabName} (ViewID {spawnedItem.ViewID}) - already spawned");
						}
						continue;
					}
					Item component = PhotonNetwork.InstantiateItemRoom(spawnedItem.ItemPrefabName, spawnedItem.Position, spawnedItem.Rotation).GetComponent<Item>();
					PhotonView component2 = ((Component)component).GetComponent<PhotonView>();
					OriginalIdToItemMap[spawnedItem.ViewID] = component;
					list.Add(component2);
					ForceSyncForFramesMethod.Invoke(component, new object[1] { 10 });
					if ((Object)(object)component != (Object)null && spawner.isKinematic)
					{
						component2.RPC("SetKinematicRPC", (RpcTarget)3, new object[3]
						{
							true,
							((Component)component).transform.position,
							((Component)component).transform.rotation
						});
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource? obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogError((object)("Error spawning items from data for spawner " + ((Object)spawner).name + ": " + ex.Message));
				}
			}
			return list;
		}

		public void SpawnItemsFromStartSpawners()
		{
			List<Spawner> list = (from s in FindAllSpawnersInScene()
				where s.spawnOnStart
				select s).ToList();
			ManualLogSource? obj = logger;
			if (obj != null)
			{
				obj.LogMessage((object)$"Spawning items from {list.Count} start spawners...");
			}
			foreach (Spawner item in list)
			{
				try
				{
					item.baseSpawnChance = 1f;
					if (((Behaviour)item).enabled)
					{
						item.ForceSpawn();
					}
				}
				catch (Exception ex)
				{
					ManualLogSource? obj2 = logger;
					if (obj2 != null)
					{
						obj2.LogError((object)("Error spawning from start spawner " + ((Object)item).name + " of type " + ((object)item).GetType().Name + ": " + ex.Message + " \n " + ex.StackTrace));
					}
				}
			}
			Plugin.Instance?.PublishSpawnDataSpawnedInLevel(list);
		}

		public void TriggerAllSpawners()
		{
			List<Spawner> list = FindAllSpawnersInScene();
			ManualLogSource? obj = logger;
			if (obj != null)
			{
				obj.LogMessage((object)$"Triggering {list.Count} spawners...");
			}
			CapturingSpawn = true;
			int num = 0;
			foreach (Spawner item in list)
			{
				try
				{
					if (TriggerSpawner(item))
					{
						num++;
					}
				}
				catch (Exception ex)
				{
					if ((Object)(object)((MonoBehaviourPun)item).photonView != (Object)null)
					{
						ManualLogSource? obj2 = logger;
						if (obj2 != null)
						{
							obj2.LogError((object)$"Error triggering spawner {((Object)item).name} [{((MonoBehaviourPun)item).photonView.ViewID}] of type {((object)item).GetType().Name}: {ex.Message} \n {ex.StackTrace}");
						}
						continue;
					}
					ManualLogSource? obj3 = logger;
					if (obj3 != null)
					{
						obj3.LogError((object)("Error triggering spawner " + ((Object)item).name + " of type " + ((object)item).GetType().Name + ": " + ex.Message + " \n " + ex.StackTrace));
					}
				}
			}
			CapturingSpawn = false;
			ManualLogSource? obj4 = logger;
			if (obj4 != null)
			{
				obj4.LogMessage((object)$"Triggered {num} spawners out of {list.Count} successfully");
			}
			Plugin.Instance?.PublishSpawnersTriggered(list);
		}

		private void SaveSpawnerData(Spawner spawner, List<PhotonView> spawnedObjects)
		{
			//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)
			Type type = ((object)spawner).GetType();
			SpawnerInstanceData spawnerInstanceData = new SpawnerInstanceData
			{
				SpawnerTypeName = type.Name,
				SpawnerPosition = ((Component)spawner).transform.position,
				SpawnerInstanceID = (((Object)(object)((MonoBehaviourPun)spawner).photonView != (Object)null) ? ((MonoBehaviourPun)spawner).photonView.ViewID : (-1)),
				SpawnedItems = spawnedObjects.Select(delegate(PhotonView obj)
				{
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					//IL_003e: 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)
					string text = ((Object)obj).name;
					if (text.EndsWith("(Clone)"))
					{
						string text2 = text;
						text = text2.Substring(0, text2.Length - 7);
					}
					return new SpawnedItemData
					{
						ItemPrefabName = text,
						Position = ((Component)obj).transform.position,
						Rotation = ((Component)obj).transform.rotation,
						ViewID = obj.ViewID
					};
				}).ToList()
			};
			CurrentMapData.Spawners.Add(spawnerInstanceData);
			spawnerToDataMap[spawner] = spawnerInstanceData;
		}

		private bool TriggerSpawner(Spawner spawner)
		{
			SpawnedItemTracker val = default(SpawnedItemTracker);
			if (SpawnerExtensions.HasSpawnTracking((ISpawner)(object)spawner, ref val))
			{
				ManualLogSource? obj = logger;
				if (obj != null)
				{
					string name = ((Object)spawner).name;
					PhotonView photonView = ((MonoBehaviourPun)spawner).photonView;
					obj.LogInfo((object)$"Resetting spawn tracking for spawner {name} [{((photonView != null) ? new int?(photonView.ViewID) : ((int?)null))}]");
				}
				val.HasSpawnHistory = false;
			}
			if (spawner.spawnOnStart)
			{
				List<PhotonView> list = spawner.TrySpawnItems();
				if ((Object)(object)((MonoBehaviourPun)spawner).photonView != (Object)null)
				{
					ManualLogSource? obj2 = logger;
					if (obj2 != null)
					{
						obj2.LogInfo((object)$"Triggered spawnOnStart on spawner {((Object)spawner).name} [{((MonoBehaviourPun)spawner).photonView.ViewID}] and got {list.Count} items");
					}
				}
				else
				{
					ManualLogSource? obj3 = logger;
					if (obj3 != null)
					{
						obj3.LogInfo((object)$"Triggered spawnOnStart on spawner {((Object)spawner).name} and got {list.Count} items");
					}
				}
				SaveSpawnerData(spawner, list);
				return true;
			}
			Type type = ((object)spawner).GetType();
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;
			MethodInfo method = type.GetMethod("GetSpawnSpots", bindingAttr);
			if (method != null)
			{
				List<Transform> list2 = method.Invoke(spawner, null) as List<Transform>;
				List<PhotonView> list3 = spawner.SpawnItems(list2);
				if ((Object)(object)((MonoBehaviourPun)spawner).photonView != (Object)null)
				{
					ManualLogSource? obj4 = logger;
					if (obj4 != null)
					{
						obj4.LogInfo((object)$"Triggered {type.Name}.SpawnItems() on spawner {((Object)spawner).name} [{((MonoBehaviourPun)spawner).photonView.ViewID}] and got {list3.Count} items");
					}
				}
				else
				{
					ManualLogSource? obj5 = logger;
					if (obj5 != null)
					{
						obj5.LogInfo((object)$"Triggered {type.Name}.SpawnItems() on spawner {((Object)spawner).name} and got {list3.Count} items");
					}
				}
				SaveSpawnerData(spawner, list3);
				return true;
			}
			ManualLogSource? obj6 = logger;
			if (obj6 != null)
			{
				obj6.LogWarning((object)(type.Name + " spawner " + ((Object)spawner).name + " does not have expected spawn method GetSpawnSpots."));
			}
			return false;
		}

		public void ClearSpawnedData(string sceneName)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource? obj = logger;
			if (obj != null)
			{
				obj.LogMessage((object)("Clearing spawned data for scene " + sceneName + "..."));
			}
			if (string.IsNullOrEmpty(sceneName))
			{
				OriginalIdToItemMap.Clear();
				return;
			}
			int num = 0;
			foreach (KeyValuePair<int, Item> item in OriginalIdToItemMap.ToList())
			{
				Item value = item.Value;
				if (!((Object)(object)value == (Object)null))
				{
					Scene scene = ((Component)value).gameObject.scene;
					if (!(((Scene)(ref scene)).name == sceneName))
					{
						continue;
					}
				}
				OriginalIdToItemMap.Remove(item.Key);
				num++;
			}
			ManualLogSource? obj2 = logger;
			if (obj2 != null)
			{
				obj2.LogMessage((object)$"Cleared spawned data for scene {sceneName}: {num} items removed.");
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}