using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using NuageReport.Core.Model;
using NuageReport.Core.Recording;
using NuageReport.Core.Reporting;
using NuageReport.Plugin.Config;
using NuageReport.Plugin.Infrastructure;
using NuageReport.Plugin.Networking;
using NuageReport.Plugin.Patches;
using NuageReport.Plugin.Reports;
using NuageReport.Plugin.UI;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("TheoHay, GangDesNuages")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f7dcda716f6ccd2361b1be02417714f4cb5ee1f9")]
[assembly: AssemblyProduct("NuageReport.Plugin")]
[assembly: AssemblyTitle("NuageReport.Plugin")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/TheoHay/NuageREPO")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 NuageReport.Plugin
{
	[BepInPlugin("com.theohay.nuagereport", "NuageReport", "1.0.0")]
	public sealed class NuageReportPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <PollingLoop>d__52 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private float <resumeAt>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0056;
				}
				<>1__state = -1;
				LogVerbose("NuageReport polling coroutine started.");
				goto IL_0021;
				IL_0056:
				if (Time.unscaledTime < <resumeAt>5__2)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_0021;
				IL_0021:
				TickSurvivingSystems("Plugin.PollingLoop", forcePoll: true);
				<resumeAt>5__2 = Time.unscaledTime + 0.5f;
				goto IL_0056;
			}

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

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

		public const string PluginGuid = "com.theohay.nuagereport";

		public const string PluginName = "NuageReport";

		public const string PluginVersion = "1.0.0";

		private const float InitialReportCatchupDelaySeconds = 3f;

		private const float ReportCatchupIntervalSeconds = 2f;

		private Harmony? _harmony;

		private static bool _initialObjectBackfillDone;

		private static readonly PollingRecorder SharedPollingRecorder = new PollingRecorder();

		private static readonly ReportSnapshotFactory SnapshotFactory = new ReportSnapshotFactory();

		private static GameObject? _runnerObject;

		private static float _nextLiveReportSyncAt;

		private static float _nextReportCatchupRequestAt;

		private static string? _lastLiveReportRunId;

		private static int _lastLiveReportVersionPublished = -1;

		private bool _isQuitting;

		internal static ManualLogSource Log { get; private set; } = null;


		internal static RunRecorder Recorder { get; private set; } = null;


		internal static ReportExporter Exporter { get; private set; } = null;


		internal static ReportSyncService? ReportSync { get; private set; }

		internal static ReportUiController? ReportUi { get; private set; }

		internal static bool CanRecord => PatchSafety.Try("NuageReport Plugin.CanRecord", () => PluginConfig.Instance.EnableRecording != null && PluginConfig.Instance.IsModActive() && HostAuthority.IsAuthoritativeHost(), fallback: false);

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			PluginConfig.Instance.Bind(((BaseUnityPlugin)this).Config);
			PluginPaths.Initialize("NuageReport");
			Recorder = new RunRecorder((IClock)new SystemClock());
			Recorder.EventRecorded += LogRecordedEvent;
			Exporter = new ReportExporter();
			ReportSync = new ReportSyncService();
			ReportUi = new ReportUiController(ReportSync, CreateLiveReportSnapshot);
			ReportSync.FinalReportReceived += HandleFinalReportReceived;
			ReportSync.LiveReportReceived += HandleLiveReportReceived;
			ReportUi.Initialize();
			_harmony = new Harmony("com.theohay.nuagereport");
			WriteStartupMarker();
			InstallPatchFamilies();
			Log.LogInfo((object)("NuageReport 1.0.0 loaded. " + $"Recording={PluginConfig.Instance.EnableRecording.Value}, " + $"JsonOutput={PluginConfig.Instance.EnableJsonOutput.Value}, " + "RecordingAuthority=Host, " + $"LiveReport={PluginConfig.Instance.IsLiveReportEnabled()}, " + $"ShareReports={PluginConfig.Instance.ShouldShareReports()}, " + $"VerboseLogging={PluginConfig.Instance.ShouldLogVerbose()}, " + $"LogHookHits={PluginConfig.Instance.LogHookHits.Value}, " + $"LogRecordedEvents={PluginConfig.Instance.LogRecordedEvents.Value}, " + $"CartConfirmation={PluginConfig.Instance.CartConfirmationSeconds.Value:0.###}s, " + $"LiveReportSyncInterval={EffectiveLiveReportSyncIntervalSeconds():0.###}s, " + $"ReportMenuKeybind={PluginConfig.Instance.EffectiveReportMenuShortcut()}, " + "Reports path: " + PluginPaths.ReportsDirectory));
			CreatePollingRunner();
			((MonoBehaviour)this).StartCoroutine(PollingLoop());
			LogVerbose("Polling coroutine requested from Awake.");
		}

		private void CreatePollingRunner()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			try
			{
				if ((Object)(object)_runnerObject != (Object)null)
				{
					LogVerbose("NuageReport polling runner already exists.");
					return;
				}
				_runnerObject = new GameObject("NuageReport Polling Runner");
				_runnerObject.AddComponent<PollingRunner>();
				LogVerbose("NuageReport polling runner GameObject created.");
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Failed to create NuageReport polling runner: {arg}");
			}
		}

		private void OnEnable()
		{
			LogVerbose("NuageReport OnEnable reached.");
		}

		private void Start()
		{
			LogVerbose("NuageReport Start reached.");
		}

		private void InstallPatchFamilies()
		{
			if (_harmony == null)
			{
				return;
			}
			Type[] array = new Type[6]
			{
				typeof(RunLifecyclePatches),
				typeof(ValuableLifecyclePatches),
				typeof(CosmeticObjectLifecyclePatches),
				typeof(CartDetectionPatches),
				typeof(DamagePatches),
				typeof(InputManagerPatches)
			};
			int num = 0;
			Type[] array2 = array;
			foreach (Type type in array2)
			{
				string name = type.Name;
				try
				{
					int num2 = CountInstalledPatches();
					_harmony.PatchAll(type);
					int num3 = CountInstalledPatches();
					num++;
					Log.LogInfo((object)$"Installed patch family: {name} ({num3 - num2} patch methods, {num3} total owned patch methods).");
				}
				catch (Exception arg)
				{
					Log.LogError((object)$"Failed to install patch family '{name}'. Other patch families will still be attempted. {arg}");
				}
			}
			Log.LogInfo((object)$"Installed {num}/{array.Length} NuageReport patch families.");
		}

		private static void WriteStartupMarker()
		{
			try
			{
				Directory.CreateDirectory(PluginPaths.RootDirectory);
				File.WriteAllText(PluginPaths.StartupMarkerPath, string.Format("{0} {1} reached Awake at {2:O}.{3}", "NuageReport", "1.0.0", DateTimeOffset.UtcNow, Environment.NewLine) + $"JSON output enabled: {PluginConfig.Instance.EnableJsonOutput.Value}{Environment.NewLine}" + "Reports path: " + PluginPaths.ReportsDirectory + Environment.NewLine);
			}
			catch (Exception arg)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)$"Failed to write startup marker: {arg}");
				}
			}
		}

		private void OnDestroy()
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)$"NuageReport OnDestroy reached. isQuitting={_isQuitting}. Keeping patches/runner alive unless the app is quitting.");
			}
			if (!_isQuitting)
			{
				CreatePollingRunner();
				return;
			}
			try
			{
				RunRecorder recorder = Recorder;
				if (recorder != null && recorder.IsActive)
				{
					EndRunIfActive(null);
				}
				if (recorder != null)
				{
					recorder.EventRecorded -= LogRecordedEvent;
				}
				if (ReportSync != null)
				{
					ReportSync.FinalReportReceived -= HandleFinalReportReceived;
					ReportSync.LiveReportReceived -= HandleLiveReportReceived;
					ReportSync.Dispose();
				}
				if ((Object)(object)_runnerObject != (Object)null)
				{
					Object.Destroy((Object)(object)_runnerObject);
					_runnerObject = null;
				}
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)$"Failed to unpatch Harmony cleanly: {arg}");
				}
			}
		}

		private void OnApplicationQuit()
		{
			_isQuitting = true;
			LogVerbose("NuageReport OnApplicationQuit reached.");
		}

		private void Update()
		{
			TickSurvivingSystems("Plugin.Update");
		}

		private void OnGUI()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Event current = Event.current;
			if (PluginConfig.Instance.IsModActive() && current != null && (int)current.type == 4 && ReportUi != null && ReportUi.HandleKeyEvent(current.keyCode, "Plugin.OnGUI"))
			{
				current.Use();
			}
		}

		internal static void TickSurvivingSystems(string source, bool forcePoll = false)
		{
			PatchSafety.LogHookHit("NuageReport TickSurvivingSystems", source, 3);
			if (!PluginConfig.Instance.IsModActive())
			{
				ReportUi?.Deactivate();
				ReportSync?.Dispose();
				return;
			}
			ReportUi?.Tick(source);
			EnsureReportSyncSubscribedIfSafe();
			RequestReportCatchupIfDue();
			PublishLiveReportIfDue();
			SharedPollingRecorder.Tick(forcePoll);
		}

		private static void EnsureReportSyncSubscribedIfSafe()
		{
			if (ReportSync != null && PluginConfig.Instance.ShouldShareReports())
			{
				string levelName = RunLifecyclePatches.CurrentLevelName();
				if (RunLifecyclePatches.IsRecordableLevel(levelName))
				{
					ReportSync.EnsureSubscribed();
				}
			}
		}

		private static void PublishLiveReportIfDue()
		{
			if (ReportSync == null || !PluginConfig.Instance.ShouldShareLiveReport() || !Recorder.IsActive || !ReportSync.IsRoomReady || !CanRecord || !HostAuthority.IsAuthoritativeHost())
			{
				return;
			}
			float num = EffectiveLiveReportSyncIntervalSeconds();
			if (Time.unscaledTime < _nextLiveReportSyncAt)
			{
				return;
			}
			string activeRunId = Recorder.ActiveRunId;
			int eventVersion = Recorder.EventVersion;
			if (_lastLiveReportRunId == activeRunId && _lastLiveReportVersionPublished == eventVersion)
			{
				_nextLiveReportSyncAt = Time.unscaledTime + num;
				return;
			}
			_nextLiveReportSyncAt = Time.unscaledTime + num;
			ReportSnapshot reportSnapshot = CreateLiveReportSnapshot();
			if (reportSnapshot != null)
			{
				ReportSync.PublishLiveReport(reportSnapshot);
				_lastLiveReportRunId = activeRunId;
				_lastLiveReportVersionPublished = eventVersion;
			}
		}

		private static void RequestReportCatchupIfDue()
		{
			if (ReportSync == null || !PluginConfig.Instance.ShouldShareReports())
			{
				return;
			}
			string levelName = RunLifecyclePatches.CurrentLevelName();
			if (!RunLifecyclePatches.IsRecordableLevel(levelName) || !ReportSync.IsRoomReady || HostAuthority.IsAuthoritativeHost())
			{
				return;
			}
			bool flag = ReportSync.LatestFinalReport == null;
			bool flag2 = PluginConfig.Instance.IsLiveReportEnabled() && ReportSync.LatestLiveReport == null;
			if (flag || flag2)
			{
				if (_nextReportCatchupRequestAt <= 0f)
				{
					_nextReportCatchupRequestAt = Time.unscaledTime + 3f;
				}
				else if (!(Time.unscaledTime < _nextReportCatchupRequestAt))
				{
					_nextReportCatchupRequestAt = Time.unscaledTime + 2f;
					ReportSync.RequestLatestReport(flag, flag2);
				}
			}
		}

		private static float EffectiveLiveReportSyncIntervalSeconds()
		{
			return Mathf.Clamp(PluginConfig.Instance.LiveReportSyncIntervalSeconds.Value, 0.5f, 10f);
		}

		[IteratorStateMachine(typeof(<PollingLoop>d__52))]
		private IEnumerator PollingLoop()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PollingLoop>d__52(0);
		}

		private static void HandleFinalReportReceived(ReportSnapshot snapshot)
		{
			ReportUi?.SetLatestFinalReport(snapshot);
			Log.LogInfo((object)("Received NuageReport final report sync. runId=" + snapshot.RunId + " level=" + Quote(snapshot.LevelName ?? "unknown") + " modVersion=" + snapshot.ModVersion));
		}

		private static void HandleLiveReportReceived(ReportSnapshot snapshot)
		{
			ReportUi?.SetLatestLiveReport(snapshot);
		}

		private static ReportSnapshot? CreateLiveReportSnapshot()
		{
			return PatchSafety.Try("NuageReport Plugin.CreateLiveReportSnapshot", () => (!Recorder.IsActive) ? null : SnapshotFactory.CreateLiveReport(Recorder.Snapshot(), "1.0.0"), null);
		}

		internal static void StartRunIfNeeded(string? levelName)
		{
			if (CanRecord && !Recorder.IsActive)
			{
				if (!RunLifecyclePatches.IsRecordableLevel(levelName))
				{
					PatchSafety.LogHookHit("NuageReportPlugin.StartRunIfNeeded", "ignored non-run level=" + (levelName ?? "unknown"));
					return;
				}
				string text = DateTimeOffset.UtcNow.ToString("yyyyMMdd-HHmmssfff");
				_initialObjectBackfillDone = false;
				Recorder.StartRun(text, levelName);
				Log.LogInfo((object)("Run recording started. runId=" + text + " level=" + Quote(levelName ?? "unknown")));
			}
		}

		internal static bool EnsureRunActiveFromHook(string hookName)
		{
			if (!CanRecord)
			{
				PatchSafety.LogHookHit(hookName, "recording gate is closed");
				return false;
			}
			string text = RunLifecyclePatches.CurrentLevelName();
			if (!RunLifecyclePatches.IsRecordableLevel(text))
			{
				PatchSafety.LogHookHit(hookName, "ignored non-run level=" + (text ?? "unknown"));
				return false;
			}
			if (!Recorder.IsActive)
			{
				LogVerbose("No active run when " + hookName + " fired; starting a fallback run.");
				StartRunIfNeeded(text);
				BackfillInitialObjectsIfAvailable(hookName);
			}
			return Recorder.IsActive;
		}

		internal static void BackfillInitialObjectsIfAvailable(string source)
		{
			if (_initialObjectBackfillDone || !Recorder.IsActive)
			{
				return;
			}
			RoundDirector instance = RoundDirector.instance;
			if ((Object)(object)instance == (Object)null)
			{
				LogVerbose("Initial object backfill skipped from " + source + ": RoundDirector.instance is null.");
				return;
			}
			int num = 0;
			int num2 = 0;
			List<PhysGrabObject> list = GameAccess.Field<List<PhysGrabObject>>(instance, "physGrabObjects");
			if (list != null)
			{
				foreach (PhysGrabObject item in list)
				{
					if (ValuableLifecyclePatches.RecordPhysGrabObject(item))
					{
						num++;
					}
				}
			}
			List<CosmeticWorldObject> list2 = GameAccess.Field<List<CosmeticWorldObject>>(instance, "cosmeticWorldObjects");
			if (list2 != null)
			{
				foreach (CosmeticWorldObject item2 in list2)
				{
					if (CosmeticObjectLifecyclePatches.RecordCosmeticObjectExisting(item2))
					{
						num2++;
					}
				}
			}
			_initialObjectBackfillDone = true;
			LogVerbose($"Initial object backfill from {source}: valuables={num}, cosmeticObjects={num2}.");
		}

		internal static void EndRunIfActive(string? levelName)
		{
			if (!Recorder.IsActive)
			{
				return;
			}
			try
			{
				RunReport val = Recorder.EndRun(levelName);
				if (!ReportContainsRecordableLevel(val, levelName))
				{
					_initialObjectBackfillDone = false;
					Log.LogInfo((object)("Discarded non-run report. runId=" + val.RunId + " level=" + Quote(ReportLevelName(val, levelName) ?? "unknown") + "."));
				}
				else
				{
					string text = ExportJsonReportStatus(val);
					ReportSnapshot reportSnapshot = SnapshotFactory.CreateFinalReport(val, "1.0.0");
					ReportUi?.SetLatestFinalReport(reportSnapshot);
					ReportSync?.PublishFinalReport(reportSnapshot);
					_initialObjectBackfillDone = false;
					GlobalReportSummary global = val.Summary.Global;
					Log.LogInfo((object)(text + " " + $"Objects {global.ObjectsExtracted}/{global.ObjectsAtStart}, " + $"value ${global.ObjectsExtractedValue}/${global.ObjectsAtStartValue}, " + $"lost ${global.ObjectsValueLost}."));
				}
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Failed to end/export run report: {arg}");
			}
		}

		private static string ExportJsonReportStatus(RunReport report)
		{
			if (!PluginConfig.Instance.ShouldWriteJsonOutput())
			{
				return "Run report completed with JSON output disabled.";
			}
			try
			{
				string text = Exporter.Export(report);
				return "Run report exported: " + text + ".";
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Failed to export JSON run report: {arg}");
				return "Run report completed, but JSON export failed.";
			}
		}

		private static bool ReportContainsRecordableLevel(RunReport report, string? fallbackLevelName)
		{
			if (RunLifecyclePatches.IsRecordableLevel(fallbackLevelName))
			{
				return true;
			}
			foreach (RunEvent @event in report.Events)
			{
				if (RunLifecyclePatches.IsRecordableLevel(@event.LevelName))
				{
					return true;
				}
			}
			return false;
		}

		private static string? ReportLevelName(RunReport report, string? fallbackLevelName)
		{
			if (!string.IsNullOrWhiteSpace(fallbackLevelName))
			{
				return fallbackLevelName;
			}
			foreach (RunEvent @event in report.Events)
			{
				if (!string.IsNullOrWhiteSpace(@event.LevelName))
				{
					return @event.LevelName;
				}
			}
			return null;
		}

		private static void LogRecordedEvent(RunEvent runEvent)
		{
			RunEvent runEvent2 = runEvent;
			if (PluginConfig.Instance.LogRecordedEvents != null && !PluginConfig.Instance.LogRecordedEvents.Value)
			{
				return;
			}
			PatchSafety.Run("Recorder.EventRecordedLog", delegate
			{
				//IL_0017: 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)
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("Recorded ").Append(runEvent2.Type).Append(" [")
					.Append(runEvent2.Confidence)
					.Append(']');
				if (!string.IsNullOrWhiteSpace(runEvent2.LevelName))
				{
					stringBuilder.Append(" level=").Append(Quote(runEvent2.LevelName));
				}
				if (runEvent2.Valuable != null)
				{
					stringBuilder.Append(" valuable=").Append(Quote(runEvent2.Valuable.Name)).Append(" valuableId=")
						.Append(runEvent2.Valuable.RuntimeId);
					if (runEvent2.Valuable.ValueAtEvent.HasValue)
					{
						stringBuilder.Append(" value=$").Append(runEvent2.Valuable.ValueAtEvent.Value);
					}
					if (runEvent2.Valuable.WeightAtEvent.HasValue)
					{
						stringBuilder.Append(" weight=").Append(runEvent2.Valuable.WeightAtEvent.Value.ToString("0.###"));
					}
				}
				if (runEvent2.Player != null)
				{
					stringBuilder.Append(" player=").Append(Quote(runEvent2.Player.DisplayName)).Append(" playerId=")
						.Append(runEvent2.Player.Id);
				}
				if (runEvent2.DamageAmount.HasValue)
				{
					stringBuilder.Append(" damage=").Append(runEvent2.DamageAmount.Value);
				}
				if (runEvent2.DeltaValue.HasValue)
				{
					stringBuilder.Append(" deltaValue=").Append(runEvent2.DeltaValue.Value);
				}
				foreach (KeyValuePair<string, string> tag in runEvent2.Tags)
				{
					stringBuilder.Append(' ').Append(tag.Key).Append('=')
						.Append(Quote(tag.Value));
				}
				if (!string.IsNullOrWhiteSpace(runEvent2.Message))
				{
					stringBuilder.Append(" note=").Append(Quote(runEvent2.Message));
				}
				Log.LogInfo((object)stringBuilder.ToString());
			});
		}

		private static string Quote(string value)
		{
			return "\"" + value.Replace("\"", "'") + "\"";
		}

		internal static void LogVerbose(string message)
		{
			if (PluginConfig.Instance.ShouldLogVerbose())
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)message);
				}
			}
		}

		private static int CountInstalledPatches()
		{
			int num = 0;
			foreach (MethodBase allPatchedMethod in Harmony.GetAllPatchedMethods())
			{
				Patches patchInfo = Harmony.GetPatchInfo(allPatchedMethod);
				if (patchInfo != null)
				{
					num += CountOwnedPatches(patchInfo.Prefixes);
					num += CountOwnedPatches(patchInfo.Postfixes);
					num += CountOwnedPatches(patchInfo.Transpilers);
					num += CountOwnedPatches(patchInfo.Finalizers);
				}
			}
			return num;
		}

		private static int CountOwnedPatches(IEnumerable<Patch> patches)
		{
			int num = 0;
			foreach (Patch patch in patches)
			{
				if (patch.owner == "com.theohay.nuagereport")
				{
					num++;
				}
			}
			return num;
		}
	}
}
namespace NuageReport.Plugin.UI
{
	internal sealed class ReportOverlayPage : MonoBehaviour
	{
		private sealed class Metric
		{
			public string Label { get; }

			public string Value { get; }

			public string Detail { get; }

			public Metric(string label, string value, string detail)
			{
				Label = label;
				Value = value;
				Detail = detail;
			}
		}

		private sealed class ButtonVisual
		{
			public Button Button { get; }

			public Image Background { get; }

			public TextMeshProUGUI Label { get; }

			public ButtonVisual(Button button, Image background, TextMeshProUGUI label)
			{
				Button = button;
				Background = background;
				Label = label;
			}
		}

		private const float FallbackFontSize = 18f;

		private const float HeaderHeight = 64f;

		private const float FooterHeight = 42f;

		private const float StackSpacing = 12f;

		private RectTransform? _contentRect;

		private RectTransform? _viewportRect;

		private RectTransform? _scrollTrackRect;

		private RectTransform? _scrollThumbRect;

		private Image? _scrollTrackImage;

		private Image? _scrollThumbImage;

		private TextMeshProUGUI? _titleText;

		private TextMeshProUGUI? _footerText;

		private TextMeshProUGUI? _fallbackText;

		private LayoutElement? _fallbackLayout;

		private ButtonVisual? _summaryTab;

		private ButtonVisual? _liveTab;

		private Action<ReportUiTab>? _tabSelected;

		private Action? _closed;

		private bool _isClosing;

		private bool _layoutDirty;

		private float _scrollOffset;

		private float _maxScrollOffset;

		private CursorLockMode _previousCursorLockState;

		private bool _previousCursorVisible;

		private ReportUiTab _selectedTab;

		private bool _summaryEnabled;

		private bool _liveEnabled;

		public static ReportOverlayPage Create(ReportUiTab selectedTab, bool summaryEnabled, bool liveEnabled, ReportSnapshot? snapshot, string fallbackText, string footer, Action<ReportUiTab> tabSelected, Action closed)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("NuageReport Report Overlay");
			try
			{
				Object.DontDestroyOnLoad((Object)(object)val);
				Canvas val2 = val.AddComponent<Canvas>();
				val2.renderMode = (RenderMode)0;
				val2.sortingOrder = 6000;
				CanvasScaler val3 = val.AddComponent<CanvasScaler>();
				val3.uiScaleMode = (ScaleMode)1;
				val3.referenceResolution = new Vector2(1920f, 1080f);
				val3.matchWidthOrHeight = 0.5f;
				val.AddComponent<GraphicRaycaster>();
				CanvasGroup val4 = val.AddComponent<CanvasGroup>();
				val4.alpha = 1f;
				val4.interactable = true;
				val4.blocksRaycasts = true;
				ReportOverlayPage reportOverlayPage = val.AddComponent<ReportOverlayPage>();
				reportOverlayPage._tabSelected = tabSelected;
				reportOverlayPage._closed = closed;
				reportOverlayPage.CaptureCursorState();
				reportOverlayPage.Build(val.transform);
				reportOverlayPage.SetContent(selectedTab, summaryEnabled, liveEnabled, snapshot, fallbackText, footer);
				return reportOverlayPage;
			}
			catch
			{
				Object.Destroy((Object)(object)val);
				throw;
			}
		}

		public void SetContent(ReportUiTab selectedTab, bool summaryEnabled, bool liveEnabled, ReportSnapshot? snapshot, string fallbackText, string footer)
		{
			bool flag = _selectedTab != selectedTab;
			_selectedTab = selectedTab;
			_summaryEnabled = summaryEnabled;
			_liveEnabled = liveEnabled;
			_fallbackText = null;
			_fallbackLayout = null;
			if ((Object)(object)_titleText != (Object)null)
			{
				((TMP_Text)_titleText).text = "NuageReport";
			}
			if ((Object)(object)_footerText != (Object)null)
			{
				((TMP_Text)_footerText).text = footer;
			}
			ClearContent();
			if (snapshot != null && ReportUiData.TryParse(snapshot.JsonPayload, out ReportUiData data) && data != null)
			{
				BuildStructuredContent(snapshot, data);
			}
			else
			{
				BuildFallbackContent(string.IsNullOrWhiteSpace(fallbackText) ? "No report data." : fallbackText);
			}
			if (flag)
			{
				_scrollOffset = 0f;
			}
			UpdateTabVisuals();
			_layoutDirty = true;
		}

		public void Close()
		{
			if (!_isClosing)
			{
				_isClosing = true;
				_closed?.Invoke();
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void Build(Transform root)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_003a: 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_005e: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Expected O, but got Unknown
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Expected O, but got Unknown
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Expected O, but got Unknown
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Expected O, but got Unknown
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0559: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Expected O, but got Unknown
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_058d: Unknown result type (might be due to invalid IL or missing references)
			//IL_059c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0601: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_060b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_064e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_0682: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0712: Unknown result type (might be due to invalid IL or missing references)
			//IL_074c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0784: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreatePanel(root, "Background", Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.01f, 0.012f, 0.014f, 0.88f);
			GameObject val2 = CreatePanel(root, "Window", Vector2.zero, Vector2.one, new Vector2(64f, 54f), new Vector2(-64f, -54f));
			Image component = val2.GetComponent<Image>();
			((Graphic)component).color = new Color(0.035f, 0.043f, 0.048f, 0.96f);
			Outline val3 = val2.AddComponent<Outline>();
			((Shadow)val3).effectColor = new Color(0.23f, 0.34f, 0.37f, 0.62f);
			((Shadow)val3).effectDistance = new Vector2(1f, -1f);
			GameObject val4 = CreatePanel(val2.transform, "Top Bar", new Vector2(0f, 1f), Vector2.one, new Vector2(0f, -64f), Vector2.zero);
			((Graphic)val4.GetComponent<Image>()).color = new Color(0.055f, 0.067f, 0.072f, 0.98f);
			_titleText = CreateText(val4.transform, "Title", 22f, (TextAlignmentOptions)4097);
			RectTransform rectTransform = ((TMP_Text)_titleText).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0f);
			rectTransform.anchorMax = new Vector2(0f, 1f);
			rectTransform.pivot = new Vector2(0f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(24f, 0f);
			rectTransform.sizeDelta = new Vector2(250f, 0f);
			((TMP_Text)_titleText).fontStyle = (FontStyles)1;
			((Graphic)_titleText).color = new Color(0.93f, 0.98f, 1f, 1f);
			((TMP_Text)_titleText).enableWordWrapping = false;
			((TMP_Text)_titleText).overflowMode = (TextOverflowModes)1;
			_summaryTab = CreateButton(val4.transform, "Summary", new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(318f, 0f), new Vector2(126f, 38f), 16f);
			((UnityEvent)_summaryTab.Button.onClick).AddListener((UnityAction)delegate
			{
				_tabSelected?.Invoke(ReportUiTab.Summary);
			});
			_liveTab = CreateButton(val4.transform, "Live", new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(450f, 0f), new Vector2(104f, 38f), 16f);
			((UnityEvent)_liveTab.Button.onClick).AddListener((UnityAction)delegate
			{
				_tabSelected?.Invoke(ReportUiTab.Live);
			});
			ButtonVisual buttonVisual = CreateButton(val4.transform, "X", new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-38f, 0f), new Vector2(44f, 38f), 18f);
			((UnityEvent)buttonVisual.Button.onClick).AddListener(new UnityAction(Close));
			ApplyButtonStyle(buttonVisual, enabled: true, selected: false, compact: true);
			GameObject val5 = CreatePanel(val2.transform, "Content", Vector2.zero, Vector2.one, new Vector2(24f, 60f), new Vector2(-24f, -82f));
			((Graphic)val5.GetComponent<Image>()).color = new Color(0.018f, 0.023f, 0.026f, 0.92f);
			GameObject val6 = new GameObject("Viewport");
			val6.transform.SetParent(val5.transform, false);
			_viewportRect = val6.AddComponent<RectTransform>();
			_viewportRect.anchorMin = Vector2.zero;
			_viewportRect.anchorMax = Vector2.one;
			_viewportRect.offsetMin = new Vector2(22f, 16f);
			_viewportRect.offsetMax = new Vector2(-38f, -16f);
			val6.AddComponent<RectMask2D>();
			GameObject val7 = new GameObject("Content Stack");
			val7.transform.SetParent(val6.transform, false);
			_contentRect = val7.AddComponent<RectTransform>();
			_contentRect.anchorMin = new Vector2(0f, 1f);
			_contentRect.anchorMax = new Vector2(1f, 1f);
			_contentRect.pivot = new Vector2(0f, 1f);
			_contentRect.anchoredPosition = Vector2.zero;
			_contentRect.sizeDelta = new Vector2(0f, 800f);
			VerticalLayoutGroup val8 = val7.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val8).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val8).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val8).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val8).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val8).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val8).spacing = 12f;
			((LayoutGroup)val8).padding = new RectOffset(0, 0, 0, 0);
			GameObject val9 = CreatePanel(val5.transform, "Scroll Track", new Vector2(1f, 0f), Vector2.one, new Vector2(-17f, 18f), new Vector2(-12f, -18f));
			_scrollTrackRect = val9.GetComponent<RectTransform>();
			_scrollTrackImage = val9.GetComponent<Image>();
			((Graphic)_scrollTrackImage).color = new Color(0.16f, 0.21f, 0.23f, 0.55f);
			GameObject val10 = CreatePanel(val9.transform, "Scroll Thumb", new Vector2(0f, 1f), Vector2.one, Vector2.zero, Vector2.zero);
			_scrollThumbRect = val10.GetComponent<RectTransform>();
			_scrollThumbRect.anchorMin = new Vector2(0f, 1f);
			_scrollThumbRect.anchorMax = new Vector2(1f, 1f);
			_scrollThumbRect.pivot = new Vector2(0.5f, 1f);
			_scrollThumbRect.sizeDelta = new Vector2(0f, 80f);
			_scrollThumbImage = val10.GetComponent<Image>();
			((Graphic)_scrollThumbImage).color = new Color(0.45f, 0.72f, 0.74f, 0.9f);
			GameObject val11 = CreatePanel(val2.transform, "Footer", Vector2.zero, new Vector2(1f, 0f), Vector2.zero, new Vector2(0f, 42f));
			((Graphic)val11.GetComponent<Image>()).color = new Color(0.055f, 0.067f, 0.072f, 0.98f);
			_footerText = CreateText(val11.transform, "Footer Text", 13f, (TextAlignmentOptions)514);
			RectTransform rectTransform2 = ((TMP_Text)_footerText).rectTransform;
			rectTransform2.anchorMin = Vector2.zero;
			rectTransform2.anchorMax = Vector2.one;
			rectTransform2.offsetMin = new Vector2(24f, 0f);
			rectTransform2.offsetMax = new Vector2(-24f, 0f);
			((Graphic)_footerText).color = new Color(0.66f, 0.78f, 0.8f, 1f);
			((TMP_Text)_footerText).enableWordWrapping = false;
			((TMP_Text)_footerText).overflowMode = (TextOverflowModes)1;
		}

		private void BuildStructuredContent(ReportSnapshot snapshot, ReportUiData data)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_contentRect == (Object)null || data.global == null)
			{
				return;
			}
			ReportUiGlobal global = data.global;
			ReportUiPlayer[] array = data.players ?? Array.Empty<ReportUiPlayer>();
			ReportUiCosmeticObjects cosmeticObjects = data.cosmeticObjects;
			string title = ((snapshot.ReportKind == ReportKind.Live) ? "Live Report" : "Post Game Summary");
			string state = ((snapshot.ReportKind == ReportKind.Live) ? "In progress" : "Complete");
			CreateHero(title, state, snapshot.LevelName);
			GameObject val = CreateHorizontalGroup("KPI Row", 94f, 10f);
			AddStatTile(val.transform, "Extracted value", Money(global.objectsExtractedValue), CountDetail(global.objectsExtracted, "object"), new Color(0.22f, 0.64f, 0.42f, 1f));
			AddStatTile(val.transform, "Value lost", Money(global.objectsValueLost), CountDetail(global.objectsDestroyed, "destroyed"), new Color(0.74f, 0.28f, 0.25f, 1f));
			AddStatTile(val.transform, "Detected", Percent(global.objectsDetectedPercent), global.objectsDetected + " / " + global.objectsAtStart, new Color(0.33f, 0.56f, 0.86f, 1f));
			AddStatTile(val.transform, "Players hurt", Number(global.playerDamageTaken), "total damage", new Color(0.77f, 0.56f, 0.26f, 1f));
			CreateSectionTitle("Valuables");
			CreateMetricRows(new Metric("Map value", Money(global.objectsAtStartValue), CountDetail(global.objectsAtStart, "object")), new Metric("Extracted", Money(global.objectsExtractedValue), CountDetail(global.objectsExtracted, "object")), new Metric("Missed", Number(global.objectsMissed), "not detected"), new Metric("Damaged", Number(global.objectsDamaged), "valuable objects"), new Metric("Destroyed", Number(global.objectsDestroyed), Money(global.objectsValueLost) + " lost"), new Metric("Detection", Percent(global.objectsDetectedPercent), global.objectsDetected + " found"));
			CreateSectionTitle("Extras and Combat");
			CreateMetricRows(new Metric("Monster loot", Money(global.orbsExtractedValue), CountDetail(global.orbsCollected, "orb")), new Metric("Loot lost", Money(global.orbsLostValue), CountDetail(global.orbsDestroyed, "orb")), new Metric("Cosmetics found", Number(global.cosmeticObjectsFound), CountDetail(global.cosmeticObjectsExisting, "known")), new Metric("Monsters killed", Number(global.monstersKilled), Number(global.monsterDamageTaken) + " damage"), new Metric("Player damage", Number(global.playerDamageTaken), "taken by crew"));
			CreateSectionTitle("Players");
			if (array.Length == 0)
			{
				CreateEmptyState("No player-specific stats recorded yet.");
			}
			else
			{
				ReportUiPlayer[] array2 = array;
				foreach (ReportUiPlayer player in array2)
				{
					CreatePlayerRow(player);
				}
			}
			int num = cosmeticObjects?.existing?.Length ?? global.cosmeticObjectsExisting;
			int num2 = cosmeticObjects?.found?.Length ?? global.cosmeticObjectsFound;
			if (num > 0 || num2 > 0)
			{
				CreateSectionTitle("Cosmetic Objects");
				CreateMetricRows(new Metric("Existing", Number(num), "seen by recorder"), new Metric("Found", Number(num2), "extracted or found"));
			}
		}

		private void BuildFallbackContent(string text)
		{
			if ((Object)(object)_contentRect == (Object)null)
			{
				return;
			}
			string text2 = text.Replace("\r\n", "\n");
			CreateHero("Text Report", "Compatibility fallback", null);
			string[] array = text2.Split('\n');
			if (array.Length <= 1)
			{
				CreateEmptyState(text2);
				return;
			}
			string title = "Report";
			List<string> list = new List<string>();
			for (int i = 0; i < array.Length; i++)
			{
				string text3 = array[i].TrimEnd();
				if (IsLegacySectionHeader(array, i))
				{
					FlushFallbackSection(title, list);
					list.Clear();
					title = TitleCase(text3);
					i++;
				}
				else if (!string.IsNullOrWhiteSpace(text3))
				{
					list.Add(text3);
				}
			}
			FlushFallbackSection(title, list);
		}

		private void FlushFallbackSection(string title, List<string> lines)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			if (lines.Count == 0)
			{
				return;
			}
			CreateSectionTitle(title);
			GameObject val = CreateContentPanel(title + " Fallback Rows", Math.Max(54f, 16f + (float)lines.Count * 34f), new Color(0.03f, 0.04f, 0.045f, 0.95f));
			VerticalLayoutGroup val2 = val.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val2).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val2).spacing = 0f;
			((LayoutGroup)val2).padding = new RectOffset(14, 14, 8, 8);
			foreach (string line in lines)
			{
				AddFallbackLine(val.transform, line);
			}
		}

		private void AddFallbackLine(Transform parent, string line)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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)
			GameObject val = new GameObject("Fallback Row");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			LayoutElement val3 = val.AddComponent<LayoutElement>();
			val3.preferredHeight = 34f;
			val3.minHeight = 34f;
			int num = line.IndexOf(':');
			if (num <= 0)
			{
				TextMeshProUGUI val4 = CreateText(val.transform, "Text", 15f, (TextAlignmentOptions)4097);
				((TMP_Text)val4).rectTransform.offsetMin = Vector2.zero;
				((TMP_Text)val4).rectTransform.offsetMax = Vector2.zero;
				((TMP_Text)val4).text = line.Trim();
				((TMP_Text)val4).fontStyle = (FontStyles)((!line.StartsWith("  ", StringComparison.Ordinal)) ? 1 : 0);
				((Graphic)val4).color = new Color(0.86f, 0.94f, 0.95f, 1f);
				((TMP_Text)val4).enableWordWrapping = false;
				((TMP_Text)val4).overflowMode = (TextOverflowModes)1;
			}
			else
			{
				string text = line.Substring(0, num).Trim();
				string text2 = line.Substring(num + 1).Trim();
				TextMeshProUGUI val5 = CreateText(val.transform, "Label", 13f, (TextAlignmentOptions)4097);
				SetAnchors(((TMP_Text)val5).rectTransform, Vector2.zero, new Vector2(0.48f, 1f), Vector2.zero, new Vector2(-8f, 0f));
				((TMP_Text)val5).text = text;
				((Graphic)val5).color = new Color(0.62f, 0.72f, 0.74f, 1f);
				((TMP_Text)val5).enableWordWrapping = false;
				((TMP_Text)val5).overflowMode = (TextOverflowModes)1;
				TextMeshProUGUI val6 = CreateText(val.transform, "Value", 15f, (TextAlignmentOptions)4100);
				SetAnchors(((TMP_Text)val6).rectTransform, new Vector2(0.48f, 0f), Vector2.one, new Vector2(8f, 0f), Vector2.zero);
				((TMP_Text)val6).text = text2;
				((TMP_Text)val6).fontStyle = (FontStyles)1;
				((Graphic)val6).color = new Color(0.92f, 0.97f, 0.98f, 1f);
				((TMP_Text)val6).enableWordWrapping = false;
				((TMP_Text)val6).overflowMode = (TextOverflowModes)1;
			}
		}

		private static bool IsLegacySectionHeader(string[] lines, int index)
		{
			if (index + 1 >= lines.Length)
			{
				return false;
			}
			string text = lines[index].Trim();
			string text2 = lines[index + 1].Trim();
			if (text.Length > 0 && text.ToUpperInvariant() == text && text2.Length >= 8)
			{
				return text2.Trim('-').Length == 0;
			}
			return false;
		}

		private static string TitleCase(string value)
		{
			string str = value.ToLowerInvariant();
			return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(str);
		}

		private void CreateHero(string title, string state, string? levelName)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateContentPanel("Report Header", 64f, new Color(0.045f, 0.058f, 0.064f, 0.98f));
			TextMeshProUGUI val2 = CreateText(val.transform, "Report Title", 22f, (TextAlignmentOptions)4097);
			RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0f);
			rectTransform.anchorMax = new Vector2(0.55f, 1f);
			rectTransform.offsetMin = new Vector2(18f, 0f);
			rectTransform.offsetMax = new Vector2(-8f, 0f);
			((TMP_Text)val2).text = title;
			((TMP_Text)val2).fontStyle = (FontStyles)1;
			((Graphic)val2).color = new Color(0.95f, 0.99f, 1f, 1f);
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)1;
			TextMeshProUGUI val3 = CreateText(val.transform, "Report Meta", 15f, (TextAlignmentOptions)4100);
			RectTransform rectTransform2 = ((TMP_Text)val3).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.55f, 0f);
			rectTransform2.anchorMax = Vector2.one;
			rectTransform2.offsetMin = new Vector2(8f, 0f);
			rectTransform2.offsetMax = new Vector2(-18f, 0f);
			((TMP_Text)val3).text = (string.IsNullOrWhiteSpace(levelName) ? state : (state + " | " + levelName));
			((Graphic)val3).color = new Color(0.62f, 0.78f, 0.8f, 1f);
			((TMP_Text)val3).enableWordWrapping = false;
			((TMP_Text)val3).overflowMode = (TextOverflowModes)1;
		}

		private void CreateSectionTitle(string title)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateContentPanel(title + " Title", 30f, new Color(0f, 0f, 0f, 0f));
			Image component = val.GetComponent<Image>();
			((Behaviour)component).enabled = false;
			TextMeshProUGUI val2 = CreateText(val.transform, "Title", 16f, (TextAlignmentOptions)4097);
			((TMP_Text)val2).rectTransform.offsetMin = new Vector2(2f, 0f);
			((TMP_Text)val2).rectTransform.offsetMax = Vector2.zero;
			((TMP_Text)val2).text = title.ToUpperInvariant();
			((TMP_Text)val2).fontStyle = (FontStyles)1;
			((Graphic)val2).color = new Color(0.5f, 0.72f, 0.74f, 1f);
			((TMP_Text)val2).characterSpacing = 0f;
			((TMP_Text)val2).enableWordWrapping = false;
		}

		private GameObject CreateHorizontalGroup(string name, float height, float spacing)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateContentPanel(name, height, new Color(0f, 0f, 0f, 0f));
			((Behaviour)val.GetComponent<Image>()).enabled = false;
			HorizontalLayoutGroup val2 = val.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)val2).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)val2).spacing = spacing;
			return val;
		}

		private void AddStatTile(Transform parent, string label, string value, string detail, Color accent)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateChildPanel(parent, label + " Tile", new Color(0.03f, 0.04f, 0.045f, 0.98f));
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.flexibleWidth = 1f;
			val2.preferredHeight = 94f;
			GameObject val3 = CreatePanel(val.transform, "Accent", new Vector2(0f, 0f), new Vector2(0f, 1f), Vector2.zero, new Vector2(4f, 0f));
			((Graphic)val3.GetComponent<Image>()).color = accent;
			TextMeshProUGUI val4 = CreateText(val.transform, "Label", 13f, (TextAlignmentOptions)257);
			SetOffsets(((TMP_Text)val4).rectTransform, new Vector2(16f, 52f), new Vector2(-12f, -10f));
			((TMP_Text)val4).text = label;
			((Graphic)val4).color = new Color(0.62f, 0.72f, 0.74f, 1f);
			((TMP_Text)val4).enableWordWrapping = false;
			((TMP_Text)val4).overflowMode = (TextOverflowModes)1;
			TextMeshProUGUI val5 = CreateText(val.transform, "Value", 28f, (TextAlignmentOptions)4097);
			SetOffsets(((TMP_Text)val5).rectTransform, new Vector2(16f, 18f), new Vector2(-12f, -24f));
			((TMP_Text)val5).text = value;
			((TMP_Text)val5).fontStyle = (FontStyles)1;
			((Graphic)val5).color = new Color(0.95f, 0.99f, 1f, 1f);
			((TMP_Text)val5).enableWordWrapping = false;
			((TMP_Text)val5).overflowMode = (TextOverflowModes)1;
			TextMeshProUGUI val6 = CreateText(val.transform, "Detail", 12f, (TextAlignmentOptions)1025);
			SetOffsets(((TMP_Text)val6).rectTransform, new Vector2(16f, 6f), new Vector2(-12f, -62f));
			((TMP_Text)val6).text = detail;
			((Graphic)val6).color = new Color(0.55f, 0.64f, 0.66f, 1f);
			((TMP_Text)val6).enableWordWrapping = false;
			((TMP_Text)val6).overflowMode = (TextOverflowModes)1;
		}

		private void CreateMetricRows(params Metric[] metrics)
		{
			for (int i = 0; i < metrics.Length; i += 2)
			{
				GameObject val = CreateHorizontalGroup("Metric Row", 54f, 10f);
				AddMetricCell(val.transform, metrics[i]);
				if (i + 1 < metrics.Length)
				{
					AddMetricCell(val.transform, metrics[i + 1]);
				}
				else
				{
					AddMetricCell(val.transform, new Metric(string.Empty, string.Empty, string.Empty), visible: false);
				}
			}
		}

		private void AddMetricCell(Transform parent, Metric metric, bool visible = true)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateChildPanel(parent, "Metric", visible ? new Color(0.028f, 0.035f, 0.039f, 0.96f) : new Color(0f, 0f, 0f, 0f));
			((Behaviour)val.GetComponent<Image>()).enabled = visible;
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.flexibleWidth = 1f;
			val2.preferredHeight = 54f;
			if (visible)
			{
				TextMeshProUGUI val3 = CreateText(val.transform, "Label", 13f, (TextAlignmentOptions)4097);
				SetOffsets(((TMP_Text)val3).rectTransform, new Vector2(14f, 0f), new Vector2(-260f, 0f));
				((TMP_Text)val3).text = metric.Label;
				((Graphic)val3).color = new Color(0.64f, 0.74f, 0.76f, 1f);
				((TMP_Text)val3).enableWordWrapping = false;
				((TMP_Text)val3).overflowMode = (TextOverflowModes)1;
				TextMeshProUGUI val4 = CreateText(val.transform, "Value", 18f, (TextAlignmentOptions)4100);
				SetOffsets(((TMP_Text)val4).rectTransform, new Vector2(145f, 0f), new Vector2(-130f, 0f));
				((TMP_Text)val4).text = metric.Value;
				((TMP_Text)val4).fontStyle = (FontStyles)1;
				((Graphic)val4).color = new Color(0.93f, 0.97f, 0.98f, 1f);
				((TMP_Text)val4).enableWordWrapping = false;
				((TMP_Text)val4).overflowMode = (TextOverflowModes)1;
				TextMeshProUGUI val5 = CreateText(val.transform, "Detail", 12f, (TextAlignmentOptions)4100);
				SetOffsets(((TMP_Text)val5).rectTransform, new Vector2(270f, 0f), new Vector2(-14f, 0f));
				((TMP_Text)val5).text = metric.Detail;
				((Graphic)val5).color = new Color(0.5f, 0.6f, 0.62f, 1f);
				((TMP_Text)val5).enableWordWrapping = false;
				((TMP_Text)val5).overflowMode = (TextOverflowModes)1;
			}
		}

		private void CreatePlayerRow(ReportUiPlayer player)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			string text = (string.IsNullOrWhiteSpace(player.displayName) ? player.playerId : player.displayName);
			GameObject val = CreateContentPanel("Player Row", 82f, new Color(0.03f, 0.039f, 0.043f, 0.98f));
			TextMeshProUGUI val2 = CreateText(val.transform, "Name", 18f, (TextAlignmentOptions)4097);
			SetAnchors(((TMP_Text)val2).rectTransform, new Vector2(0f, 0f), new Vector2(0.28f, 1f), new Vector2(16f, 0f), new Vector2(-8f, 0f));
			((TMP_Text)val2).text = text;
			((TMP_Text)val2).fontStyle = (FontStyles)1;
			((Graphic)val2).color = new Color(0.95f, 0.99f, 1f, 1f);
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)1;
			AddPlayerStat(val.transform, new Vector2(0.3f, 0f), new Vector2(0.48f, 1f), "Cart/cashout", CountAndMoney(player.objectsPutInCartOrCashout, player.objectsPutInCartOrCashoutValue));
			AddPlayerStat(val.transform, new Vector2(0.5f, 0f), new Vector2(0.66f, 1f), "Extracted weight", Weight(player.extractedObjectWeight));
			AddPlayerStat(val.transform, new Vector2(0.68f, 0f), new Vector2(0.84f, 1f), "Detected", CountAndMoney(player.objectsDetected, player.objectsDetectedValue));
			AddPlayerStat(val.transform, new Vector2(0.86f, 0f), new Vector2(1f, 1f), "Damage taken", Number(player.damageTaken));
		}

		private void AddPlayerStat(Transform parent, Vector2 anchorMin, Vector2 anchorMax, string label, string value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0059: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(label);
			val.transform.SetParent(parent, false);
			RectTransform rect = val.AddComponent<RectTransform>();
			SetAnchors(rect, anchorMin, anchorMax, Vector2.zero, Vector2.zero);
			TextMeshProUGUI val2 = CreateText(val.transform, "Label", 11f, (TextAlignmentOptions)1025);
			SetAnchors(((TMP_Text)val2).rectTransform, new Vector2(0f, 0.5f), Vector2.one, new Vector2(0f, 0f), new Vector2(-8f, -8f));
			((TMP_Text)val2).text = label;
			((Graphic)val2).color = new Color(0.54f, 0.64f, 0.66f, 1f);
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)1;
			TextMeshProUGUI val3 = CreateText(val.transform, "Value", 17f, (TextAlignmentOptions)257);
			SetAnchors(((TMP_Text)val3).rectTransform, Vector2.zero, new Vector2(1f, 0.55f), new Vector2(0f, 8f), new Vector2(-8f, 0f));
			((TMP_Text)val3).text = value;
			((TMP_Text)val3).fontStyle = (FontStyles)1;
			((Graphic)val3).color = new Color(0.87f, 0.94f, 0.95f, 1f);
			((TMP_Text)val3).enableWordWrapping = false;
			((TMP_Text)val3).overflowMode = (TextOverflowModes)1;
		}

		private void CreateEmptyState(string text)
		{
			//IL_001f: 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)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateContentPanel("Empty State", 58f, new Color(0.028f, 0.035f, 0.039f, 0.96f));
			TextMeshProUGUI val2 = CreateText(val.transform, "Text", 15f, (TextAlignmentOptions)4097);
			((TMP_Text)val2).rectTransform.offsetMin = new Vector2(16f, 0f);
			((TMP_Text)val2).rectTransform.offsetMax = new Vector2(-16f, 0f);
			((TMP_Text)val2).text = text;
			((Graphic)val2).color = new Color(0.62f, 0.72f, 0.74f, 1f);
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)1;
		}

		private void LateUpdate()
		{
			KeepModalInputState();
			if (_layoutDirty)
			{
				RefreshContentHeight();
				_layoutDirty = false;
			}
		}

		private void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			KeepModalInputState();
			float y = Input.mouseScrollDelta.y;
			if (Mathf.Abs(y) > 0.01f)
			{
				_scrollOffset = Mathf.Clamp(_scrollOffset - y * 58f, 0f, _maxScrollOffset);
				ApplyScrollOffset();
			}
		}

		private void RefreshContentHeight()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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)
			if (!((Object)(object)_contentRect == (Object)null) && !((Object)(object)_viewportRect == (Object)null))
			{
				Canvas.ForceUpdateCanvases();
				Rect rect = _viewportRect.rect;
				float num = Mathf.Max(300f, ((Rect)(ref rect)).height);
				if ((Object)(object)_fallbackText != (Object)null && (Object)(object)_fallbackLayout != (Object)null)
				{
					rect = _viewportRect.rect;
					float num2 = Mathf.Max(300f, ((Rect)(ref rect)).width - 36f);
					Vector2 preferredValues = ((TMP_Text)_fallbackText).GetPreferredValues(((TMP_Text)_fallbackText).text, num2, 0f);
					_fallbackLayout.preferredHeight = Mathf.Max(num, preferredValues.y + 36f);
				}
				LayoutRebuilder.ForceRebuildLayoutImmediate(_contentRect);
				float num3 = Mathf.Max(num, LayoutUtility.GetPreferredHeight(_contentRect));
				_contentRect.sizeDelta = new Vector2(0f, num3);
				_maxScrollOffset = Mathf.Max(0f, num3 - num);
				_scrollOffset = Mathf.Clamp(_scrollOffset, 0f, _maxScrollOffset);
				ApplyScrollOffset();
			}
		}

		private void ApplyScrollOffset()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_contentRect == (Object)null))
			{
				_contentRect.anchoredPosition = new Vector2(0f, _scrollOffset);
				UpdateScrollThumb();
			}
		}

		private void UpdateScrollThumb()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_viewportRect == (Object)null) && !((Object)(object)_scrollTrackRect == (Object)null) && !((Object)(object)_scrollThumbRect == (Object)null) && !((Object)(object)_scrollTrackImage == (Object)null) && !((Object)(object)_scrollThumbImage == (Object)null))
			{
				bool flag = _maxScrollOffset > 1f;
				((Behaviour)_scrollTrackImage).enabled = flag;
				((Behaviour)_scrollThumbImage).enabled = flag;
				if (flag)
				{
					Rect rect = _scrollTrackRect.rect;
					float num = Mathf.Max(1f, ((Rect)(ref rect)).height);
					rect = _viewportRect.rect;
					float num2 = Mathf.Max(1f, ((Rect)(ref rect)).height);
					float num3 = num2 + _maxScrollOffset;
					float num4 = Mathf.Clamp(num * (num2 / num3), 42f, num);
					float num5 = Mathf.Max(0f, num - num4);
					float num6 = _scrollOffset / _maxScrollOffset;
					_scrollThumbRect.sizeDelta = new Vector2(0f, num4);
					_scrollThumbRect.anchoredPosition = new Vector2(0f, (0f - num6) * num5);
				}
			}
		}

		private void UpdateTabVisuals()
		{
			if (_summaryTab != null)
			{
				ApplyButtonStyle(_summaryTab, _summaryEnabled, _selectedTab == ReportUiTab.Summary, compact: false);
			}
			if (_liveTab != null)
			{
				ApplyButtonStyle(_liveTab, _liveEnabled, _selectedTab == ReportUiTab.Live, compact: false);
			}
		}

		private void ClearContent()
		{
			if (!((Object)(object)_contentRect == (Object)null))
			{
				for (int num = ((Transform)_contentRect).childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)((Transform)_contentRect).GetChild(num)).gameObject);
				}
			}
		}

		private void OnDestroy()
		{
			RestoreCursorState();
			if (!_isClosing)
			{
				_isClosing = true;
				_closed?.Invoke();
			}
		}

		private void CaptureCursorState()
		{
			//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)
			_previousCursorLockState = Cursor.lockState;
			_previousCursorVisible = Cursor.visible;
			KeepModalInputState();
		}

		private void KeepModalInputState()
		{
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			InputManager instance = InputManager.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				GameAccess.SetFloatFieldAtLeast(instance, "disableAimingTimer", 0.25f);
				GameAccess.SetFloatFieldAtLeast(instance, "disableMovementTimer", 0.25f);
			}
		}

		private void RestoreCursorState()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Cursor.lockState = _previousCursorLockState;
			Cursor.visible = _previousCursorVisible;
		}

		private GameObject CreateContentPanel(string name, float height, Color color)
		{
			//IL_0020: 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)
			if ((Object)(object)_contentRect == (Object)null)
			{
				throw new InvalidOperationException("Content root has not been built.");
			}
			GameObject val = CreateChildPanel((Transform)(object)_contentRect, name, color);
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(0f, height);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.preferredHeight = height;
			val2.minHeight = height;
			val2.flexibleWidth = 1f;
			return val;
		}

		private static GameObject CreatePanel(Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			val2.offsetMin = offsetMin;
			val2.offsetMax = offsetMax;
			val.AddComponent<Image>();
			return val;
		}

		private static GameObject CreateChildPanel(Transform parent, string name, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = color;
			return val;
		}

		private static TextMeshProUGUI CreateText(Transform parent, string name, float fontSize, TextAlignmentOptions alignment)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val3).text = string.Empty;
			((TMP_Text)val3).fontSize = fontSize;
			((TMP_Text)val3).alignment = alignment;
			((TMP_Text)val3).richText = false;
			return val3;
		}

		private static ButtonVisual CreateButton(Transform parent, string label, Vector2 anchorMin, Vector2 anchorMax, Vector2 anchoredPosition, Vector2 size, float fontSize)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(label + " Button");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = anchoredPosition;
			val2.sizeDelta = size;
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0.09f, 0.12f, 0.13f, 0.96f);
			Button val4 = val.AddComponent<Button>();
			((Selectable)val4).targetGraphic = (Graphic)(object)val3;
			((Selectable)val4).transition = (Transition)1;
			TextMeshProUGUI val5 = CreateText(val.transform, "Label", fontSize, (TextAlignmentOptions)514);
			((TMP_Text)val5).text = label;
			((Graphic)val5).color = Color.white;
			((TMP_Text)val5).enableWordWrapping = false;
			((TMP_Text)val5).overflowMode = (TextOverflowModes)1;
			RectTransform rectTransform = ((TMP_Text)val5).rectTransform;
			rectTransform.offsetMin = new Vector2(8f, 0f);
			rectTransform.offsetMax = new Vector2(-8f, 0f);
			return new ButtonVisual(val4, val3, val5);
		}

		private static void ApplyButtonStyle(ButtonVisual visual, bool enabled, bool selected, bool compact)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			((Selectable)visual.Button).interactable = enabled;
			Color val = (selected ? new Color(0.13f, 0.45f, 0.46f, 0.98f) : new Color(0.075f, 0.095f, 0.105f, compact ? 0.7f : 0.96f));
			Color val2 = (selected ? new Color(0.16f, 0.55f, 0.56f, 1f) : new Color(0.13f, 0.18f, 0.19f, 0.98f));
			Color pressedColor = (selected ? new Color(0.09f, 0.32f, 0.34f, 1f) : new Color(0.045f, 0.06f, 0.065f, 1f));
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.06f, 0.065f, 0.07f, 0.55f);
			ColorBlock colors = ((Selectable)visual.Button).colors;
			((ColorBlock)(ref colors)).normalColor = val;
			((ColorBlock)(ref colors)).highlightedColor = val2;
			((ColorBlock)(ref colors)).pressedColor = pressedColor;
			((ColorBlock)(ref colors)).selectedColor = val2;
			((ColorBlock)(ref colors)).disabledColor = val3;
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((Selectable)visual.Button).colors = colors;
			((Graphic)visual.Background).color = (enabled ? val : val3);
			((Graphic)visual.Label).color = ((!enabled) ? new Color(0.42f, 0.49f, 0.5f, 1f) : (selected ? new Color(0.98f, 1f, 1f, 1f) : new Color(0.74f, 0.84f, 0.86f, 1f)));
			((TMP_Text)visual.Label).fontStyle = (FontStyles)(selected ? 1 : 0);
		}

		private static void SetOffsets(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}

		private static void SetAnchors(RectTransform rect, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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)
			rect.anchorMin = anchorMin;
			rect.anchorMax = anchorMax;
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}

		private static string Money(int value)
		{
			return "$" + value.ToString("N0", CultureInfo.InvariantCulture);
		}

		private static string Number(int value)
		{
			return value.ToString("N0", CultureInfo.InvariantCulture);
		}

		private static string Percent(float value)
		{
			return value.ToString("0.##", CultureInfo.InvariantCulture) + "%";
		}

		private static string Weight(float value)
		{
			return value.ToString("0.##", CultureInfo.InvariantCulture);
		}

		private static string CountAndMoney(int count, int value)
		{
			return Number(count) + " / " + Money(value);
		}

		private static string CountDetail(int count, string singular)
		{
			return Number(count) + " " + singular + ((count == 1) ? string.Empty : "s");
		}
	}
	internal sealed class ReportUiController
	{
		private enum ReportKey
		{
			None,
			Menu,
			Escape
		}

		private sealed class PageContent
		{
			public ReportSnapshot? Snapshot { get; }

			public string FallbackText { get; }

			public string Footer { get; }

			public PageContent(ReportSnapshot? snapshot, string fallbackText, string footer)
			{
				Snapshot = snapshot;
				FallbackText = fallbackText;
				Footer = footer;
			}
		}

		private readonly ReportSyncService _syncService;

		private readonly Func<ReportSnapshot?> _liveReportProvider;

		private ReportSnapshot? _latestFinalReport;

		private ReportSnapshot? _latestLiveReport;

		private ReportOverlayPage? _overlay;

		private int _lastHandledFrame = -1;

		private ReportKey _lastHandledKey;

		private InputAction? _menuAction;

		private bool _menuActionWasHeld;

		private bool _waitingForShortcutRelease;

		private float _shortcutReleaseWaitStartedAt;

		private float _ignoreHotkeysUntil;

		private int _suppressGameMenuInputFrame = -1;

		private ReportUiTab _selectedTab;

		public ReportUiController(ReportSyncService syncService, Func<ReportSnapshot?> liveReportProvider)
		{
			_syncService = syncService ?? throw new ArgumentNullException("syncService");
			_liveReportProvider = liveReportProvider ?? throw new ArgumentNullException("liveReportProvider");
		}

		public void Initialize()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			RebuildInputActions();
			NuageReportPlugin.Log.LogInfo((object)($"Report UI initialized. MenuShortcut={PluginConfig.Instance.EffectiveReportMenuShortcut()}, " + $"SelectedTab={_selectedTab}, LiveEnabled={PluginConfig.Instance.IsLiveReportEnabled()}, " + $"MenuInputAction={_menuAction != null}"));
		}

		public void Tick(string source = "Update")
		{
			//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)
			if (!PluginConfig.Instance.IsModActive())
			{
				Deactivate();
				return;
			}
			KeepOpenMenuValid();
			if (!HotkeysAreSuppressed())
			{
				bool flag = ActionIsDown(_menuAction, ref _menuActionWasHeld);
				KeyboardShortcut val = PluginConfig.Instance.EffectiveReportMenuShortcut();
				if (((KeyboardShortcut)(ref val)).IsDown() || flag)
				{
					HandleMenuKey(flag ? (source + "/InputAction") : (source + "/KeyboardShortcut"));
				}
			}
		}

		public bool HandleKeyEvent(KeyCode keyCode, string source)
		{
			//IL_0014: 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_001c: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!PluginConfig.Instance.IsModActive())
			{
				Deactivate();
				return false;
			}
			if ((int)keyCode == 0)
			{
				return false;
			}
			if ((int)keyCode == 27 && TryConsumeEscapeMenuInput(source))
			{
				return true;
			}
			if (HotkeysAreSuppressed())
			{
				return false;
			}
			if (IsMenuKey(keyCode))
			{
				return HandleMenuKey(source);
			}
			return false;
		}

		public void Deactivate()
		{
			CloseOpenPage();
			_menuActionWasHeld = false;
			_waitingForShortcutRelease = false;
		}

		public bool TryConsumeEscapeMenuInput(string source)
		{
			if (_suppressGameMenuInputFrame == Time.frameCount)
			{
				return true;
			}
			if ((Object)(object)_overlay == (Object)null)
			{
				return false;
			}
			if (!TryMarkHandled(ReportKey.Escape))
			{
				SuppressGameMenuInputThisFrame();
				return true;
			}
			NuageReportPlugin.Log.LogInfo((object)("Report overlay escape close detected via " + source + "."));
			CloseOpenPage();
			SuppressHotkeysUntilReleased();
			SuppressGameMenuInputThisFrame();
			return true;
		}

		public void SetLatestFinalReport(ReportSnapshot snapshot)
		{
			_latestFinalReport = snapshot ?? throw new ArgumentNullException("snapshot");
			RefreshOpenTab(ReportUiTab.Summary);
		}

		public void SetLatestLiveReport(ReportSnapshot snapshot)
		{
			_latestLiveReport = snapshot ?? throw new ArgumentNullException("snapshot");
			RefreshOpenTab(ReportUiTab.Live);
		}

		private bool HandleMenuKey(string source)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!TryMarkHandled(ReportKey.Menu))
			{
				return false;
			}
			NuageReportPlugin.Log.LogInfo((object)($"Report menu key detected via {source}. enabledTabs=summary:{IsTabEnabled(ReportUiTab.Summary)} live:{IsTabEnabled(ReportUiTab.Live)} " + $"shortcut={PluginConfig.Instance.EffectiveReportMenuShortcut()} hasFinal={HasFinalReport()} hasLive={HasLiveReport()}"));
			if ((Object)(object)_overlay != (Object)null)
			{
				CloseOpenPage();
				SuppressHotkeysUntilReleased();
				return true;
			}
			try
			{
				OpenReportMenu();
			}
			finally
			{
				SuppressHotkeysUntilReleased();
			}
			return true;
		}

		private void OpenReportMenu()
		{
			ReportUiTab selectedTab = _selectedTab;
			ReportUiTab? reportUiTab = ChooseAvailableTab(selectedTab);
			if (!reportUiTab.HasValue)
			{
				NuageReportPlugin.Log.LogInfo((object)"Report menu did not open because both report tabs are disabled.");
				return;
			}
			_selectedTab = reportUiTab.Value;
			PageContent pageContent = ContentFor(_selectedTab);
			CloseOpenPage();
			try
			{
				_overlay = ReportOverlayPage.Create(_selectedTab, IsTabEnabled(ReportUiTab.Summary), IsTabEnabled(ReportUiTab.Live), pageContent.Snapshot, pageContent.FallbackText, pageContent.Footer, SelectTabFromOverlay, delegate
				{
					_overlay = null;
				});
			}
			catch (Exception arg)
			{
				_overlay = null;
				NuageReportPlugin.Log.LogError((object)$"Failed to open report overlay: {arg}");
			}
		}

		private void SelectTabFromOverlay(ReportUiTab tab)
		{
			SelectTab(tab);
		}

		private void SelectTab(ReportUiTab tab)
		{
			if (!IsTabEnabled(tab))
			{
				KeepOpenMenuValid();
				return;
			}
			_selectedTab = tab;
			UpdateOpenMenuContent();
		}

		private void KeepOpenMenuValid()
		{
			if (!((Object)(object)_overlay == (Object)null) && !IsTabEnabled(_selectedTab))
			{
				ReportUiTab? reportUiTab = ChooseAvailableTab(OtherTab(_selectedTab));
				if (!reportUiTab.HasValue)
				{
					CloseOpenPage();
				}
				else
				{
					SelectTab(reportUiTab.Value);
				}
			}
		}

		private void RefreshOpenTab(ReportUiTab tab)
		{
			if ((Object)(object)_overlay != (Object)null && _selectedTab == tab && IsTabEnabled(tab))
			{
				UpdateOpenMenuContent();
			}
		}

		private void UpdateOpenMenuContent()
		{
			if (!((Object)(object)_overlay == (Object)null))
			{
				PageContent pageContent = ContentFor(_selectedTab);
				_overlay.SetContent(_selectedTab, IsTabEnabled(ReportUiTab.Summary), IsTabEnabled(ReportUiTab.Live), pageContent.Snapshot, pageContent.FallbackText, pageContent.Footer);
			}
		}

		private PageContent ContentFor(ReportUiTab tab)
		{
			if (tab != ReportUiTab.Live)
			{
				return SummaryContent();
			}
			return LiveContent();
		}

		private PageContent SummaryContent()
		{
			ReportSnapshot reportSnapshot = _latestFinalReport ?? _syncService.LatestFinalReport;
			if (reportSnapshot == null)
			{
				_syncService.RequestLatestReport(includeFinalReport: true, includeLiveReport: false);
				return new PageContent(null, "No completed level report is available yet.", "Summary | No completed report");
			}
			return new PageContent(reportSnapshot, reportSnapshot.DisplayText, FooterForSnapshot(reportSnapshot, "Summary"));
		}

		private PageContent LiveContent()
		{
			ReportSnapshot reportSnapshot = _liveReportProvider() ?? _latestLiveReport ?? _syncService.LatestLiveReport;
			if (reportSnapshot == null)
			{
				_syncService.RequestLatestReport(includeFinalReport: false, includeLiveReport: true);
				return new PageContent(null, "No live report is available.", "Live | Waiting for an active shared report");
			}
			return new PageContent(reportSnapshot, reportSnapshot.DisplayText, FooterForSnapshot(reportSnapshot, "Live"));
		}

		private bool HasFinalReport()
		{
			if (_latestFinalReport == null)
			{
				return _syncService.LatestFinalReport != null;
			}
			return true;
		}

		private bool HasLiveReport()
		{
			if (_latestLiveReport == null)
			{
				return _syncService.LatestLiveReport != null;
			}
			return true;
		}

		private static ReportUiTab? ChooseAvailableTab(ReportUiTab preferredTab)
		{
			if (IsTabEnabled(preferredTab))
			{
				return preferredTab;
			}
			ReportUiTab reportUiTab = OtherTab(preferredTab);
			if (!IsTabEnabled(reportUiTab))
			{
				return null;
			}
			return reportUiTab;
		}

		private static bool IsTabEnabled(ReportUiTab tab)
		{
			if (tab != ReportUiTab.Live)
			{
				return true;
			}
			return PluginConfig.Instance.IsLiveReportEnabled();
		}

		private static ReportUiTab OtherTab(ReportUiTab tab)
		{
			if (tab != ReportUiTab.Live)
			{
				return ReportUiTab.Live;
			}
			return ReportUiTab.Summary;
		}

		private void RebuildInputActions()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			InputAction? menuAction = _menuAction;
			if (menuAction != null)
			{
				menuAction.Disable();
			}
			KeyboardShortcut val = PluginConfig.Instance.EffectiveReportMenuShortcut();
			_menuAction = CreateInputAction("NuageReport Menu", ((KeyboardShortcut)(ref val)).MainKey);
			_menuActionWasHeld = false;
		}

		private static InputAction? CreateInputAction(string name, KeyCode keyCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			string text = BindingPathFor(keyCode);
			if (text == null)
			{
				return null;
			}
			InputAction val = new InputAction(name, (InputActionType)1, text, (string)null, (string)null, (string)null);
			val.Enable();
			return val;
		}

		private static bool ActionIsDown(InputAction? action, ref bool wasHeld)
		{
			if (action == null)
			{
				return false;
			}
			bool flag = action.ReadValue<float>() > 0.5f;
			bool result = flag && !wasHeld;
			wasHeld = flag;
			return result;
		}

		private bool TryMarkHandled(ReportKey key)
		{
			if (_lastHandledFrame == Time.frameCount && _lastHandledKey == key)
			{
				return false;
			}
			_lastHandledFrame = Time.frameCount;
			_lastHandledKey = key;
			return true;
		}

		private static bool IsMenuKey(KeyCode keyCode)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut val = PluginConfig.Instance.EffectiveReportMenuShortcut();
			return keyCode == ((KeyboardShortcut)(ref val)).MainKey;
		}

		private bool HotkeysAreSuppressed()
		{
			if (Time.unscaledTime < _ignoreHotkeysUntil)
			{
				return true;
			}
			if (!_waitingForShortcutRelease)
			{
				return false;
			}
			if (Time.unscaledTime - _shortcutReleaseWaitStartedAt > 2f)
			{
				_waitingForShortcutRelease = false;
				return false;
			}
			if (AnyReportShortcutPressed())
			{
				return true;
			}
			_waitingForShortcutRelease = false;
			return false;
		}

		private void SuppressHotkeysUntilReleased()
		{
			_waitingForShortcutRelease = true;
			_shortcutReleaseWaitStartedAt = Time.unscaledTime;
			_ignoreHotkeysUntil = Time.unscaledTime + 0.15f;
			_menuActionWasHeld = IsActionPressed(_menuAction);
		}

		private void SuppressGameMenuInputThisFrame()
		{
			_suppressGameMenuInputFrame = Time.frameCount;
		}

		private bool AnyReportShortcutPressed()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut val = PluginConfig.Instance.EffectiveReportMenuShortcut();
			if (!((KeyboardShortcut)(ref val)).IsPressed())
			{
				return IsActionPressed(_menuAction);
			}
			return true;
		}

		private static bool IsActionPressed(InputAction? action)
		{
			if (action != null)
			{
				return action.ReadValue<float>() > 0.5f;
			}
			return false;
		}

		private static string? BindingPathFor(KeyCode keyCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Invalid comparison between Unknown and I4
			//IL_000d: 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_005a: Expected I4, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected I4, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Invalid comparison between Unknown and I4
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			if ((int)keyCode <= 91)
			{
				if ((int)keyCode == 32)
				{
					return "<Keyboard>/space";
				}
				switch (keyCode - 45)
				{
				default:
					if ((int)keyCode != 91)
					{
						break;
					}
					return "<Keyboard>/leftBracket";
				case 3:
					return "<Keyboard>/0";
				case 4:
					return "<Keyboard>/1";
				case 5:
					return "<Keyboard>/2";
				case 6:
					return "<Keyboard>/3";
				case 7:
					return "<Keyboard>/4";
				case 8:
					return "<Keyboard>/5";
				case 9:
					return "<Keyboard>/6";
				case 10:
					return "<Keyboard>/7";
				case 11:
					return "<Keyboard>/8";
				case 12:
					return "<Keyboard>/9";
				case 0:
					return "<Keyboard>/minus";
				case 16:
					return "<Keyboard>/equals";
				case 1:
				case 2:
				case 13:
				case 14:
				case 15:
					break;
				}
			}
			else if ((int)keyCode <= 96)
			{
				if ((int)keyCode == 93)
				{
					return "<Keyboard>/rightBracket";
				}
				if ((int)keyCode == 96)
				{
					return "<Keyboard>/backquote";
				}
			}
			else
			{
				if ((int)keyCode == 111)
				{
					return "<Keyboard>/o";
				}
				switch (keyCode - 282)
				{
				case 0:
					return "<Keyboard>/f1";
				case 1:
					return "<Keyboard>/f2";
				case 2:
					return "<Keyboard>/f3";
				case 3:
					return "<Keyboard>/f4";
				case 4:
					return "<Keyboard>/f5";
				case 5:
					return "<Keyboard>/f6";
				case 6:
					return "<Keyboard>/f7";
				case 7:
					return "<Keyboard>/f8";
				case 8:
					return "<Keyboard>/f9";
				case 9:
					return "<Keyboard>/f10";
				case 10:
					return "<Keyboard>/f11";
				case 11:
					return "<Keyboard>/f12";
				}
			}
			return null;
		}

		private void CloseOpenPage()
		{
			if (!((Object)(object)_overlay == (Object)null))
			{
				ReportOverlayPage overlay = _overlay;
				_overlay = null;
				overlay.Close();
			}
		}

		private static string FooterForSnapshot(ReportSnapshot snapshot, string header)
		{
			string text = (string.IsNullOrWhiteSpace(snapshot.LevelName) ? "Unknown level" : snapshot.LevelName);
			string text2 = ((snapshot.ReportKind == ReportKind.Live) ? "Live" : "Complete");
			return string.Format(CultureInfo.InvariantCulture, "{0} | {1} | {2} | Run {3} | Generated {4:u}", header, text2, text, snapshot.RunId, snapshot.GeneratedAtUtc);
		}
	}
	[Serializable]
	internal sealed class ReportUiData
	{
		public int schemaVersion;

		public string runId = string.Empty;

		public string startedAt = string.Empty;

		public string endedAt = string.Empty;

		public ReportUiGlobal? global;

		public ReportUiPlayer[]? players;

		public ReportUiCosmeticObjects? cosmeticObjects;

		public static bool TryParse(string json, out ReportUiData? data)
		{
			data = null;
			if (string.IsNullOrWhiteSpace(json))
			{
				return false;
			}
			try
			{
				object obj = new ReportJsonReader(json).Read();
				if (!(obj is Dictionary<string, object> map))
				{
					return false;
				}
				data = FromMap(map);
				return data.global != null;
			}
			catch
			{
				data = null;
				return false;
			}
		}

		private static ReportUiData FromMap(Dictionary<string, object?> map)
		{
			return new ReportUiData
			{
				schemaVersion = IntValue(map, "schemaVersion"),
				runId = StringValue(map, "runId"),
				startedAt = StringValue(map, "startedAt"),
				endedAt = StringValue(map, "endedAt"),
				global = GlobalFromMap(ObjectValue(map, "global")),
				players = PlayersFromArray(ArrayValue(map, "players")),
				cosmeticObjects = CosmeticObjectsFromMap(ObjectValue(map, "cosmeticObjects"))
			};
		}

		private static ReportUiGlobal? GlobalFromMap(Dictionary<string, object?>? map)
		{
			if (map == null)
			{
				return null;
			}
			return new ReportUiGlobal
			{
				objectsAtStart = IntValue(map, "objectsAtStart"),
				objectsAtStartValue = IntValue(map, "objectsAtStartValue"),
				objectsExtracted = IntValue(map, "objectsExtracted"),
				objectsExtractedValue = IntValue(map, "objectsExtractedValue"),
				objectsDetected = IntValue(map, "objectsDetected"),
				objectsDetectedPercent = FloatValue(map, "objectsDetectedPercent"),
				objectsMissed = IntValue(map, "objectsMissed"),
				objectsDamaged = IntValue(map, "objectsDamaged"),
				objectsDestroyed = IntValue(map, "objectsDestroyed"),
				objectsValueLost = IntValue(map, "objectsValueLost"),
				orbsCollected = IntValue(map, "orbsCollected"),
				orbsDestroyed = IntValue(map, "orbsDestroyed"),
				orbsExtractedValue = IntValue(map, "orbsExtractedValue"),
				orbsLostValue = IntValue(map, "orbsLostValue"),
				cosmeticObjectsExisting = IntValue(map, "cosmeticObjectsExisting"),
				cosmeticObjectsFound = IntValue(map, "cosmeticObjectsFound"),
				monsterDamageTaken = IntValue(map, "monsterDamageTaken"),
				monstersKilled = IntValue(map, "monstersKilled"),
				playerDamageTaken = IntValue(map, "playerDamageTaken")
			};
		}

		private static ReportUiPlayer[] PlayersFromArray(List<object?>? values)
		{
			if (values == null || values.Count == 0)
			{
				return Array.Empty<ReportUiPlayer>();
			}
			List<ReportUiPlayer> list = new List<ReportUiPlayer>(values.Count);
			foreach (object value in values)
			{
				if (value is Dictionary<string, object> map)
				{
					list.Add(new ReportUiPlayer
					{
						playerId = StringValue(map, "playerId"),
						displayName = StringValue(map, "displayName"),
						objectsPutInCartOrCashout = IntValue(map, "objectsPutInCartOrCashout"),
						objectsPutInCartOrCashoutValue = IntValue(map, "objectsPutInCartOrCashoutValue"),
						extractedObjectWeight = FloatValue(map, "extractedObjectWeight"),
						averageExtractedObjectWeight = FloatValue(map, "averageExtractedObjectWeight"),
						averageExtractedObjectValue = IntValue(map, "averageExtractedObjectValue"),
						objectsDetected = IntValue(map, "objectsDetected"),
						objectsDetectedValue = IntValue(map, "objectsDetectedValue"),
						damageDealt = IntValue(map, "damageDealt"),
						damageTaken = IntValue(map, "damageTaken")
					});
				}
			}
			return list.ToArray();
		}

		private static ReportUiCosmeticObjects? CosmeticObjectsFromMap(Dictionary<string, object?>? map)
		{
			if (map == null)
			{
				return null;
			}
			return new ReportUiCosmeticObjects
			{
				existing = ValuablesFromArray(ArrayValue(map, "existing")),
				found = ValuablesFromArray(ArrayValue(map, "found"))
			};
		}

		private static ReportUiValuable[] ValuablesFromArray(List<object?>? values)
		{
			if (values == null || values.Count == 0)
			{
				return Array.Empty<ReportUiValuable>();
			}
			List<ReportUiValuable> list = new List<ReportUiValuable>(values.Count);
			foreach (object value in values)
			{
				if (value is Dictionary<string, object> map)
				{
					list.Add(new ReportUiValuable
					{
						runtimeId = StringValue(map, "runtimeId"),
						name = StringValue(map, "name"),
						valueAtEvent = IntValue(map, "valueAtEvent"),
						weightAtEvent = FloatValue(map, "weightAtEvent")
					});
				}
			}
			return list.ToArray();
		}

		private static Dictionary<string, object?>? ObjectValue(Dictionary<string, object?> map, string key)
		{
			if (!map.TryGetValue(key, out object value))
			{
				return null;
			}
			return value as Dictionary<string, object>;
		}

		private static List<object?>? ArrayValue(Dictionary<string, object?> map, string key)
		{
			if (!map.TryGetValue(key, out object value))
			{
				return null;
			}
			return value as List<object>;
		}

		private static string StringValue(Dictionary<string, object?> map, string key)
		{
			if (!map.TryGetValue(key, out object value))
			{
				return string.Empty;
			}
			return (value as string) ?? string.Empty;
		}

		private static int IntValue(Dictionary<string, object?> map, string key)
		{
			if (!map.TryGetValue(key, out object value))
			{
				return 0;
			}
			object obj = value;
			if (!(obj is int result))
			{
				if (!(obj is double num))
				{
					if (!(obj is float num2))
					{
						if (obj is string text)
						{
							string s = text;
							if (int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
							{
								return result2;
							}
						}
						return 0;
					}
					float num3 = num2;
					return (int)num3;
				}
				double num4 = num;
				return (int)num4;
			}
			return result;
		}

		private static float FloatValue(Dictionary<string, object?> map, string key)
		{
			if (!map.TryGetValue(key, out object value))
			{
				return 0f;
			}
			object obj = value;
			if (!(obj is float result))
			{
				if (!(obj is double num))
				{
					if (!(obj is int num2))
					{
						if (obj is string text)
						{
							string s = text;
							if (float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
							{
								return result2;
							}
						}
						return 0f;
					}
					int num3 = num2;
					return num3;
				}
				double num4 = num;
				return (float)num4;
			}
			return result;
		}

		private static bool BoolValue(Dictionary<string, object?> map, string key)
		{
			object value;
			bool flag = map.TryGetValue(key, out value);
			bool flag2 = flag;
			bool flag4;
			if (flag2)
			{
				object obj = value;
				if (!(obj is bool flag3))
				{
					if (obj is string text)
					{
						string value2 = text;
						if (bool.TryParse(value2, out var result))
						{
							flag4 = result;
							goto IL_0055;
						}
					}
					flag4 = false;
				}
				else
				{
					bool flag5 = flag3;
					flag4 = flag5;
				}
				goto IL_0055;
			}
			goto IL_0058;
			IL_0055:
			flag2 = flag4;
			goto IL_0058;
			IL_0058:
			return flag2;
		}
	}
	[Serializable]
	internal sealed class ReportUiGlobal
	{
		public int objectsAtStart;

		public int objectsAtStartValue;

		public int objectsExtracted;

		public int objectsExtractedValue;

		public int objectsDetected;

		public float objectsDetectedPercent;

		public int objectsMissed;

		public int objectsDamaged;

		public int objectsDestroyed;

		public int objectsValueLost;

		public int orbsCollected;

		public int orbsDestroyed;

		public int orbsExtractedValue;

		public int orbsLostValue;

		public int cosmeticObjectsExisting;

		public int cosmeticObjectsFound;

		public int monsterDamageTaken;

		public int monstersKilled;

		public int playerDamageTaken;
	}
	[Serializable]
	internal sealed class ReportUiPlayer
	{
		public string playerId = string.Empty;

		public string displayName = string.Empty;

		public int objectsPutInCartOrCashout;

		public int objectsPutInCartOrCashoutValue;

		public float extractedObjectWeight;

		public float averageExtractedObjectWeight;

		public int averageExtractedObjectValue;

		public int objectsDetected;

		public int objectsDetectedValue;

		public int damageDealt;

		public int damageTaken;
	}
	[Serializable]
	internal sealed class ReportUiCosmeticObjects
	{
		public ReportUiValuable[]? existing;

		public ReportUiValuable[]? found;
	}
	[Serializable]
	internal sealed class ReportUiValuable
	{
		public string runtimeId = string.Empty;

		public string name = string.Empty;

		public int valueAtEvent;

		public float weightAtEvent;
	}
	internal sealed class ReportJsonReader
	{
		private readonly string _json;

		private int _index;

		public ReportJsonReader(string json)
		{
			_json = json;
		}

		public object? Read()
		{
			object result = ReadValue();
			SkipWhitespace();
			return result;
		}

		private object? ReadValue()
		{
			SkipWhitespace();
			if (_index >= _json.Length)
			{
				throw new FormatException("Unexpected end of JSON.");
			}
			switch (_json[_index])
			{
			case '{':
				return ReadObject();
			case '[':
				return ReadArray();
			case '"':
				return ReadString();
			case 't':
				return ReadLiteral("true", true);
			case 'f':
				return ReadLiteral("false", false);
			case 'n':
				return ReadLiteral("null", null);
			case '-':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				return ReadNumber();
			default:
				throw new FormatException("Unexpected JSON token.");
			}
		}

		private Dictionary<string, object?> ReadObject()
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.Ordinal);
			Expect('{');
			SkipWhitespace();
			if (TryConsume('}'))
			{
				return dictionary;
			}
			while (true)
			{
				string key = ReadString();
				SkipWhitespace();
				Expect(':');
				dictionary[key] = ReadValue();
				SkipWhitespace();
				if (TryConsume('}'))
				{
					break;
				}
				Expect(',');
			}
			return dictionary;
		}

		private List<object?> ReadArray()
		{
			List<object> list = new List<object>();
			Expect('[');
			SkipWhitespace();
			if (TryConsume(']'))
			{
				return list;
			}
			while (true)
			{
				list.Add(ReadValue());
				SkipWhitespace();
				if (TryConsume(']'))
				{
					break;
				}
				Expect(',');
			}
			return list;
		}

		private string ReadString()
		{
			Expect('"');
			StringBuilder stringBuilder = new StringBuilder();
			while (_index < _json.Length)
			{
				char c = _json[_index++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				default:
					stringBuilder.Append(c);
					break;
				case '\\':
				{
					if (_index >= _json.Length)
					{
						throw new FormatException("Unexpected end of JSON escape.");
					}
					char c2 = _json[_index++];
					switch (c2)
					{
					case '"':
					case '/':
					case '\\':
						stringBuilder.Append(c2);
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'u':
						stringBuilder.Append(ReadUnicodeEscape());
						break;
					default:
						throw new FormatException("Unsupported JSON escape.");
					}
					break;
				}
				}
			}
			throw new FormatException("Unterminated JSON string.");
		}

		private char ReadUnicodeEscape()
		{
			if (_index + 4 > _json.Length)
			{
				throw new FormatException("Incomplete JSON unicode escape.");
			}
			string s = _json.Substring(_index, 4);
			_index += 4;
			return (char)int.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
		}

		private object ReadNumber()
		{
			int index = _index;
			if (_json[_index] == '-')
			{
				_index++;
			}
			while (_index < _json.Length && char.IsDigit(_json[_index]))
			{
				_index++;
			}
			bool flag = false;
			if (_index < _json.Length && _json[_index] == '.')
			{
				flag = true;
				_index++;
				while (_index < _json.Length && char.IsDigit(_json[_index]))
				{
					_index++;
				}
			}
			if (_index < _json.Length && (_json[_index] == 'e' || _json[_index] == 'E'))
			{
				flag = true;
				_index++;
				if (_index < _json.Length && (_json[_index] == '+' || _json[_index] == '-'))
				{
					_index++;
				}
				while (_index < _json.Length && char.IsDigit(_json[_index]))
				{
					_index++;
				}
			}
			string s = _json.Substring(index, _index - index);
			if (!flag && int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return double.Parse(s, NumberStyles.Float, CultureInfo.InvariantCulture);
		}

		private object? ReadLiteral(string literal, object? value)
		{
			if (_index + literal.Length > _json.Length || string.CompareOrdinal(_json, _index, literal, 0, literal.Length) != 0)
			{
				throw new FormatException("Unexpected JSON literal.");
			}
			_index += literal.Length;
			return value;
		}

		private bool TryConsume(char expected)
		{
			SkipWhitespace();
			if (_index >= _json.Length || _json[_index] != expected)
			{
				return false;
			}
			_index++;
			return true;
		}

		private void Expect(char expected)
		{
			SkipWhitespace();
			if (_index >= _json.Length || _json[_index] != expected)
			{
				throw new FormatException("Unexpected JSON token.");
			}
			_index++;
		}

		private void SkipWhitespace()
		{
			while (_index < _json.Length && char.IsWhiteSpace(_json[_index]))
			{
				_index++;
			}
		}
	}
	internal enum ReportUiTab
	{
		Summary,
		Live
	}
}
namespace NuageReport.Plugin.Reports
{
	internal enum ReportKind
	{
		Summary,
		Live
	}
	internal sealed class ReportSnapshot
	{
		private const string SchemaVersionKey = "schemaVersion";

		private const string ModVersionKey = "modVersion";

		private const string RunIdKey = "runId";

		private const string LevelIndexKey = "levelIndex";

		private const string LevelNameKey = "levelName";

		private const string ReportKindKey = "reportKind";

		private const string SpoilerModeKey = "spoilerMode";

		private const string GeneratedAtUtcKey = "generatedAtUtc";

		private const string JsonPayloadKey = "jsonPayload";

		private const string DisplayTextKey = "displayText";

		private const string ContentHashKey = "contentHash";

		public int SchemaVersion => 1;

		public string ModVersion { get; }

		public string RunId { get; }

		public int? LevelIndex { get; }

		public string? LevelName { get; }

		public ReportKind ReportKind { get; }

		public ReportSpoilerMode SpoilerMode { get; }

		public DateTimeOffset GeneratedAtUtc { get; }

		public string JsonPayload { get; }

		public string DisplayText { get; }

		public string ContentHash { get; }

		public ReportSnapshot(string modVersion, string runId, int? levelIndex, string? levelName, ReportKind reportKind, ReportSpoilerMode spoilerMode, DateTimeOffset generatedAtUtc, string jsonPayload, string displayText)
		{
			ModVersion = (string.IsNullOrWhiteSpace(modVersion) ? "unknown" : modVersion);
			RunId = (string.IsNullOrWhiteSpace(runId) ? "unknown" : runId);
			LevelIndex = levelIndex;
			LevelName = levelName;
			ReportKind = reportKind;
			SpoilerMode = spoilerMode;
			GeneratedAtUtc = generatedAtUtc;
			JsonPayload = jsonPayload ?? string.Empty;
			DisplayText = displayText ?? string.Empty;
			ContentHash = CalculateContentHash(ModVersion, RunId, LevelIndex, LevelName, ReportKind, SpoilerMode, JsonPayload, DisplayText);
		}

		public Hashtable ToHashtable()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_004a: 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)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			Hashtable val = new Hashtable
			{
				[(object)"schemaVersion"] = SchemaVersion,
				[(object)"modVersion"] = ModVersion,
				[(object)"runId"] = RunId,
				[(object)"reportKind"] = ReportKind.ToString(),
				[(object)"spoilerMode"] = SpoilerMode.ToString(),
				[(object)"generatedAtUtc"] = GeneratedAtUtc.ToString("O", CultureInfo.InvariantCulture),
				[(object)"jsonPayload"] = JsonPayload,
				[(object)"displayText"] = DisplayText,
				[(object)"contentHash"] = ContentHash
			};
			if (LevelIndex.HasValue)
			{
				val[(object)"levelIndex"] = LevelIndex.Value;
			}
			if (!string.IsNullOrWhiteSpace(LevelName))
			{
				val[(object)"levelName"] = LevelName;
			}
			return val;
		}

		public static bool TryFromHashtable(object? value, out ReportSnapshot? snapshot)
		{
			snapshot = null;
			Hashtable val = (Hashtable)((value is Hashtable) ? value : null);
			if (val == null)
			{
				return false;
			}
			string text = ReadString(val, "runId");
			string value2 = ReadString(val, "reportKind");
			string value3 = ReadString(val, "spoilerMode");
			string input = ReadString(val, "generatedAtUtc");
			if (string.IsNullOrWhiteSpace(text) || !Enum.TryParse<ReportKind>(value2, ignoreCase: true, out var result) || !Enum.TryParse<ReportSpoilerMode>(value3, ignoreCase: true, out var result2) || !DateTimeOffset.TryParse(input, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result3))
			{
				return false;
			}
			snapshot = new ReportSnapshot(ReadString(val, "modVersion") ?? "unknown", text, ReadInt(val, "levelIndex"), ReadString(val, "levelName"), result, result2, result3, ReadString(val, "jsonPayload") ?? string.Empty, ReadString(val, "displayText") ?? string.Empty);
			return true;
		}

		private static string? ReadString(Hashtable table, string key)
		{
			if (!((Dictionary<object, object>)(object)table).TryGetValue((object)key, out object value))
			{
				return null;
			}
			return value as string;
		}

		private static int? ReadInt(Hashtable table, string key)
		{
			if (!((Dictionary<object, object>)(object)table).TryGetValue((object)key, out object value))
			{
				return null;
			}
			object obj = value;
			if (!(obj is int value2))
			{
				if (!(obj is short value3))
				{
					if (!(obj is byte value4))
					{
						if (obj is string text)
						{
							string s = text;
							if (int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
							{
								return result;
							}
						}
						return null;
					}
					return value4;
				}
				return value3;
			}
			return value2;
		}

		private static string CalculateContentHash(string modVersion, string runId, int? levelIndex, string? levelName, ReportKind reportKind, ReportSpoilerMode spoilerMode, string jsonPayload, string displayText)
		{
			ulong hash = 14695981039346656037uL;
			Add(ref hash, modVersion);
			Add(ref hash, runId);
			Add(ref hash, levelIndex?.ToString(CultureInfo.InvariantCulture) ?? string.Empty);
			Add(ref hash, levelName ?? string.Empty);
			Add(ref hash, reportKind.ToString());
			Add(ref hash, spoilerMode.ToString());
			Add(ref hash, jsonPayload);
			Add(ref hash, displayText);
			return hash.ToString("x16", CultureInfo.InvariantCulture);
		}

		private static void Add(ref ulong hash, string value)
		{
			for (int i = 0; i < value.Length; i++)
			{
				hash ^= value[i];
				hash *= 1099511628211uL;
			}
			hash ^= 31uL;
			hash *= 1099511628211uL;
		}
	}
	internal sealed class ReportSnapshotFactory
	{
		private readonly DisplayReportFormatter _displayFormatter = new DisplayReportFormatter();

		private readonly LiveReportPayloadFormatter _livePayloadFormatter = new LiveReportPayloadFormatter();

		public ReportSnapshot CreateFinalReport(RunReport report, string modVersion)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (report == null)
			{
				throw new ArgumentNullException("report");
			}
			return new ReportSnapshot(modVersion, report.RunId, null, LastLevelName(report), ReportKind.Summary, ReportSpoilerMode.Complete, DateTimeOffset.UtcNow, new JsonReportFormatter().Format(report), _displayFormatter.Format(report, (DisplayReportMode)0));
		}

		public ReportSnapshot CreateLiveReport(RunReport report, string modVersion)
		{
			if (report == null)
			{
				throw new ArgumentNullException("report");
			}
			return new ReportSnapshot(modVersion, report.RunId, null, LastLevelName(report), ReportKind.Live, ReportSpoilerMode.Complete, DateTimeOffset.UtcNow, _livePayloadFormatter.Format(report), _displayFormatter.Format(report, (DisplayReportMode)1));
		}

		private static string? LastLevelName(RunReport report)
		{
			return report.Events.Select((RunEvent e) => e.LevelName).LastOrDefault((string levelName) => !string.IsNullOrWhiteSpace(levelName));
		}
	}
	internal enum ReportSpoilerMode
	{
		Complete
	}
}
namespace NuageReport.Plugin.Patches
{
	[HarmonyPatch(typeof(PhysGrabCart), "ObjectsInCart")]
	internal static class CartDetectionPatches
	{
		private readonly struct PendingCartItem
		{
			public int CartId { get; }

			public float FirstSeenAt { get; }

			public PendingCartItem(int cartId, float firstSeenAt)
			{
				CartId = cartId;
				FirstSeenAt = firstSeenAt;
			}
		}

		private static readonly Dictionary<string, PendingCartItem> PendingItems = new Dictionary<string, PendingCartItem>(StringComparer.Ordinal);

		[HarmonyPostfix]
		private static void ObjectsInCart(PhysGrabCart __instance)
		{
			PhysGrabCart __instance2 = __instance;
			PatchSafety.Run("PhysGrabCart.ObjectsInCart", delegate
			{
				RecordObjectsInCart(__instance2, "PhysGrabCart.ObjectsInCart");
			});
		}

		internal static int RecordObjectsInCartFromPolling(PhysGrabCart cart)
		{
			PhysGrabCart cart2 = cart;
			return PatchSafety.Try("PollingRecorder.Carts", () => RecordObjectsInCart(cart2, "PollingRecorder.Carts"), 0);
		}

		private static int RecordObjectsInCart(PhysGrabCart __instance, string hookName)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return 0;
			}
			int instanceID = ((Object)__instance).GetInstanceID();
			List<PhysGrabObject> list = GameAccess.Field<List<PhysGrabObject>>(__instance, "itemsInCart");
			if (list == null || list.Count == 0)
			{
				RemovePendingItemsNotInCart(instanceID, new HashSet<string>(StringComparer.Ordinal));
				return 0;
			}
			PatchSafety.LogHookHit(hookName, $"items={list.Count} active={NuageReportPlugin.Recorder.IsActive}", 20);
			if (!NuageReportPlugin.EnsureRunActiveFromHook(hookName))
			{
				return 0;
			}
			float time = Time.time;
			float num = Mathf.Max(0f, PluginConfig.Instance.CartConfirmationSeconds.Value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			int num2 = 0;
			foreach (PhysGrabObject item in list)
			{
				ValuableRef val = GameObjectRefs.TryCreateValuableRef(item);
				if (val == null)
				{
					continue;
				}
				hashSet.Add(val.RuntimeId);
				if (!PendingItems.TryGetValue(val.RuntimeId, out var value) || value.CartId != instanceID)
				{
					value = new PendingCartItem(instanceID, time);
					PendingItems[val.RuntimeId] = value;
				}
				if (!(time - value.FirstSeenAt < num))
				{
					PlayerRef val2 = GameObjectRefs.TryCreatePlayerRef(item);
					bool flag = NuageReportPlugin.Recorder.TryRecordFirstCarted(val, val2, (ConfidenceLevel)((val2 != null) ? 1 : 2), RunLifecyclePatches.CurrentLevelName());
					PendingItems.Remove(val.RuntimeId);
					if (flag)
					{
						num2++;
					}
				}
			}
			RemovePendingItemsNotInCart(instanceID, hashSet);
			return num2;
		}

		private static void RemovePendingItemsNotInCart(int cartId, HashSet<string> currentlyInThisCart)
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, PendingCartItem> pendingItem in PendingItems)
			{
				if (pendingItem.Value.CartId == cartId && !currentlyInThisCart.Contains(pendingItem.Key))
				{
					list.Add(pendingItem.Key);
				}
			}
			foreach (string item in list)
			{
				PendingItems.Remove(item);
			}
		}
	}
	[HarmonyPatch]
	internal static class CosmeticObjectLifecyclePatches
	{
		[HarmonyPatch(typeof(CosmeticWorldObject), "Start")]
		[HarmonyPostfix]
		private static void CosmeticObjectStarted(CosmeticWorldObject __instance)
		{
			RecordCosmeticObjectExisting(__instance);
		}

		[HarmonyPatch(typeof(CosmeticWorldObject), "ExtractRPC")]
		[HarmonyPostfix]
		private static void CosmeticObjectExtracted(CosmeticWorldObject __instance)
		{
			CosmeticWorldObject __instance2 = __instance;
			PatchSafety.Run("CosmeticWorldObject.ExtractRPC", delegate
			{
				RecordCosmeticObjectFound(__instance2);
			});
		}

		internal static bool RecordCosmeticObjectExisting(CosmeticWorldObject? cosmeticObject)
		{
			CosmeticWorldObject cosmeticObject2 = cosmeticObject;
			return PatchSafety.Try("CosmeticWorldObject.Start", () => RecordCosmeticObjectExistingUnsafe(cosmeticObject2), fallback: false);
		}

		private static bool RecordCosmeticObjectExistingUnsafe(CosmeticWorldObject? cosmeticObject)
		{
			if (!CanRecordActive() || (Object)(object)cosmeticObject == (Object)null)
			{
				return false;
			}
			return NuageReportPlugin.Recorder.TryRecordCosmeticObjectExisting(GameObjectRefs.CreateCosmeticObjectRef(cosmeticObject), GameAccess.EnumText(cosmeticObject, "rarity"), RunLifecyclePatches.CurrentLevelName());
		}

		private static void RecordCosmeticObjectFound(CosmeticWorldObject cosmeticObject)
		{
			if (!((Object)(object)cosmeticObject == (Object)null) && GameAccess.BoolField(cosmeticObject, "inExtraction"))
			{
				PatchSafety.LogHookHit("CosmeticWorldObject.ExtractRPC", $"active={NuageReportPlugin.Recorder.IsActive}", 20);
				if (NuageReportPlugin.EnsureRunActiveFromHook("CosmeticWorldObject.ExtractRPC"))
				{
					NuageReportPlugin.Recorder.TryRecordCosmeticObjectFound(GameObjectRefs.CreateCosmeticObjectRef(cosmeticObject), GameAccess.EnumText(cosmeticObject, "rarity"), RunLifecyclePatches.CurrentLevelName());
				}
			}
		}

		private static bool CanRecordActive()
		{
			if (NuageReportPlugin.CanRecord)
			{
				return NuageReportPlugin.Recorder.IsActive;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class DamagePatches
	{
		private readonly struct HealthState
		{
			public int Health { get; }

			public bool Dead { get; }

			public HealthState(int health, bool dead)
			{
				Health = health;
				Dead = dead;
			}
		}

		[HarmonyPatch(typeof(EnemyHealth), "Hurt")]
		[HarmonyPrefix]
		private static void EnemyHurtPrefix(EnemyHealth __instance, out HealthState __state)
		{
			EnemyHealth __instance2 = __instance;
			__state = PatchSafety.Try("EnemyHealth.Hurt prefix", () => new HealthState(GameAccess.IntField(__instance2, "healthCurrent"), GameAccess.BoolField(__instance2, "dead")), default(HealthState));
		}

		[HarmonyPatch(typeof(EnemyHealth), "Hurt")]
		[HarmonyPostfix]
		private static void EnemyHurtPostfix(EnemyHealth __instance, HealthState __state)
		{
			EnemyHealth __instance2 = __instance;
			PatchSafety.Run("EnemyHealth.Hurt postfix", delegate
			{
				RecordEnemyHurt(__instance2, __state);
			});
		}

		private static void RecordEnemyHurt(EnemyHealth __instance, HealthState __state)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			PatchSafety.LogHookHit("EnemyHealth.Hurt", $"active={NuageReportPlugin.Recorder.IsActive}", 20);
			if (NuageReportPlugin.EnsureRunActiveFromHook("EnemyHealth.Hurt"))
			{
				int val = GameAccess.IntField(__instance, "healthCurrent");
				int num = Math.Max(0, __state.Health - Math.Max(0, val));
				string text = GameObjectRefs.MonsterRuntimeId(__instance);
				string text2 = GameObjectRefs.MonsterName(__instance);
				if (num > 0)
				{
					NuageReportPlugin.Recorder.RecordMonsterDamaged(text, text2, num, RunLifecyclePatches.CurrentLevelName());
				}
			}
		}

		[HarmonyPatch(typeof(EnemyHealth), "DeathImpulseRPC")]
		[HarmonyPostfix]
		private static void EnemyDeathImpulsePostfix(EnemyHealth __instance)
		{
			EnemyHealth __instance2 = __instance;
			PatchSafety.Run("EnemyHealth.DeathImpulseRPC postfix", delegate
			{
				RecordEnemyDeathImpulse(__instance2);
			});
		}

		private static void RecordEnemyDeathImpulse(EnemyHealth __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && GameAccess.BoolField(__instance, "dead"))
			{
				PatchSafety.LogHookHit("EnemyHealth.DeathImpulseRPC", $"active={NuageReportPlugin.Recorder.IsActive}", 20);
				if (NuageReportPlugin.EnsureRunActiveFromHook("EnemyHealth.DeathImpulseRPC"))
				{
					NuageReportPlugin.Recorder.TryRecordMonsterKilled(GameObjectRefs.MonsterRuntimeId(__instance), GameObjectRefs.MonsterName(__instance), RunLifecyclePatches.CurrentLevelName());
				}
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "Hurt")]
		[HarmonyPrefix]
		private static void PlayerHurtPrefix(PlayerHealth __instance, out int __state)
		{
			PlayerHealth __instance2 = __instance;
			__state = PatchSafety.Try("PlayerHealth.Hurt prefix", () => GameAccess.IntField(__instance2, "health"), 0);
		}

		[HarmonyPatch(typeof(PlayerHealth), "Hurt")]
		[HarmonyPostfix]
		private static void PlayerHurtPostfix(PlayerHealth __instance, int __state)
		{
			PlayerHealth __instance2 = __instance;
			PatchSafety.Run("PlayerHealth.Hurt postfix", delegate
			{
				RecordPlayerHealthUpdate(__instance2, __state, "PlayerHealth.Hurt");
			});
		}

		[HarmonyPatch(typeof(PlayerHealth), "UpdateHealthRPC")]
		[HarmonyPrefix]
		private static void PlayerHealthUpdatePrefix(PlayerHealth __instance, out int __state)
		{
			PlayerHealth __instance2 = __instance;
			__state = PatchSafety.Try("PlayerHealth.UpdateHealthRPC prefix", () => GameAccess.IntField(__instance2, "health"), 0);
		}

		[HarmonyPatch(typeof(PlayerHealth), "UpdateHealthRPC")]
		[HarmonyPostfix]
		private static void PlayerHealthUpdatePostfix(PlayerHealth __instance, int __state)
		{
			PlayerHealth __instance2 = __instance;
			PatchSafety.Run("PlayerHealth.UpdateHealthRPC postfix", delegate
			{
				RecordPlayerHealthUpdate(__instance2, __state, "PlayerHealth.UpdateHealthRPC");
			});
		}

		private static void RecordPlayerHealthUpdate(PlayerHealth __instance, int __state, string sourceHook)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			PatchSafety.LogHookHit(sourceHook, $"active={NuageReportPlugin.Recorder.IsActive}", 20);
			if (!NuageReportPlugin.EnsureRunActiveFromHook(sourceHook))
			{
				return;
			}
			int num = Math.Max(0, __state - GameAccess.IntField(__instance, "health"));
			if (num > 0)
			{
				PlayerRef val = GameObjectRefs.TryCreatePlayerRef(__instance);
				if (val != null)
				{
					NuageReportPlugin.Recorder.RecordPlayerDamaged(val, num, RunLifecyclePatches.CurrentLevelName());
				}
			}
		}

		private static bool CanRecordActive()
		{
			if (NuageReportPlugin.CanRecord)
			{
				return NuageReportPlugin.Recorder.IsActive;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class InputManagerPatches
	{
		[HarmonyPatch(typeof(InputManager), "KeyDown")]
		[HarmonyPrefix]
		private static bool KeyDownPrefix(InputManager __instance, InputKey key, ref bool __result)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			InputManager __instance2 = __instance;
			if (!PatchSafety.Try("InputManager.KeyDown prefix", delegate
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				if ((int)key != 6 || !MenuActionWasPressedThisFrame(__instance2))
				{
					return false;
				}
				return NuageReportPlugin.ReportUi != null && NuageReportPlugin.ReportUi.TryConsumeEscapeMenuInput("InputManager.KeyDown");
			}, fallback: false))
			{
				return true;
			}
			__result = false;
			return false;
		}

		[HarmonyPatch(typeof(InputManager), "FixedUpdate")]
		[HarmonyPostfix]
		private static void FixedUpdatePostfix()
		{
			PatchSafety.Run("InputManager.FixedUpdate", delegate
			{
				NuageReportPlugin.TickSurvivingSystems("InputManager.FixedUpdate");
			});
		}

		private static bool MenuActionWasPressedThisFrame(InputManager inputManager)
		{
			if ((Object)(object)inputManager == (Object)null)
			{
				return false;
			}
			InputAction action = inputManager.GetAction((InputKey)6);
			if (action != null)
			{
				return action.WasPressedThisFrame();
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class RunLifecyclePatches
	{
		[HarmonyPatch(typeof(RoundDirector), "StartRoundLogic")]
		[HarmonyPostfix]
		private static void RoundStarted(RoundDirector __instance, int value)
		{
			RoundDirector __instance2 = __instance;
			PatchSafety.Run("RoundDirector.StartRoundLogic", delegate
			{
				RoundStartedUnsafe(__instance2, value);
			});
		}

		private static void RoundStartedUnsafe(RoundDirector __instance, int value)
		{
			PatchSafety.LogHookHit("RoundDirector.StartRoundLogic", $"value={value}", 10);
			string levelName = CurrentLevelName();
			if (NuageReportPlugin.CanRecord && IsRecordableLevel(levelName))
			{
				NuageReportPlugin.StartRunIfNeeded(levelName);
				NuageReportPlugin.BackfillInitialObjectsIfAvailable("RoundDirector.StartRoundLogic");
			}
		}

		[HarmonyPatch(typeof(RunManager), "ChangeLevel")]
		[HarmonyPrefix]
		private static void LevelChanging(RunManager __instance, ChangeLevelType _changeLevelType)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			RunManager __instance2 = __instance;
			PatchSafety.Run("RunManager.ChangeLevel", delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				LevelChangingUnsafe(__instance2, _changeLevelType);
			});
		}

		private static void LevelChangingUnsafe(RunManager __instance, ChangeLevelType _changeLevelType)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			PatchSafety.LogHookHit("RunManager.ChangeLevel", $"type={_changeLevelType} active={NuageReportPlugin.Recorder.IsActive}", 10);
			if (NuageReportPlugin.Recorder.IsActive && (int)_changeLevelType != 1)
			{
				if ((Object)(object)RoundDirector.instance != (Object)null)
				{
					ValuableLifecyclePatches.RecordExtractedValuables(RoundDirector.instance);
				}
				string levelName = (((Object)(object)__instance?.levelCurrent != (Object)null) ? ((Object)__instance.levelCurrent).name : CurrentLevelName());
				NuageReportPlugin.EndRunIfActive(levelName);
			}
		}

		internal static string? CurrentLevelName()
		{
			return PatchSafety.Try("RunLifecyclePatches.CurrentLevelName", () => (!((Object)(object)RunManager.instance?.levelCurrent != (Object)null)) ? null : ((Object)RunManager.instance.levelCurrent).name, null);
		}

		internal static bool IsRecordableLevel(string? levelName)
		{
			if (string.IsNullOrWhiteSpace(levelName))
			{
				return false;
			}
			string text = levelName.Trim();
			if (text.IndexOf("Lobby", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Shop", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Splash", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Menu", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			return text.StartsWith("Level - ", StringComparison.OrdinalIgnoreCase);
		}
	}
	[HarmonyPatch]
	internal static class ValuableLifecyclePatches
	{
		private enum CashoutCandidateKind
		{
			Valuable,
			EnemyOrb
		}

		private readonly struct CashoutCandidate
		{
			public ValuableRef Valuable { get; }

			public PlayerRef? Player { get; }

			public CashoutCandidateKind Kind { get; }

			public CashoutCandidate(ValuableRef valuable, PlayerRef? player, CashoutCandidateKind kind)
			{
				Valuable = valuable;
				Player = player;
				Kind = kind;
			}
		}

		private static readonly Dictionary<string, CashoutCandidate> PendingCashoutValuables = new Dictionary<string, CashoutCandidate>(StringComparer.Ordinal);

		[HarmonyPatch(typeof(RoundDirector), "PhysGrabObjectAdd")]
		[HarmonyPostfix]
		private static void PhysGrabObjectAdded(PhysGrabObject _physGrabObject)
		{
			RecordPhysGrabObject(_physGrabObject);
		}

		[HarmonyPatch(typeof(ValuableObject), "DollarValueSetLogic")]
		[HarmonyPostfix]
		private static void ValuableValueSet(ValuableObject __instance)
		{
			ValuableObject __instance2 = __instance;
			PatchSafety.Run("ValuableObject.DollarValueSetLogic", delegate
			{
				ValuableValueSetUnsafe(__instance2);
			});
		}

		private static void ValuableValueSetUnsafe(ValuableObject __instance)
		{
			PatchSafety.LogHookHit("ValuableObject.DollarValueSetLogic", $"active={NuageReportPlugin.Recorder.IsActive}", 10);
			if (!CanRecordActive() || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			ValuableRef val = GameObjectRefs.TryCreateEnemyOrbRef(__instance);
			if (val != null)
			{
				NuageReportPlugin.Recorder.TryRecordOrbSpawned(val, EnemyOrbSize(val), RunLifecyclePatches.CurrentLevelName());
				return;
			}
			ValuableRef val2 = GameObjectRefs.TryCreateValuableRef(__instance);
			if (val2 != null)
			{
				NuageReportPlugin.Recorder.TryRecordValuableSpawned(val2, RunLifecyclePatches.CurrentLevelName());
			}
		}

		[HarmonyPatch(typeof(ValuableObject), "Discover")]
		[HarmonyPostfix]
		private static void ValuableDiscovered(ValuableObject __instance, bool __result)
		{
			ValuableObject __instance2 = __instance;
			PatchSafety.Run("ValuableObject.Discover", delegate
			{
				ValuableDiscoveredUnsafe(__instance2, __result);
			});
		}

		private static void ValuableDiscoveredUnsafe(ValuableObject __instance, bool __result)
		{
			if (!__result || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			PatchSafety.LogHookHit("ValuableObject.Discover", $"active={NuageReportPlugin.Recorder.IsActive}", 20);
			if (NuageReportPlugin.EnsureRunActiveFromHook("ValuableObject.Discover"))
			{
				ValuableRef val = GameObjectRefs.TryCreateValuableRef(__instance);
				if (val != null)
				{
					NuageReportPlugin.Recorder.TryRecordValuableDiscovered(val, (PlayerRef)null, (ConfidenceLevel)2, RunLifecyclePatches.CurrentLevelName());
				}
			}
		}

		[HarmonyPatch(typeof(RoundDirector), "ExtractionCompleted")]
		[HarmonyPrefix]
		private static void ExtractionCompleted(RoundDirector __instance)
		{
			RoundDirector __instance2 = __instance;
			PatchSafety.Run("RoundDirector.ExtractionCompleted", delegate
			{
				RecordExtractedValuables(__instance2);
			});
		}

		[HarmonyPatch(typeof(ValuableObject), "AddToDollarHaulList")]
		[HarmonyPostfix]
		private static void ValuableEnteredCashoutZone(ValuableObject __instance)
		{
			ValuableObject __instance2 = __instance;
			PatchSafety.Run("ValuableObject.AddToDollarHaulList", delegate
			{
				ValuableEnteredCashoutZoneUnsafe(__instance2);
			});
		}

		private static void ValuableEnteredCashoutZoneUnsafe(ValuableObject __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			PatchSafety.LogHookHit("ValuableObject.AddToDollarHaulList", $"active={NuageReportPlugin.Recorder.IsActive}", 20);
			if (!NuageReportPlugin.EnsureRunActiveFromHook("ValuableObject.AddToDollarHaulList"))
			{
				return;
			}
			ValuableRef val = GameObjectRefs.TryCreateEnemyOrbRef(__instance);
			if (val != null)
			{
				PendingCashoutValuables[val.RuntimeId] = new CashoutCandidate(val, null, CashoutCandidateKind.EnemyOrb);
				return;
			}
			ValuableRef val2 = GameObjectRefs.TryCreateValuableRef(__instance);
			if (val2 != null)
			{
				PhysGrabObject physGrabObject = GameObjectRefs.ValuablePhysGrabObject(__instance);
				PlayerRef val3 = GameObjectRefs.TryCreatePlayerRef(physGrabObject);
				NuageReportPlugin.Recorder.TryRecordFirstCarted(val2, val3, (ConfidenceLevel)((val3 != null) ? 1 : 2), RunLifecyclePatches.CurrentLevelName());
				PendingCashoutValuables[val2.RuntimeId] = new CashoutCandidate(val2, val3, CashoutCandidateKind.Valuable);
			}
		}

		[HarmonyPatch(typeof(ValuableObject), "RemoveFromDollarHaulList")]
		[HarmonyPostfix]
		private static void ValuableLeftCashoutZone(ValuableObject __instance)
		{
			ValuableObject __instance2 = __instance;
			PatchSafety.Run("ValuableObject.RemoveFromDollarHaulList", delegate
			{
				ValuableLeftCashoutZoneUnsafe(__instance2);
			});
		}

		private static void ValuableLeftCashoutZoneUnsafe(ValuableObject __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				ValuableRef val = GameObjectRefs.TryCreateEnemyOrbRef(__instance) ?? GameObjectRefs.TryCreateValuableRef(__instance);
				if (val != null)
				{
					PendingCashoutValuables.Remove(val.RuntimeId);
				}
			}
		}

		[HarmonyPatch(typeof(PhysGrabObjectImpactDetector), "Break")]
		[HarmonyPostfix]
		private static void ValuableDamaged(PhysGrabObjectImpactDetector __instance, float valueLost)
		{
			PhysGrabObjectImpactDetector __instance2 = __instance;
			PatchSafety.Run("PhysGrabObjectImpactDetector.Break", delegate
			{
				ValuableDamagedUnsafe(__instance2, valueLost);
			});
		}

		private static void ValuableDamagedUnsafe(PhysGrabObjectImpactDetector __instance, float valueLost)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			PatchSafety.LogHookHit("PhysGrabObjectImpactDetector.Break", $"valueLost={valueLost:0.###} active={NuageReportPlugin.Recorder.IsActive}", 20);
			if (!NuageReportPlugin.EnsureRunActiveFromHook("PhysGrabObjectImpactDetector.Break"))
			{
				return;
			}
			ValuableObject val = ((Component)__instance).GetComponent<ValuableObject>() ?? ((Component)__instance).GetComponentInParent<ValuableObject>();
			if (!((Object)(object)val == (Object)null))
			{
				ValuableRef val2 = GameObjectRefs.CreateValuableRef(val);
				if (!GameObjectRefs.IsEnemyOrbValuable(val))
				{
					NuageReportPlugin.Recorder.RecordValuableDamaged(val2, Mathf.RoundToInt(valueLost), RunLifecyclePatches.CurrentLevelName());
				}
			}
		}

		[HarmonyPatch(typeof(PhysGrabObjectImpactDetector), "DestroyObject")]
		[HarmonyPostfix]
		private static void ValuableDestroyed(PhysGrabObjectImpactDetector __instance)
		{
			PhysGrabObjectImpactDetector __instance2 = __instance;
			PatchSafety.Run("PhysGrabObjectImpactDetector.DestroyObject", delegate
			{
				ValuableDestroyedUnsafe(__instance2);
			});
		}

		private static void ValuableDestroyedUnsafe(PhysGrabObjectImpactDetector __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			PatchSafety.LogHookHit("PhysGrabObjectImpactDetector.DestroyObject", $"active={NuageReportPlugin.Recorder.IsActive}", 20);
			if (!NuageReportPlugin.EnsureRunActiveFromHook("PhysGrabObjectImpactDetector.DestroyObject"))
			{
				return;
			}
			ValuableObject val = ((Component)__instance).GetComponent<ValuableObject>() ?? ((Component)__instance).GetComponentInParent<ValuableObject>();
			if (!((Object)(object)val == (Object)null))
			{
				if (GameObjectRefs.IsEnemyOrbValuable(val))
				{
					ValuableRef val2 = GameObjectRefs.CreateValuableOriginalValueRef(val);
					NuageReportPlugin.Recorder.TryRecordOrbDestroyed(val2, EnemyOrbSize(val2), RunLifecyclePatches.CurrentLevelName());
				}
				else
				{
					ValuableRef val3 = GameObjectRefs.CreateValuableRef(val);
					NuageReportPlugin.Recorder.TryRecordValuableDestroyed(val3, RunLifecyclePatches.CurrentLevelName());
				}
			}
		}

		internal static bool RecordPhysGrabObject(PhysGrabObject? physGrabObject)
		{
			PhysGrabObject physGrabObject2 = physGrabObject;
			return PatchSafety.Try("RoundDirector.PhysGrabObjectAdd", () => RecordPhysGrabObjectUnsafe(physGrabObject2), fallback: false);
		}

		private static bool RecordPhysGrabObjectUnsafe(PhysGrabObject? physGrabObject)
		{
			if (!CanRecordActive())
			{
				return false;
			}
			ValuableObject valuableObject = (((Object)(object)physGrabObject == (Object)null) ? null : (((Component)physGrabObject).GetComponent<ValuableObject>() ?? ((Component)physGrabObject).GetComponentInParent<ValuableObject>()));
			ValuableRef val = GameObjectRefs.TryCreateEnemyOrbRef(valuableObject);
			if (val != null)
			{
				return NuageReportPlugin.Recorder.TryRecordOrbSpawned(val, EnemyOrbSize(val), RunLifecyclePatches.CurrentLevelName());
			}
			ValuableRef val2 = GameObjectRefs.TryCreateValuableRef(physGrabObject);
			if (val2 != null)
			{
				return NuageReportPlugin.Recorder.TryRecordValuableSpawned(val2, RunLifecyclePatches.CurrentLevelName());
			}
			return false;
		}

		internal static void RecordExtractedValuables(RoundDirector? roundDirector)
		{
			RoundDirector roundDirector2 = roundDirector;
			PatchSafety.Run("RecordExtractedValuables", delegate
			{
				RecordExtractedValuablesUnsafe(roundDirector2);
			});
		}

		private static void RecordExtractedValuablesUnsafe(RoundDirector? roundDirector)
		{
			PatchSafety.LogHookHit("RecordExtractedValuables", $"active={NuageReportPlugin.Recorder.IsActive}", 20);
			if (!NuageReportPlugin.EnsureRunActiveFromHook("RecordExtractedValuables") || roundDirector?.dollarHaulList == null)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (GameObject dollarHaul in roundDirector.dollarHaulList)
			{
				if ((Object)(object)dollarHaul == (Object)null)
				{
					continue;
				}
				ValuableObject component = dollarHaul.GetComponent<ValuableObject>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				ValuableRef val = GameObjectRefs.TryCreateEnemyOrbRef(component);
				if (val != null)
				{
					hashSet.Add(val.RuntimeId);
					NuageReportPlugin.Recorder.TryRecordOrbExtracted(val, EnemyOrbSize(val), RunLifecyclePatches.CurrentLevelName());
					continue;
				}
				PhysGrabObject physGrabObject = GameObjectRefs.ValuablePhysGrabObject(component);
				PlayerRef val2 = GameObjectRefs.TryCreatePlayerRef(physGrabObject);
				ValuableRef val3 = GameObjectRefs.TryCreateValuableRef(component);
				if (val3 != null)
				{
					hashSet.Add(val3.RuntimeId);
					NuageReportPlugin.Recorder.TryRecordValuableExtracted(val3, val2, (ConfidenceLevel)((val2 != null) ? 1 : 2), RunLifecyclePatches.CurrentLevelName());
				}
			}
			foreach (KeyValuePair<string, CashoutCandidate> pendingCashoutValuable in PendingCashoutValuables)
			{
				if (!hashSet.Contains(pendingCashoutValuable.Key))
				{
					if (pendingCashoutValuable.Value.Kind == CashoutCandidateKind.EnemyOrb)
					{
						NuageReportPlugin.Recorder.TryRecordOrbExtracted(pendingCashoutValuable.Value.Valuable, EnemyOrbSize(pendingCashoutValuable.Value.Valuable), RunLifecyclePatches.CurrentLevelName());
					}
					else
					{
						NuageReportPlugin.Recorder.TryRecordValuableExtracted(pendingCashoutValuable.Value.Valuable, pendingCashoutValuable.Value.Player, (ConfidenceLevel)((pendingCashoutValuable.Value.Player != null) ? 1 : 2), RunLifecyclePatches.CurrentLevelName());
					}
				}
			}
			PendingCashoutValuables.Clear();
		}

		private static bool CanRecordActive()
		{
			if (NuageReportPlugin.CanRecord)
			{
				return NuageReportPlugin.Recorder.IsActive;
			}
			return false;
		}

		private static string? EnemyOrbSize(ValuableRef valuable)
		{
			string text = "Enemy Valuable - ";
			if (!valuable.Name.StartsWith(text, StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			return valuable.Name.Substring(text.Length).Trim();
		}
	}
}
namespace NuageReport.Plugin.Networking
{
	internal sealed class ReportSyncService
	{
		private readonly struct ReceivedSnapshotState
		{
			public string ContentHash { get; }

			public DateTimeOffset GeneratedAtUtc { get; }

			public ReceivedSnapshotState(string contentHash, DateTimeOffset generatedAtUtc)
			{
				ContentHash = contentHash;
				GeneratedAtUtc = generatedAtUtc;
			}
		}

		private readonly struct SentSnapshotState
		{
			public string ContentHash { get; }

			public DateTimeOffset SentAtUtc { get; }

			public SentSnapshotState(string contentHash, DateTimeOffset sentAtUtc)
			{
				ContentHash = contentHash;
				SentAtUtc = sentAtUtc;
			}
		}

		private const byte SyncEventCode = 173;

		private const string ProtocolKey = "protocol";

		private const string ProtocolValue = "com.theohay.nuagereport";

		private const string MessageTypeKey = "messageType";

		private const string MessageFinal = "final";

		private const string MessageLive = "live";

		private const string MessageRequest = "request";

		private const string RequestIncludeFinalKey = "includeFinal";

		private const string RequestIncludeLiveKey = "includeLive";

		private const int MaxSharedSnapshotPayloadBytes = 65536;

		private const double OutgoingRequestIntervalSeconds = 2.0;

		private const double RequestedSnapshotResendIntervalSeconds = 10.0;

		private readonly Dictionary<string, ReceivedSnapshotState> _receivedSnapshots = new Dictionary<string, ReceivedSnapshotState>(StringComparer.Ordinal);

		private readonly Dictionary<string, SentSnapshotState> _requestedSnapshotResponses = new Dictionary<string, SentSnapshotState>(StringComparer.Ordinal);

		private readonly Dictionary<string, DateTimeOffset> _sentRequests = new Dictionary<string, DateTimeOffset>(StringComparer.Ordinal);

		private string? _lastPublishedFinalHash;

		private string? _lastPublishedLiveHash;

		private LoadBalancingClient? _subscribedClient;

		private bool _isSubscribed;

		public ReportSnapshot? LatestFinalReport { get; private set; }

		public ReportSnapshot? LatestLiveReport { get; private set; }

		public bool IsRoomReady => CanUseNetwork();

		public event Action<ReportSnapshot>? FinalReportReceived;

		public event Action<ReportSnapshot>? LiveReportReceived;

		public void EnsureSubscribed()
		{
			if (!CanUseNetwork())
			{
				Dispose();
				return;
			}
			if (_isSubscribed)
			{
				if (_subscribedClient == PhotonNetwork.NetworkingClient)
				{
					return;
				}
				Dispose();
			}
			LoadBalancingClient networkingClient = PhotonNetwork.NetworkingClient;
			if (networkingClient != null)
			{
				networkingClient.EventReceived += HandlePhotonEvent;
				_subscribedClient = networkingClient;
				_isSubscribed = true;
				NuageReportPlugin.Log.LogInfo((object)$"Report sync initialized. PhotonEventCode={(byte)173}.");
			}
		}

		public void Dispose()
		{
			if (_isSubscribed)
			{
				if (_subscribedClient != null)
				{
					_subscribedClient.EventReceived -= HandlePhotonEvent;
				}
				_subscribedClient = null;
				_isSubscribed = false;
			}
		}

		public void PublishFinalReport(ReportSnapshot snapshot)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null)
			{
				throw new ArgumentNullException("snapshot");
			}
			LatestFinalReport = snapshot;
			if (CanShare() && HostAuthority.IsAuthoritativeHost() && CanUseNetwork())
			{
				EnsureSubscribed();
				if (ShouldPublishChanged(snapshot, ref _lastPublishedFinalHash))
				{
					RaiseReportSnapshot(snapshot, "final", RaiseOthers(), SendOptions.SendReliable);
				}
			}
		}

		public void PublishLiveReport(ReportSnapshot snapshot)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null)
			{
				throw new ArgumentNullException("snapshot");
			}
			LatestLiveReport = snapshot;
			if (CanShare() && PluginConfig.Instance.ShouldShareLiveReport() && HostAuthority.IsAuthoritativeHost() && CanUseNetwork())
			{
				EnsureSubscribed();
				if (ShouldPublishChanged(snapshot, ref _lastPublishedLiveHash))
				{
					RaiseReportSnapshot(snapshot, "live", RaiseOthers(), SendOptions.SendUnreliable);
				}
			}
		}

		public void RequestLatestReport()
		{
			RequestLatestReport(includeFinalReport: true, includeLiveReport: true);
		}

		public void RequestLatestReport(bool includeFinalReport, bool includeLiveReport)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (CanShare() && CanUseNetwork())
			{
				EnsureSubscribed();
				if ((includeFinalReport || includeLiveReport) && ShouldSendRequest(includeFinalReport, includeLiveReport))
				{
					Hashtable table = new Hashtable
					{
						[(object)"protocol"] = "com.theohay.nuagereport",
						[(object)"messageType"] = "request",
						[(object)"includeFinal"] = includeFinalReport,
						[(object)"includeLive"] = includeLiveReport
					};
					PatchSafety.LogHookHit("ReportSyncService.RequestLatestReport", $"final={includeFinalReport} live={includeLiveReport}", 10);
					Raise(table, RaiseMasterClient(), SendOptions.SendReliable);
				}
			}
		}

		private void HandlePhotonEvent(EventData eventData)
		{
			if (eventData.Code != 173)
			{
				return;
			}
			object customData = eventData.CustomData;
			Hashtable val = (Hashtable)((customData is Hashtable) ? customData : null);
			if (val == null)
			{
				return;
			}
			string x = ReadString(val, "protocol");
			if (StringComparer.Ordinal.Equals(x, "com.theohay.nuagereport"))
			{
				string text = ReadString(val, "messageType");
				switch (text)
				{
				case "final":
					HandleFinalReportSync(val);
					break;
				case "live":
					HandleLiveReportSync(val);
					break;
				case "request":
					HandleRequestLatestReport(eventData.Sender, val);
					break;
				default:
					NuageReportPlugin.Log.LogWarning((object)("Received unknown NuageReport sync message type: " + (text ?? "null") + "."));
					break;
				}
			}
		}

		private void HandleFinalReportSync(Hashtable table)
		{
			Hashtable table2 = table;
			PatchSafety.Run("ReportSyncService.FinalReportSync", delegate
			{
				if (!ReportSnapshot.TryFromHashtable(table2, out ReportSnapshot snapshot) || snapshot == null)
				{
					NuageReportPlugin.Log.LogWarning((object)"Received malformed NuageReport final report sync payload.");
				}
				else if (TryAcceptIncomingSnapshot(snapshot))
				{
					LatestFinalReport = snapshot;
					this.FinalReportReceived?.Invoke(snapshot);
				}
			});
		}

		private void HandleLiveReportSync(Hashtable table)
		{
			Hashtable table2 = table;
			PatchSafety.Run("ReportSyncService.LiveReportSync", delegate
			{
				if (!ReportSnapshot.TryFromHashtable(table2, out ReportSnapshot snapshot) || snapshot == null)
				{
					NuageReportPlugin.Log.LogWarning((object)"Received malformed NuageReport live report sync payload.");
				}
				else if (TryAcceptIncomingSnapshot(snapshot))
				{
					LatestLiveReport = snapshot;
					if (PluginConfig.Instance.IsLiveReportEnabled())
					{
						this.LiveReportReceived?.Invoke(snapshot);
					}
				}
			});
		}

		private void HandleRequestLatestReport(int sender, Hashtable request)
		{
			Hashtable request2 = request;
			PatchSafety.Run("ReportSyncService.RequestLatestReport", delegate
			{
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				if (CanShare() && HostAuthority.IsAuthoritativeHost() && CanUseNetwork())
				{
					ReadRequestKinds(request2, out var includeFinalReport, out var includeLiveReport);
					RaiseEventOptions target = TargetForSender(sender);
					PatchSafety.LogHookHit("ReportSyncService.HandleRequestLatestReport", $"sender={sender} final={includeFinalReport} live={includeLiveReport} hasFinal={LatestFinalReport != null} hasLive={LatestLiveReport != null}", 20);
					if (includeFinalReport && LatestFinalReport != null && ShouldSendRequestedSnapshot(sender, "final", LatestFinalReport))
					{
						RaiseReportSnapshot(LatestFinalReport, "final", target, SendOptions.SendReliable);
					}
					if (includeLiveReport && LatestLiveReport != null && PluginConfig.Instance.ShouldShareLiveReport() && ShouldSendRequestedSnapshot(sender, "live", LatestLiveReport))
					{
						RaiseReportSnapshot(LatestLiveReport, "live", target, SendOptions.SendReliable);
					}
				}
			});
		}

		private static void RaiseReportSnapshot(ReportSnapshot snapshot, string messageType, RaiseEventOptions target, SendOptions sendOptions)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			int num = EstimatePayloadBytes(snapshot);
			if (num > 65536)
			{
				NuageReportPlugin.Log.LogWarning((object)("Skipped NuageReport " + messageType + " sync because the payload is too large. " + $"bytes={num} max={65536} runId={snapshot.RunId}"));
				return;
			}
			Hashtable val = snapshot.ToHashtable();
			val[(object)"protocol"] = "com.theohay.nuagereport";
			val[(object)"messageType"] = messageType;
			PatchSafety.LogHookHit("ReportSyncService.RaiseReportSnapshot", string.Format("type={0} runId={1} level={2} bytes={3} reliable={4}", messageType, snapshot.RunId, snapshot.LevelName ?? "unknown", num, ((SendOptions)(ref sendOptions)).Reliability), 20);
			Raise(val, target, sendOptions);
		}

		private static void Raise(Hashtable table, RaiseEventOptions target, SendOptions sendOptions)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			PhotonNetwork.RaiseEvent((byte)173, (object)table, target, sendOptions);
		}

		private static RaiseEventOptions TargetForSender(int sender)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			if (sender > 0)
			{
				RaiseEventOptions val = new RaiseEventOptions();
				val.TargetActors = new int[1] { sender };
				return val;
			}
			return RaiseOthers();
		}

		private static RaiseEventOptions RaiseOthers()
		{
			//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)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			return new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)0
			};
		}

		private static RaiseEventOptions RaiseMasterClient()
		{
			//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)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			return new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)2
			};
		}

		private static void ReadRequestKinds(object? customData, out bool includeFinalReport, out bool includeLiveReport)
		{
			includeFinalReport = true;
			includeLiveReport = true;
			Hashtable val = (Hashtable)((customData is Hashtable) ? customData : null);
			if (val != null)
			{
				includeFinalReport = ReadBool(val, "includeFinal", defaultValue: true);
				includeLiveReport = ReadBool(val, "includeLive", defaultValue: true);
			}
		}

		private static bool ReadBool(Hashtable table, string key, bool defaultValue)
		{
			if (!((Dictionary<object, object>)(object)table).TryGetValue((object)key, out object value))
			{
				return defaultValue;
			}
			if (value is bool)
			{
				return (bool)value;
			}
			return defaultValue;
		}

		private bool TryAcceptIncomingSnapshot(ReportSnapshot snapshot)
		{
			string key = snapshot.ReportKind.ToString() + ":" + snapshot.RunId;
			if (_receivedSnapshots.TryGetValue(key, out var value))
			{
				if (StringComparer.Ordinal.Equals(value.ContentHash, snapshot.ContentHash) || snapshot.GeneratedAtUtc < value.GeneratedAtUtc)
				{
					return false;
				}
				_receivedSnapshots[key] = new ReceivedSnapshotState(snapshot.ContentHash, snapshot.GeneratedAtUtc);
				return true;
			}
			_receivedSnapshots.Add(key, new ReceivedSnapshotState(snapshot.ContentHash, snapshot.GeneratedAtUtc));
			return true;
		}

		private static bool ShouldPublishChanged(ReportSnapshot snapshot, ref string? lastPublishedHash)
		{
			if (StringComparer.Ordinal.Equals(lastPublishedHash, snapshot.ContentHash))
			{
				return false;
			}
			lastPublishedHash = snapshot.ContentHash;
			return true;
		}

		private bool ShouldSendRequest(bool includeFinalReport, bool includeLiveReport)
		{
			string key = includeFinalReport + ":" + includeLiveReport;
			DateTimeOffset utcNow = DateTimeOffset.UtcNow;
			if (_sentRequests.TryGetValue(key, out var value) && utcNow - value < TimeSpan.FromSeconds(2.0))
			{
				PatchSafety.LogHookHit("ReportSyncService.SkipRequestLatestReport", $"final={includeFinalReport} live={includeLiveReport}", 20);
				return false;
			}
			_sentRequests[key] = utcNow;
			return true;
		}

		private bool ShouldSendRequestedSnapshot(int sender, string messageType, ReportSnapshot snapshot)
		{
			string key = sender.ToString(CultureInfo.InvariantCulture) + ":" + messageType;
			DateTimeOffset utcNow = DateTimeOffset.UtcNow;
			if (_requestedSnapshotResponses.TryGetValue(key, out var value) && StringComparer.Ordinal.Equals(value.ContentHash, snapshot.ContentHash) && utcNow - value.SentAtUtc < TimeSpan.FromSeconds(10.0))
			{
				PatchSafety.LogHookHit("ReportSyncService.SkipRequestedSnapshot", $"sender={sender} type={messageType} runId={snapshot.RunId}", 20);
				return false;
			}
			_requestedSnapshotResponses[key] = new SentSnapshotState(snapshot.ContentHash, utcNow);
			return true;
		}

		private static int EstimatePayloadBytes(ReportSnapshot snapshot)
		{
			int num = 512;
			num += Encoding.UTF8.GetByteCount(snapshot.ModVersion);
			num += Encoding.UTF8.GetByteCount(snapshot.RunId);
			num += Encoding.UTF8.GetByteCount(snapshot.LevelName ?? string.Empty);
			num += Encoding.UTF8.GetByteCount(snapshot.JsonPayload);
			num += Encoding.UTF8.GetByteCount(snapshot.DisplayText);
			return num + Encoding.UTF8.GetByteCount(snapshot.ContentHash);
		}

		private static bool CanShare()
		{
			return PluginConfig.Instance.ShouldShareReports();
		}

		private static bool CanUseNetwork()
		{
			if (PhotonNetwork.NetworkingClient != null)
			{
				return PhotonNetwork.InRoom;
			}
			return false;
		}

		private static string? ReadString(Hashtable table, string key)
		{
			if (!((Dictionary<object, object>)(object)table).TryGetValue((object)key, out object value))
			{
				return null;
			}
			return value as string;
		}
	}
}
namespace NuageReport.Plugin.Infrastructure
{
	internal static class GameAccess
	{
		private static readonly Dictionary<string, FieldInfo?> FieldCache = new Dictionary<string, FieldInfo>(StringComparer.Ordinal);

		public static T? Field<T>(object? instance, string fieldName) where T : class
		{
			return RawField(instance, fieldName) as T;
		}

		public static int IntField(object? instance, string fieldName, int fallback = 0)
		{
			object obj = RawField(instance, fieldName);
			if (obj is int)
			{
				return (int)obj;
			}
			return fallback;
		}

		public static float FloatField(object? instance, string fieldName, float fallback = 0f)
		{
			object obj = RawField(instance, fieldName);
			if (obj is float)
			{
				return (float)obj;
			}
			return fallback;
		}

		public static bool BoolField(object? instance, string fieldName, bool fallback = false)
		{
			object obj = RawField(instance, fieldName);
			if (obj is bool)
			{
				return (bool)obj;
			}
			return fallback;
		}

		public static void SetFloatFieldAtLeast(object? instance, string fieldName, float minimumValue)
		{
			if (instance == null || string.IsNullOrWhiteSpace(fieldName))
			{
				return;
			}
			try
			{
				FieldInfo fieldInfo = FindField(instance.GetType(), fieldName);
				if (!(fieldInfo == null) && !(fieldInfo.FieldType != typeof(float)))
				{
					float num2 = ((fieldInfo.GetValue(instance) is float num) ? num : 0f);
					if (num2 < minimumValue)
					{
						fieldInfo.SetValue(instance, minimumValue);
					}
				}
			}
			catch (Exception ex)
			{
				PatchSafety.LogHookHit("GameAccess.FieldWriteFailed", instance.GetType().Name + "." + fieldName + ": " + ex.GetType().Name, 20);
			}
		}

		public static string? StringField(object? instance, string fieldName)
		{
			return RawField(instance, fieldName) as string;
		}

		public static string EnumText(object? instance, string fieldName)
		{
			object obj = RawField(instance, fieldName);
			if (obj != null)
			{
				return obj.ToString();
			}
			return string.Empty;
		}

		private static object? RawField(object? instance, string fieldName)
		{
			if (instance == null || string.IsNullOrWhiteSpace(fieldName))
			{
				return null;
			}
			try
			{
				FieldInfo fieldInfo = FindField(instance.GetType(), fieldName);
				return (fieldInfo == null) ? null : fieldInfo.GetValue(instance);
			}
			catch (Exception ex)
			{
				PatchSafety.LogHookHit("GameAccess.FieldReadFailed", instance.GetType().Name + "." + fieldName + ": " + ex.GetType().Name, 20);
				return null;
			}
		}

		private static FieldInfo? FindField(Type type, string fieldName)
		{
			string key = type.FullName + ":" + fieldName;
			if (FieldCache.TryGetValue(key, out FieldInfo value))
			{
				return value;
			}
			Type type2 = type;
			while (type2 != null)
			{
				FieldInfo field = type2.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					FieldCache[key] = field;
					return field;
				}
				type2 = type2.BaseType;
			}
			FieldCache[key] = null;
			return null;
		}
	}
	internal static class GameObjectRefs
	{
		public static ValuableRef? TryCreateValuableRef(PhysGrabObject? physGrabObject)
		{
			if ((Object)(object)physGrabObject == (Object)null)
			{
				return null;
			}
			ValuableObject valuableObject = ((Component)physGrabObject).GetComponent<ValuableObject>() ?? ((Component)physGrabObject).GetComponentInParent<ValuableObject>();
			return TryCreateValuableRef(valuableObject);
		}

		public static ValuableRef? TryCreateValuableRef(ValuableObject? valuableObject)
		{
			if ((Object)(object)valuableObject == (Object)null)
			{
				return null;
			}
			string name = CleanName((Object)(object)((Component)valuableObject).gameObject);
			if (!IsMapStatExcludedValuableName(name))
			{
				return CreateValuableRef(valuableObject, name);
			}
			return null;
		}

		public static ValuableRef? TryCreateEnemyOrbRef(ValuableObject? valuableObject)
		{
			if ((Object)(object)valuableObject == (Object)null)
			{
				return null;
			}
			string name = CleanName((Object)(object)((Component)valuableObject).gameObject);
			if (!IsEnemyOrbValuableName(name))
			{
				return null;
			}
			return CreateValuableRef(valuableObject, name);
		}

		public static ValuableRef CreateValuableRef(ValuableObject valuableObject)
		{
			return CreateValuableRef(valuableObject, CleanName((Object)(object)((Component)valuableObject).gameObject));
		}

		public static ValuableRef CreateValuableOriginalValueRef(ValuableObject valuableObject)
		{
			return CreateValuableRef(valuableObject, CleanName((Object)(object)((Component)valuableObject).gameObject), useOriginalValue: true);
		}

		private static ValuableRef CreateValuableRef(ValuableObject valuableObject, string name)
		{
			return CreateValuableRef(valuableObject, name, useOriginalValue: false);
		}

		private static ValuableRef CreateValuableRef(ValuableObject valuableObject, string name, bool useOriginalValue)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			PhysGrabObject physGrabObject = ValuablePhysGrabObject(valuableObject);
			string text = RuntimeId(((Component)valuableObject).gameObject, "valuable");
			string fieldName = (useOriginalValue ? "dollarValueOriginal" : "dollarValueCurrent");
			float num = GameAccess.FloatField(valuableObject, fieldName);
			if (num <= 0f && useOriginalValue)
			{
				num = GameAccess.FloatField(valuableObject, "dollarValueCurrent");
			}
			int value = Mathf.Max(0, Mathf.RoundToInt(num));
			float? num2 = Weight(physGrabObject);
			return new ValuableRef(text, name, (int?)value, num2);
		}

		public static ValuableRef CreateOrbRef(CosmeticWorldObject orb)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			return new ValuableRef(RuntimeId(((Component)orb).gameObject, "orb"), CleanName((Object)(object)((Component)orb).gameObject), (int?)null, Weight(GameAccess.Field<PhysGrabObject>(orb, "physGrabObject")));
		}

		public static ValuableRef CreateCosmeticObjectRef(CosmeticWorldObject cosmeticObject)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			return new ValuableRef(RuntimeId(((Component)cosmeticObject).gameObject, "cosmetic"), CleanName((Object)(object)((Component)cosmeticObject).gameObject), (int?)null, Weight(GameAccess.Field<PhysGrabObject>(cosmeticObject, "physGrabObject")));
		}

		public static PlayerRef? TryCreatePlayerRef(PlayerAvatar? playerAvatar)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			if ((Object)(object)playerAvatar == (Object)null)
			{
				return null;
			}
			string text = GameAccess.StringField(playerAvatar, "steamID");
			string text2 = GameAccess.StringField(playerAvatar, "playerName");
			string text3 = ((!string.IsNullOrWhiteSpace(text)) ? text : RuntimeId(((Component)playerAvatar).gameObject, "player"));
			string text4 = ((!string.IsNullOrWhiteSpace(text2)) ? text2 : text3);
			return new PlayerRef(text3, text4);
		}

		public static PlayerRef? TryCreatePlayerRef(PlayerHealth? playerHealth)
		{
			if ((Object)(object)playerHealth == (Object)null)
			{
				return null;
			}
			PlayerAvatar playerAvatar = ((Component)playerHealth).GetComponent<PlayerAvatar>() ?? ((Component)playerHealth).GetComponentInParent<PlayerAvatar>();
			return TryCreatePlayerRef(playerAvatar);
		}

		public static string MonsterRuntimeId(EnemyHealth enemyHealth)
		{
			Enemy val = GameAccess.Field<Enemy>(enemyHealth, "enemy");
			EnemyParent val2 = (((Object)(object)val == (Object)null) ? null : GameAccess.Field<EnemyParent>(val, "EnemyParent"));
			if ((Object)(object)val2 != (Object)null)
			{
				return RuntimeId(((Component)val2).gameObject, "monster");
			}
			if ((Object)(object)val != (Object)null)
			{
				return RuntimeId(((Component)val).gameObject, "monster");
			}
			return RuntimeId((Component)(object)enemyHealth, "monster");
		}

		public static string MonsterName(EnemyHealth enemyHealth)
		{
			Enemy val = GameAccess.Field<Enemy>(enemyHealth, "enemy");
			EnemyParent val2 = (((Object)(object)val == (Object)null) ? null : GameAccess.Field<EnemyParent>(val, "EnemyParent"));
			if ((Object)(object)val2 != (Object)null)
			{
				string text = GameAccess.StringField(val2, "enemyName");
				if (!string.IsNullOrWhiteSpace(text))
				{
					return text;
				}
				return CleanName((Object)(object)((Component)val2).gameObject);
			}
			if (!((Object)(object)val != (Object)null))
			{
				return CleanName((Object)(object)((Component)enemyHealth).gameObject);
			}
			return CleanName((Object)(object)((Component)val).gameObject);
		}

		public static PlayerRef? TryCreatePlayerRef(PhysGrabObject? physGrabObject)
		{
			if (!((Object)(object)physGrabObject == (Object)null))
			{
				return TryCreatePlayerRef(GameAccess.Field<PlayerAvatar>(physGrabObject, "lastPlayerGrabbing"));
			}
			return null;
		}

		public static PhysGrabObject ValuablePhysGrabObject(ValuableObject valuableObject)
		{
			return GameAccess.Field<PhysGrabObject>(valuableObject, "physGrabObject") ?? ((Component)valuableObject).GetComponent<PhysGrabObject>();
		}

		public static string RuntimeId(Component component, string prefix)
		{
			return RuntimeId(component.gameObject, prefix);
		}

		public static string RuntimeId(GameObject gameObject, string prefix)
		{
			PhotonView val = gameObject.GetComponent<PhotonView>() ?? gameObject.GetComponentInParent<PhotonView>();
			if ((Object)(object)val != (Object)null && val.ViewID > 0)
			{
				return $"{prefix}:photon:{val.ViewID}";
			}
			return $"{prefix}:unity:{((Object)gameObject).GetInstanceID()}";
		}

		public static string CleanName(Object unityObject)
		{
			if (!(unityObject == (Object)null))
			{
				return unityObject.name.Replace("(Clone)", string.Empty).Trim();
			}
			return "unknown";
		}

		public static bool IsEnemyOrbValuable(ValuableObject valuableObject)
		{
			if ((Object)(object)valuableObject != (Object)null)
			{
				return IsEnemyOrbValuableName(CleanName((Object)(object)((Component)valuableObject).gameObject));
			}
			return false;
		}

		public static bool IsCashoutSurplusValuable(ValuableObject valuableObject)
		{
			if ((Object)(object)valuableObject != (Object)null)
			{
				return IsCashoutSurplusValuableName(CleanName((Object)(object)((Component)valuableObject).gameObject));
			}
			return false;
		}

		private static bool IsMapStatExcludedValuableName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			if (!IsEnemyOrbValuableName(name))
			{
				return IsCashoutSurplusValuableName(name);
			}
			return true;
		}

		private static bool IsEnemyOrbValuableName(string name)
		{
			return name.StartsWith("Enemy Valuable", StringComparison.OrdinalIgnoreCase);
		}

		private static bool IsCashoutSurplusValuableName(string name)
		{
			return name.StartsWith("Surplus Valuable", StringComparison.OrdinalIgnoreCase);
		}

		private static float? Weight(PhysGrabObject? physGrabObject)
		{
			if ((Object)(object)physGrabObject == (Object)null)
			{
				return null;
			}
			float num = GameAccess.FloatField(physGrabObject, "massOriginal");
			if (num > 0f)
			{
				return num;
			}
			Rigidbody val = GameAccess.Field<Rigidbody>(physGrabObject, "rb");
			if (!((Object)(object)val != (Object)null) || !(val.mass > 0f))
			{
				return null;
			}
			return val.mass;
		}
	}
	internal static class HostAuthority
	{
		public static bool IsAuthoritativeHost()
		{
			if ((Object)(object)GameManager.instance == (Object)null)
			{
				return false;
			}
			return SemiFunc.IsMasterClientOrSingleplayer();
		}
	}
	internal static class PatchSafety
	{
		private static readonly object SyncRoot = new object();

		private static readonly HashSet<string> WarnedHooks = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Dictionary<string, int> HookHitCounts = new Dictionary<string, int>(StringComparer.Ordinal);

		public static void Run(string hookName, Action action)
		{
			if (action == null)
			{
				return;
			}
			try
			{
				action();
			}
			catch (Exception ex)
			{
				LogException(hookName, ex);
			}
		}

		public static T Try<T>(string hookName, Func<T> action, T fallback)
		{
			if (action == null)
			{
				return fallback;
			}
			try
			{
				return action();
			}
			catch (Exception ex)
			{
				LogException(hookName, ex);
				return fallback;
			}
		}

		public static void LogHookHit(string hookName, string? detail = null, int maxLogs = 5)
		{
			if (!ShouldLogHookHits())
			{
				return;
			}
			int value;
			lock (SyncRoot)
			{
				HookHitCounts.TryGetValue(hookName, out value);
				value++;
				HookHitCounts[hookName] = value;
			}
			if (value > maxLogs)
			{
				return;
			}
			string arg = (string.IsNullOrWhiteSpace(detail) ? string.Empty : (" " + detail));
			ManualLogSource log = NuageReportPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"Hook hit {hookName} #{value}.{arg}");
			}
			if (value == maxLogs)
			{
				ManualLogSource log2 = NuageReportPlugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)("Further hook-hit logs for " + hookName + " are suppressed."));
				}
			}
		}

		private static void LogException(string hookName, Exception ex)
		{
			bool flag;
			lock (SyncRoot)
			{
				flag = WarnedHooks.Add(hookName);
			}
			try
			{
				if (flag)
				{
					ManualLogSource log = NuageReportPlugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("Hook '" + hookName + "' failed and was skipped so the game can keep running. " + $"Repeated failures for this hook are suppressed unless Diagnostics.VerboseLogging is enabled. {ex}"));
					}
				}
				else if (IsVerboseLoggingEnabled())
				{
					ManualLogSource log2 = NuageReportPlugin.Log;
					if (log2 != null)
					{
						log2.LogDebug((object)$"Hook '{hookName}' failed again and was skipped: {ex}");
					}
				}
			}
			catch
			{
			}
		}

		private static bool IsVerboseLoggingEnabled()
		{
			try
			{
				return PluginConfig.Instance.VerboseLogging != null && PluginConfig.Instance.VerboseLogging.Value;
			}
			catch
			{
				return false;
			}
		}

		private static bool ShouldLogHookHits()
		{
			try
			{
				return PluginConfig.Instance.LogHookHits == null || PluginConfig.Instance.LogHookHits.Value;
			}
			catch
			{
				return true;
			}
		}
	}
	internal static class PluginPaths
	{
		public static string RootDirectory { get; private set; } = string.Empty;


		public static string ReportsDirectory { get; private set; } = string.Empty;


		public static string StartupMarkerPath { get; private set; } = string.Empty;


		public static void Initialize(string pluginName)
		{
			string path = (string.IsNullOrWhiteSpace(pluginName) ? "NuageReport" : pluginName);
			RootDirectory = Path.Combine(UserDataRoot(), path);
			ReportsDirectory = Path.Combine(RootDirectory, "runs");
			StartupMarkerPath = Path.Combine(RootDirectory, "last-startup.txt");
			Directory.CreateDirectory(ReportsDirectory);
		}

		private static string UserDataRoot()
		{
			string persistentDataPath = Application.persistentDataPath;
			if (!string.IsNullOrWhiteSpace(persistentDataPath))
			{
				return persistentDataPath;
			}
			string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
			if (!string.IsNullOrWhiteSpace(folderPath))
			{
				return folderPath;
			}
			return Path.Combine(Path.GetTempPath(), "NuageReport");
		}
	}
	internal sealed class PollingRecorder
	{
		private float _nextPollAt;

		private string? _lastLevelName;

		private string? _lastIgnoredNonRunLevelName;

		private bool _sawRoundDirector;

		private int _lastExtractionPointsCompleted;

		public void Tick(bool force = false)
		{
			if (force || !(Time.unscaledTime < _nextPollAt))
			{
				_nextPollAt = Time.unscaledTime + 0.5f;
				PatchSafety.Run("PollingRecorder.Tick", Poll);
			}
		}

		private void Poll()
		{
			string text = RunLifecyclePatches.CurrentLevelName();
			if (_lastLevelName != text)
			{
				NuageReportPlugin.LogVerbose(string.Format("Polling fallback noticed level change. level={0} active={1}", text ?? "unknown", NuageReportPlugin.Recorder.IsActive));
				_lastLevelName = text;
			}
			RoundDirector instance = RoundDirector.instance;
			if ((Object)(object)instance == (Object)null)
			{
				if (_sawRoundDirector && NuageReportPlugin.Recorder.IsActive)
				{
					NuageReportPlugin.LogVerbose("Polling fallback saw RoundDirector disappear; ending active run.");
					NuageReportPlugin.EndRunIfActive(text);
				}
				_sawRoundDirector = false;
				_lastExtractionPointsCompleted = 0;
				return;
			}
			if (!RunLifecyclePatches.IsRecordableLevel(text))
			{
				if (_lastIgnoredNonRunLevelName != text)
				{
					NuageReportPlugin.LogVerbose("Polling fallback ignored non-run level: " + (text ?? "unknown") + ".");
					_lastIgnoredNonRunLevelName = text;
				}
				if (!string.IsNullOrWhiteSpace(text) && NuageReportPlugin.Recorder.IsActive)
				{
					NuageReportPlugin.LogVerbose("Polling fallback reached a non-run level while a run was active; ending the active run without using the non-run level name.");
					NuageReportPlugin.EndRunIfActive(null);
				}
				_sawRoundDirector = false;
				_lastExtractionPointsCompleted = 0;
				return;
			}
			if (!_sawRoundDirector)
			{
				_lastIgnoredNonRunLevelName = null;
				_sawRoundDirector = true;
				_lastExtractionPointsCompleted = GameAccess.IntField(instance, "extractionPointsCompleted");
				NuageReportPlugin.LogVerbose("Polling fallback saw RoundDirector. level=" + (text ?? "unknown") + " " + string.Format("physGrabObjects={0} ", Count(GameAccess.Field<List<PhysGrabObject>>(instance, "physGrabObjects"))) + $"dollarHaul={Count(instance.dollarHaulList)}");
			}
			if (NuageReportPlugin.EnsureRunActiveFromHook("PollingRecorder.RoundDirector"))
			{
				NuageReportPlugin.BackfillInitialObjectsIfAvailable("PollingRecorder");
				int num = PollValuables(instance);
				num += PollCarts();
				num += PollCashout(instance);
				if (num > 0)
				{
					NuageReportPlugin.LogVerbose(string.Format("Polling fallback recorded {0} new event(s). level={1}.", num, text ?? "unknown"));
				}
				int num2 = GameAccess.IntField(instance, "extractionPointsCompleted");
				if (num2 > _lastExtractionPointsCompleted)
				{
					NuageReportPlugin.LogVerbose($"Polling fallback noticed extraction progress. from={_lastExtractionPointsCompleted} to={num2}.");
					ValuableLifecyclePatches.RecordExtractedValuables(instance);
				}
				_lastExtractionPointsCompleted = num2;
			}
		}

		private static int PollValuables(RoundDirector roundDirector)
		{
			int num = 0;
			List<PhysGrabObject> list = GameAccess.Field<List<PhysGrabObject>>(roundDirector, "physGrabObjects");
			if (list == null)
			{
				return num;
			}
			foreach (PhysGrabObject item in list)
			{
				ValuableObject val = ((Component)item).GetComponent<ValuableObject>() ?? ((Component)item).GetComponentInParent<ValuableObject>();
				ValuableRef val2 = GameObjectRefs.TryCreateEnemyOrbRef(val);
				if (val2 != null)
				{
					if (NuageReportPlugin.Recorder.TryRecordOrbSpawned(val2, EnemyOrbSize(val2), RunLifecyclePatches.CurrentLevelName()))
					{
						num++;
					}
					continue;
				}
				ValuableRef val3 = GameObjectRefs.TryCreateValuableRef(val);
				if (val3 != null)
				{
					if (NuageReportPlugin.Recorder.TryRecordValuableSpawned(val3, RunLifecyclePatches.CurrentLevelName()))
					{
						num++;
					}
					if ((Object)(object)val != (Object)null && GameAccess.BoolField(val, "discovered") && NuageReportPlugin.Recorder.TryRecordValuableDiscovered(val3, (PlayerRef)null, (ConfidenceLevel)2, RunLifecyclePatches.CurrentLevelName()))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static int PollCarts()
		{
			int num = 0;
			PhysGrabCart[] array = Object.FindObjectsOfType<PhysGrabCart>();
			PhysGrabCart[] array2 = array;
			foreach (PhysGrabCart cart in array2)
			{
				num += CartDetectionPatches.RecordObjectsInCartFromPolling(cart);
			}
			return num;
		}

		private static int PollCashout(RoundDirector roundDirector)
		{
			int num = 0;
			if (roundDirector.dollarHaulList == null || roundDirector.dollarHaulList.Count == 0)
			{
				return num;
			}
			foreach (GameObject dollarHaul in roundDirector.dollarHaulList)
			{
				if ((Object)(object)dollarHaul == (Object)null)
				{
					continue;
				}
				ValuableObject component = dollarHaul.GetComponent<ValuableObject>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				ValuableRef val = GameObjectRefs.TryCreateEnemyOrbRef(component);
				if (val != null)
				{
					if (NuageReportPlugin.Recorder.TryRecordOrbExtracted(val, EnemyOrbSize(val), RunLifecyclePatches.CurrentLevelName()))
					{
						num++;
					}
					continue;
				}
				PhysGrabObject physGrabObject = GameObjectRefs.ValuablePhysGrabObject(component);
				PlayerRef val2 = GameObjectRefs.TryCreatePlayerRef(physGrabObject);
				ValuableRef val3 = GameObjectRefs.TryCreateValuableRef(component);
				if (val3 != null && NuageReportPlugin.Recorder.TryRecordFirstCarted(val3, val2, (ConfidenceLevel)((val2 != null) ? 1 : 2), RunLifecyclePatches.CurrentLevelName()))
				{
					num++;
				}
			}
			return num;
		}

		private static int Count<T>(ICollection<T>? collection)
		{
			return collection?.Count ?? 0;
		}

		private static string? EnemyOrbSize(ValuableRef valuable)
		{
			if (!valuable.Name.StartsWith("Enemy Valuable - ", StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			return valuable.Name.Substring("Enemy Valuable - ".Length).Trim();
		}
	}
	internal sealed class PollingRunner : MonoBehaviour
	{
		private void Awake()
		{
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			SceneManager.sceneLoaded += OnSceneLoaded;
			NuageReportPlugin.LogVerbose("NuageReport polling runner Awake.");
		}

		private void Start()
		{
			NuageReportPlugin.LogVerbose("NuageReport polling runner Start.");
		}

		private void Update()
		{
			NuageReportPlugin.TickSurvivingSystems("PollingRunner.Update");
		}

		private void OnGUI()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Event current = Event.current;
			if (PluginConfig.Instance.IsModActive() && current != null && (int)current.type == 4 && NuageReportPlugin.ReportUi != null && NuageReportPlugin.ReportUi.HandleKeyEvent(current.keyCode, "PollingRunner.OnGUI"))
			{
				current.Use();
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			NuageReportPlugin.LogVerbose("NuageReport polling runner destroyed.");
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			NuageReportPlugin.LogVerbose($"NuageReport scene loaded: {((Scene)(ref scene)).name} ({mode}).");
			NuageReportPlugin.TickSurvivingSystems("PollingRunner.OnSceneLoaded", forcePoll: true);
		}
	}
	internal sealed class ReportExporter
	{
		public string Export(RunReport report)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (report == null)
			{
				throw new ArgumentNullException("report");
			}
			Directory.CreateDirectory(PluginPaths.ReportsDirectory);
			string text = Path.Combine(PluginPaths.ReportsDirectory, BuildFileName(report));
			File.WriteAllText(text, new JsonReportFormatter().Format(report));
			return text;
		}

		private static string BuildFileName(RunReport report)
		{
			string text = report.StartedAt.UtcDateTime.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
			return text + "-" + SafeFilePart(report.RunId) + ".json";
		}

		private static string SafeFilePart(string value)
		{
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			char[] array = value.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				for (int j = 0; j < invalidFileNameChars.Length; j++)
				{
					if (array[i] == invalidFileNameChars[j])
					{
						array[i] = '-';
						break;
					}
				}
			}
			return new string(array);
		}
	}
}
namespace NuageReport.Plugin.Config
{
	internal sealed class PluginConfig
	{
		public const float LiveReportSyncIntervalMinimumSeconds = 0.5f;

		public const float LiveReportSyncIntervalMaximumSeconds = 10f;

		public static PluginConfig Instance { get; } = new PluginConfig();


		public ConfigEntry<bool> EnableRecording { get; private set; }

		public ConfigEntry<bool> EnableJsonOutput { get; private set; }

		public ConfigEntry<bool> VerboseLogging { get; private set; }

		public ConfigEntry<bool> LogHookHits { get; private set; }

		public ConfigEntry<bool> LogRecordedEvents { get; private set; }

		public ConfigEntry<float> CartConfirmationSeconds { get; private set; }

		public ConfigEntry<KeyCode> ReportMenuKeybind { get; private set; }

		public ConfigEntry<bool> EnableLiveReport { get; private set; }

		public ConfigEntry<bool> ShareReports { get; private set; }

		public ConfigEntry<float> LiveReportSyncIntervalSeconds { get; private set; }

		private PluginConfig()
		{
		}

		public void Bind(ConfigFile config)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			EnableRecording = config.Bind<bool>("General", "EnableRecording", true, "Enable NuageReport. When disabled, recording, report UI, polling, and multiplayer sync stay inactive.");
			EnableLiveReport = config.Bind<bool>("General", "EnableLiveReport", false, "Enable the live report tab and live report sharing when Multiplayer.ShareReports is enabled.");
			EnableJsonOutput = config.Bind<bool>("General", "EnableJsonOutput", true, "Write completed run reports as JSON files under the NuageReport runs folder.");
			CartConfirmationSeconds = config.Bind<float>("General", "CartConfirmationSeconds", 0.5f, "How long an item must remain detected in a cart before first-carted is recorded.");
			ReportMenuKeybind = config.Bind<KeyCode>("Keybinds", "ReportMenuKeybind", (KeyCode)111, "Key used to open or close the NuageReport menu.");
			ShareReports = config.Bind<bool>("Multiplayer", "ShareReports", true, "Share finalized reports with modded clients. Live reports are shared too when General.EnableLiveReport is enabled.");
			LiveReportSyncIntervalSeconds = config.Bind<float>("Multiplayer", "LiveReportSyncIntervalSeconds", 2f, new ConfigDescription("Minimum seconds between live report sync packets.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 10f), Array.Empty<object>()));
			VerboseLogging = config.Bind<bool>("Diagnostics", "VerboseLogging", false, "Enable extra debug logs while developing hooks.");
			LogHookHits = config.Bind<bool>("Diagnostics", "LogHookHits", false, "Log capped hook-hit diagnostics during hook smoke testing.");
			LogRecordedEvents = config.Bind<bool>("Diagnostics", "LogRecordedEvents", false, "Log each accepted recorder event to the BepInEx console.");
		}

		public bool IsModActive()
		{
			return EnableRecording.Value;
		}

		public KeyboardShortcut EffectiveReportMenuShortcut()
		{
			//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)
			return new KeyboardShortcut(ReportMenuKeybind.Value, Array.Empty<KeyCode>());
		}

		public bool IsLiveReportEnabled()
		{
			if (IsModActive())
			{
				return EnableLiveReport.Value;
			}
			return false;
		}

		public bool ShouldWriteJsonOutput()
		{
			if (IsModActive())
			{
				return EnableJsonOutput.Value;
			}
			return false;
		}

		public bool ShouldShareReports()
		{
			if (IsModActive())
			{
				return ShareReports.Value;
			}
			return false;
		}

		public bool ShouldShareLiveReport()
		{
			if (ShouldShareReports())
			{
				return IsLiveReportEnabled();
			}
			return false;
		}

		public bool ShouldLogVerbose()
		{
			if (VerboseLogging != null)
			{
				return VerboseLogging.Value;
			}
			return false;
		}
	}
}