using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ValheimReporter
{
	public static class CategoryLoader
	{
		public static CategoriesRoot Load(string fileName)
		{
			try
			{
				string path = Path.Combine(ValheimReporter.DataPath, fileName);
				if (!File.Exists(path))
				{
					Utils.LogSystem("CategoryLoader", "Load", "JSON file missing: " + fileName, "error", 1);
					return null;
				}
				string text = File.ReadAllText(path);
				Dictionary<string, Category> categories = JsonConvert.DeserializeObject<Dictionary<string, Category>>(text);
				return new CategoriesRoot
				{
					Categories = categories
				};
			}
			catch (Exception ex)
			{
				Utils.LogSystem("CategoryLoader", "Load", "Error parsing categories: " + ex.Message, "error", 1);
				return null;
			}
		}
	}
	public class CategoriesRoot
	{
		public Dictionary<string, Category> Categories { get; set; } = new Dictionary<string, Category>();


		public Category GetCategory(string id)
		{
			Category value;
			return Categories.TryGetValue(id, out value) ? value : null;
		}

		public Category GetCategoryByName(string name)
		{
			foreach (Category value in Categories.Values)
			{
				if (value.Name == name)
				{
					Utils.LogSystem("CategoryLoader", "GetCategoryByName", "Found category: " + value.Name, "log", 4);
					return value;
				}
			}
			Utils.LogSystem("CategoryLoader", "GetCategoryByName", "Category not found: " + name, "error", 4);
			return null;
		}

		public Subcategory GetSubcategory(string id)
		{
			foreach (Category value2 in Categories.Values)
			{
				if (value2.HasSubcategories && value2.Subcategories.TryGetValue(id, out var value))
				{
					Utils.LogSystem("CategoryLoader", "GetSubcategory", "Found subcategory: " + value.Name, "log", 4);
					return value;
				}
			}
			Utils.LogSystem("CategoryLoader", "GetSubcategory", "Subcategory not found: " + id, "error", 4);
			return null;
		}

		public Subcategory GetSubcategoryByName(string name)
		{
			foreach (Category value in Categories.Values)
			{
				if (!value.HasSubcategories)
				{
					continue;
				}
				foreach (Subcategory value2 in value.Subcategories.Values)
				{
					if (value2.Name == name)
					{
						Utils.LogSystem("CategoryLoader", "GetSubcategoryByName", "Found subcategory: " + value2.Name, "log", 4);
						return value2;
					}
				}
			}
			Utils.LogSystem("CategoryLoader", "GetSubcategoryByName", "Subcategory not found: " + name, "error", 4);
			return null;
		}

		public List<Category> GetList()
		{
			return new List<Category>(Categories.Values);
		}
	}
	public class Category
	{
		[JsonProperty("name")]
		public string Name { get; set; }

		[JsonProperty("webhook")]
		public string Webhook { get; set; }

		[JsonProperty("required")]
		public Requirements Required { get; set; }

		[JsonProperty("subcategories")]
		public Dictionary<string, Subcategory> Subcategories { get; set; } = new Dictionary<string, Subcategory>();


		[JsonIgnore]
		public bool HasSubcategories => Subcategories != null && Subcategories.Count > 0;
	}
	public class Subcategory
	{
		[JsonProperty("name")]
		public string Name { get; set; }

		[JsonProperty("webhook")]
		public string Webhook { get; set; }

		[JsonProperty("required")]
		public Requirements Required { get; set; }
	}
	public class Requirements
	{
		[JsonProperty("pictures")]
		public bool Pictures { get; set; }

		[JsonProperty("subject")]
		public bool Subject { get; set; }

		[JsonProperty("description")]
		public bool Description { get; set; }
	}
	public class Report
	{
		[CompilerGenerated]
		private sealed class <SendReportCoroutine>d__59 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Report <>4__this;

			private List<string>.Enumerator <>s__1;

			private string <webhook>5__2;

			private List<IMultipartFormSection> <formData>5__3;

			private string <safeCategory>5__4;

			private string <safeSubCategory>5__5;

			private string <safeSubject>5__6;

			private string <safeDescription>5__7;

			private string <embedJson>5__8;

			private UnityWebRequest <www>5__9;

			private string <errorResponse>5__10;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || num == 1)
				{
					try
					{
						if (num == -4 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = default(List<string>.Enumerator);
				<webhook>5__2 = null;
				<formData>5__3 = null;
				<safeCategory>5__4 = null;
				<safeSubCategory>5__5 = null;
				<safeSubject>5__6 = null;
				<safeDescription>5__7 = null;
				<embedJson>5__8 = null;
				<www>5__9 = null;
				<errorResponse>5__10 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b6: Invalid comparison between Unknown and I4
				//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b4: Expected O, but got Unknown
				//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fb: Expected O, but got Unknown
				//IL_033a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0344: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>4__this.GenerateReportID();
						<>4__this.SaveToLocalLogs();
						<>s__1 = <>4__this.Webhook.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -4;
						if ((int)<www>5__9.result != 1)
						{
							<errorResponse>5__10 = ((<www>5__9.downloadHandler != null) ? <www>5__9.downloadHandler.text : "No response body");
							Utils.LogSystem("Report", "Send", "Discord Webhook Error: " + <www>5__9.error + " | Details: " + <errorResponse>5__10, "error", 1);
							<errorResponse>5__10 = null;
						}
						else
						{
							ValheimReporter.playSoundFlag = true;
							Utils.LogSystem("Report", "Send", "Report successfully sent to Discord.", "success", 3);
						}
						<>m__Finally2();
						<www>5__9 = null;
						<formData>5__3 = null;
						<safeCategory>5__4 = null;
						<safeSubCategory>5__5 = null;
						<safeSubject>5__6 = null;
						<safeDescription>5__7 = null;
						<embedJson>5__8 = null;
						<webhook>5__2 = null;
						break;
					}
					while (<>s__1.MoveNext())
					{
						<webhook>5__2 = <>s__1.Current;
						if (string.IsNullOrEmpty(<webhook>5__2))
						{
							Utils.LogSystem("Report", "Send", "Webhook URL is empty!", "error", 1);
							continue;
						}
						<formData>5__3 = new List<IMultipartFormSection>();
						<safeCategory>5__4 = <>4__this.Category ?? "Not Specified";
						<safeSubCategory>5__5 = <>4__this.SubCategory ?? "Not Specified";
						<safeSubject>5__6 = (string.IsNullOrEmpty(<>4__this.Subject) ? "Not Specified" : <>4__this.Subject);
						<safeDescription>5__7 = (string.IsNullOrEmpty(<>4__this.Description) ? "Not Specified" : <>4__this.Description);
						<embedJson>5__8 = JsonConvert.SerializeObject((object)new
						{
							username = "Valheim Reporter",
							avatar_url = "https://i.ibb.co/KpNZ88cv/Gemini-Generated-Image-wk1a8fwk1a8fwk1a.png",
							webhook = (<webhook>5__2.StartsWith(Utils.ENCRIPTION_HEADER) ? <webhook>5__2 : null),
							embeds = new[]
							{
								new
								{
									title = "New Report: " + <>4__this.ReportID,
									color = 15105570,
									fields = new[]
									{
										new
										{
											name = "Player",
											value = <>4__this.PlayerName,
											inline = true
										},
										new
										{
											name = "Steam ID",
											value = <>4__this.SteamID,
											inline = true
										},
										new
										{
											name = "Discord ID",
											value = "<@" + <>4__this.DiscordID + ">",
											inline = true
										},
										new
										{
											name = "Coordinates",
											value = <>4__this.Coordinates,
											inline = false
										},
										new
										{
											name = "Timestamp",
											value = <>4__this.Date + " | " + <>4__this.Time,
											inline = false
										},
										new
										{
											name = "Category",
											value = <safeCategory>5__4,
											inline = true
										},
										new
										{
											name = "Subcategory",
											value = <safeSubCategory>5__5,
											inline = true
										},
										new
										{
											name = "Subject",
											value = <safeSubject>5__6,
											inline = false
										},
										new
										{
											name = "Description",
											value = <safeDescription>5__7,
											inline = false
										}
									},
									footer = new
									{
										text = "Valheim Reporter System"
									}
								}
							}
						});
						<formData>5__3.Add((IMultipartFormSection)new MultipartFormDataSection("payload_json", <embedJson>5__8));
						if ((Object)(object)<>4__this.Image1 != (Object)null)
						{
							<formData>5__3.Add((IMultipartFormSection)new MultipartFormFileSection("file", ImageConversion.EncodeToJPG(<>4__this.Image1, 75), "screenshot1.jpg", "image/jpeg"));
						}
						if ((Object)(object)<>4__this.Image2 != (Object)null)
						{
							<formData>5__3.Add((IMultipartFormSection)new MultipartFormFileSection("file2", ImageConversion.EncodeToJPG(<>4__this.Image2, 75), "screenshot2.jpg", "image/jpeg"));
						}
						<www>5__9 = UnityWebRequest.Post(<webhook>5__2.StartsWith(Utils.ENCRIPTION_HEADER) ? ValheimReporter.ConfigAPIKey.Value : <webhook>5__2, <formData>5__3);
						<>1__state = -4;
						<>2__current = <www>5__9.SendWebRequest();
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = default(List<string>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__1).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				if (<www>5__9 != null)
				{
					((IDisposable)<www>5__9).Dispose();
				}
			}

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

		public string Date { get; set; }

		public string Time { get; set; }

		public Texture2D Image1 { get; set; }

		public Texture2D Image2 { get; set; }

		public string PlayerName { get; set; }

		public string SteamID { get; set; }

		public string DiscordID { get; set; }

		public string Coordinates { get; set; }

		public List<string> Webhook { get; set; }

		public string Category { get; set; }

		public string SubCategory { get; set; }

		public string Subject { get; set; }

		public string Description { get; set; }

		public string ReportID { get; private set; }

		public Report()
		{
			DateTime now = DateTime.Now;
			Date = now.ToString("yyyy-MM-dd");
			Time = now.ToString("HH-mm-ss");
		}

		public void GenerateReportID()
		{
			ReportID = "[" + PlayerName + "] - " + Date + "_" + Time;
		}

		private void SaveToLocalLogs()
		{
			try
			{
				string path = Date + "_" + Time;
				string text = Path.Combine(ValheimReporter.LogsPath, path);
				if (!Directory.Exists(text))
				{
					Directory.CreateDirectory(text);
				}
				string text2 = Path.Combine(text, Date + "_log.json");
				var anon = new
				{
					ReportID, Date, Time, PlayerName, SteamID, DiscordID, Coordinates, Webhook, Category, SubCategory,
					Subject, Description
				};
				string contents = JsonConvert.SerializeObject((object)anon, (Formatting)1);
				File.WriteAllText(text2, contents);
				if ((Object)(object)Image1 != (Object)null)
				{
					Utils.Screen.SaveTextureToFile(Image1, Path.Combine(text, "world_view"));
				}
				if ((Object)(object)Image2 != (Object)null)
				{
					Utils.Screen.SaveTextureToFile(Image2, Path.Combine(text, "map_view"));
				}
				Utils.LogSystem("Report", "SaveLocal", "Log saved to: " + text2, "success", 3);
			}
			catch (Exception ex)
			{
				Utils.LogSystem("Report", "SaveLocal", "Error saving log: " + ex.Message, "error", 1);
			}
		}

		[IteratorStateMachine(typeof(<SendReportCoroutine>d__59))]
		public IEnumerator SendReportCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SendReportCoroutine>d__59(0)
			{
				<>4__this = this
			};
		}
	}
	public static class Utils
	{
		public static class Colors
		{
			public static class Text
			{
				public static readonly string RED = "\u001b[31m";

				public static readonly string RED_BOLD = "\u001b[31;1m";

				public static readonly string GREEN = "\u001b[32m";

				public static readonly string GREEN_BOLD = "\u001b[32;1m";

				public static readonly string YELLOW = "\u001b[33m";

				public static readonly string YELLOW_BOLD = "\u001b[33;1m";

				public static readonly string BLUE = "\u001b[34m";

				public static readonly string BLUE_BOLD = "\u001b[34;1m";

				public static readonly string MAGENTA = "\u001b[35m";

				public static readonly string MAGENTA_BOLD = "\u001b[35;1m";

				public static readonly string CYAN = "\u001b[36m";

				public static readonly string CYAN_BOLD = "\u001b[36;1m";

				public static readonly string WHITE = "\u001b[37m";

				public static readonly string WHITE_BOLD = "\u001b[37;1m";

				public static readonly string GRAY = "\u001b[90m";

				public static readonly string GRAY_BOLD = "\u001b[90;1m";

				public static readonly string BLACK = "\u001b[30m";

				public static readonly string BLACK_BOLD = "\u001b[30;1m";
			}

			public static class ForeGround
			{
				public static readonly string BLACK = "\u001b[40m";

				public static readonly string RED = "\u001b[41m";

				public static readonly string GREEN = "\u001b[42m";

				public static readonly string YELLOW = "\u001b[43m";

				public static readonly string BLUE = "\u001b[44m";

				public static readonly string MAGENTA = "\u001b[45m";

				public static readonly string CYAN = "\u001b[46m";

				public static readonly string WHITE = "\u001b[47m";
			}

			public static readonly string BOLD = "\u001b[1m";

			public static readonly string UNDERLINED = "\u001b[4m";

			public static readonly string RESET = "\u001b[0m";
		}

		public static class PlayerUtils
		{
			private static Vector3 playerLastPosition = Vector3.zero;

			public static Vector3 GetPlayerPosition()
			{
				//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_001a: 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)
				playerLastPosition = ((Component)Player.m_localPlayer).transform.position;
				return playerLastPosition;
			}

			public static Vector3 GetPlayerLastPosition()
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				return playerLastPosition;
			}
		}

		public static class Screen
		{
			public static bool toggleCursorMode;

			public static bool preventPlayerMovement;

			public static void ToggleCursorMode(bool preventPlayerMovement = false)
			{
				//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)
				Scene activeScene = SceneManager.GetActiveScene();
				if (!(((Scene)(ref activeScene)).name != "start") || !((Object)(object)Player.m_localPlayer != (Object)null))
				{
					return;
				}
				if (toggleCursorMode)
				{
					Cursor.lockState = (CursorLockMode)1;
					Cursor.visible = false;
					toggleCursorMode = false;
					FieldInfo field = typeof(GameCamera).GetField("m_mouseCapture", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field != null)
					{
						field.SetValue(GameCamera.instance, true);
					}
				}
				else
				{
					Cursor.lockState = (CursorLockMode)0;
					Cursor.visible = true;
					toggleCursorMode = true;
					Screen.preventPlayerMovement = preventPlayerMovement;
				}
			}

			public static void SaveTextureToFile(Texture2D tex, string fileName)
			{
				if (!((Object)(object)tex == (Object)null))
				{
					byte[] bytes = null;
					switch (ValheimReporter.ConfigImageFormat.Value)
					{
					case ValheimReporter.ImageFormat.JPG:
						fileName += ".jpg";
						bytes = ImageConversion.EncodeToJPG(tex, 75);
						break;
					case ValheimReporter.ImageFormat.PNG:
						fileName += ".png";
						bytes = ImageConversion.EncodeToPNG(tex);
						break;
					}
					File.WriteAllBytes(fileName, bytes);
				}
			}
		}

		public static bool debugMode = false;

		public static bool outputMode = false;

		private static bool hasInitializedLogFile = false;

		public static bool isReporterOpen = false;

		public static readonly string ENCRIPTION_HEADER = "[NH]-3247";

		private static readonly ManualLogSource Logger = Logger.CreateLogSource("ValheimReporter");

		public static string GetVersion()
		{
			return typeof(ValheimReporter).Assembly.GetName().Version.ToString();
		}

		public static void LogSystem(string sender, string function, string message, string type = "log", int level = 10, bool forcedVerbose = false)
		{
			if (!(debugMode || forcedVerbose) && level >= 4)
			{
				return;
			}
			string text = "";
			string text2 = Colors.Text.WHITE_BOLD + " || ";
			string text3 = Colors.Text.WHITE_BOLD + " ->> ";
			string text4 = Colors.Text.CYAN;
			string text5 = Colors.Text.RED;
			string text6 = Colors.Text.MAGENTA_BOLD;
			string text7 = Colors.Text.YELLOW;
			string wHITE_BOLD = Colors.Text.WHITE_BOLD;
			string wHITE_BOLD2 = Colors.Text.WHITE_BOLD;
			string text8 = type.ToLower();
			string text9 = text8;
			if (!(text9 == "success"))
			{
				if (text9 == "error")
				{
					text = Colors.ForeGround.RED;
					text4 = Colors.Text.WHITE_BOLD;
					text5 = Colors.Text.WHITE_BOLD;
					text6 = Colors.Text.WHITE_BOLD;
					text7 = Colors.Text.WHITE_BOLD;
					wHITE_BOLD = Colors.Text.WHITE_BOLD;
					wHITE_BOLD2 = Colors.Text.WHITE_BOLD;
				}
			}
			else
			{
				text = Colors.ForeGround.GREEN;
				text4 = Colors.Text.WHITE_BOLD;
				text5 = Colors.Text.WHITE_BOLD;
				text6 = Colors.Text.WHITE_BOLD;
				text7 = Colors.Text.WHITE_BOLD;
				wHITE_BOLD = Colors.Text.WHITE_BOLD;
				wHITE_BOLD2 = Colors.Text.WHITE_BOLD;
			}
			string text10 = text4 + "#### [NH]" + text2 + text5 + "[VALHEIM REPORTER]";
			string text11 = text6 + "< " + sender + " >";
			string text12 = text7 + "{ " + function + " }";
			string text13 = wHITE_BOLD + "[ " + type.ToUpper() + " ]";
			string text14 = wHITE_BOLD2 + message;
			string text15 = text + text10 + text2;
			if (debugMode || level == 1)
			{
				text15 = text15 + text11 + text2 + text12 + text2 + text13;
			}
			else
			{
				switch (level)
				{
				case 2:
					text15 = text15 + text11 + text2 + text13;
					break;
				case 3:
					text15 += text13;
					break;
				}
			}
			text15 = text15 + text3 + text14 + Colors.RESET;
			Logger.LogMessage((object)text15);
			if (!outputMode)
			{
				return;
			}
			text2 = " || ";
			text3 = " ->> ";
			text10 = "#### [NH]" + text2 + "[VALHEIM REPORTER]";
			text11 = "< " + sender + " >";
			text12 = "{ " + function + " }";
			text13 = "[ " + type.ToUpper() + " ]";
			text14 = text3 + message;
			text15 = text10 + text2 + text11 + text2 + text12 + text2 + text13 + text2 + text14;
			try
			{
				string path = Path.Combine(ValheimReporter.RootConfigValheimPath, "NH-ValheimReporter.log");
				if (!hasInitializedLogFile)
				{
					File.WriteAllText(path, text15 + Environment.NewLine);
					hasInitializedLogFile = true;
				}
				else
				{
					File.AppendAllText(path, text15 + Environment.NewLine);
				}
			}
			catch (Exception ex)
			{
				LogSystem("ValheimReporter", "LogSystem", "Failed to write log file: " + ex.Message, "error");
			}
		}

		public static void DeleteOldLogs()
		{
			try
			{
				if (!Directory.Exists(ValheimReporter.LogsPath))
				{
					return;
				}
				DirectoryInfo directoryInfo = new DirectoryInfo(ValheimReporter.LogsPath);
				DirectoryInfo[] directories = directoryInfo.GetDirectories();
				int value = ValheimReporter.ConfigMaxLogs.Value;
				if (directories.Length <= value)
				{
					return;
				}
				IEnumerable<DirectoryInfo> enumerable = directories.OrderBy((DirectoryInfo f) => f.Name).Take(directories.Length - value);
				foreach (DirectoryInfo item in enumerable)
				{
					try
					{
						item.Delete(recursive: true);
						LogSystem("LogManager", "DeleteOldLogs", "Deleted old log folder: " + item.Name, "log", 3);
					}
					catch (Exception ex)
					{
						LogSystem("LogManager", "DeleteOldLogs", "Failed to delete " + item.Name + ": " + ex.Message, "error", 1);
					}
				}
			}
			catch (Exception ex2)
			{
				LogSystem("LogManager", "DeleteOldLogs", "Critical error managing logs: " + ex2.Message, "error", 1);
			}
		}
	}
	[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
	public static class GameCamera_Patch
	{
		private static bool Prefix()
		{
			if (Utils.Screen.toggleCursorMode)
			{
				FieldInfo field = typeof(GameCamera).GetField("m_mouseCapture", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					field.SetValue(GameCamera.instance, false);
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "CanMove")]
	public static class Player_Movement
	{
		private static bool Prefix()
		{
			if (Utils.Screen.toggleCursorMode && Utils.Screen.preventPlayerMovement)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Character), "Jump")]
	public static class Player_Jump
	{
		private static bool Prefix(Character __instance)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (val != null && ((Character)val).IsPlayer() && Utils.Screen.toggleCursorMode && Utils.Screen.preventPlayerMovement)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class BlockInputPatch
	{
		private static bool Prefix()
		{
			if (Utils.isReporterOpen)
			{
				return false;
			}
			return true;
		}
	}
	[BepInPlugin("n1h1lius.valheimreporter", "Valheim Reporter", "1.0.0")]
	public class ValheimReporter : BaseUnityPlugin
	{
		public enum ImageFormat
		{
			JPG,
			PNG
		}

		public static AssetBundle MainAssetBundle;

		public static CategoriesRoot ReportCategories;

		private static GameObject _instanciaUI;

		private static ValheimReporterController _controller;

		public static bool playSoundFlag = false;

		public static ConfigEntry<KeyCode> ConfigOpenKey;

		public static ConfigEntry<bool> ConfigCloseOnSend;

		public static ConfigEntry<float> ConfigFadeDuration;

		public static ConfigEntry<bool> ConfigRequirementsRemark;

		public static ConfigEntry<bool> ConfigConfirmationSound;

		public static ConfigEntry<string> ConfigDiscordID;

		public static ConfigEntry<string> ConfigAPIKey;

		public static ConfigEntry<string> ConfigWorldName;

		public static ConfigEntry<bool> ConfigDeleteLogs;

		public static ConfigEntry<int> ConfigMaxLogs;

		public static ConfigEntry<float> ConfigMapZoom;

		public static ConfigEntry<ImageFormat> ConfigImageFormat;

		public static ConfigEntry<bool> ConfigDebugMode;

		public static ConfigEntry<bool> ConfigOutputMode;

		public static readonly string RootConfigValheimPath = Path.Combine(Paths.ConfigPath, "ValheimReporter");

		public static readonly string DataPath = Path.Combine(RootConfigValheimPath, "Data");

		public static readonly string AssetsPath = Path.Combine(DataPath, "Assets");

		public static readonly string ImagesPath = Path.Combine(DataPath, "Images");

		public static readonly string LogsPath = Path.Combine(RootConfigValheimPath, "Logs");

		private readonly Harmony harmony = new Harmony("com.n1h1lius.valheimreporter");

		private void Awake()
		{
			EnsurePluginFoldersAndFiles();
			harmony.PatchAll();
			Init();
		}

		private void Update()
		{
			if (HandleOpenManager())
			{
				if ((Object)(object)_instanciaUI == (Object)null)
				{
					Utils.LogSystem("ValheimReporter", "Update", "INIT UI...", "log", 3);
					GameObject val = MainAssetBundle.LoadAsset<GameObject>("ReporterCanvas");
					_instanciaUI = Object.Instantiate<GameObject>(val);
					Object.DontDestroyOnLoad((Object)(object)_instanciaUI);
					_controller = _instanciaUI.AddComponent<ValheimReporterController>();
					_controller.StartReporter();
				}
				if ((Object)(object)_controller != (Object)null)
				{
					Utils.LogSystem("ValheimReporter", "Update", "Toggle Main Manager...", "log", 4);
					_controller.ToggleMainManager();
				}
			}
			if ((Object)(object)_instanciaUI != (Object)null && (Object)(object)_controller != (Object)null && _controller.getIsReporterOpen())
			{
				_controller.UpdateFooterInfo();
			}
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
		}

		private void Init()
		{
			string text = Path.Combine(AssetsPath, "valheim_reporter_bundle");
			if (File.Exists(text))
			{
				MainAssetBundle = AssetBundle.LoadFromFile(text);
				Utils.LogSystem("ValheimReporter", "Awake", "Bundle Loaded Successfully.", "success", 3);
			}
			else
			{
				Utils.LogSystem("ValheimReporter", "Awake", "Bundle Not Found.", "error", 1);
			}
			ReportCategories = CategoryLoader.Load("categories.json");
			if (ReportCategories != null)
			{
				Utils.LogSystem("ValheimReporter", "Awake", "Categories Loaded Successfully.", "success", 3);
			}
			ConfigOpenKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "Open Key", (KeyCode)291, "The key to open the main manager. Default: F10");
			ConfigCloseOnSend = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Close On Send", true, "Close the main manager when a report is sent. Default: true");
			ConfigFadeDuration = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Fade Duration", 0.09f, "The duration of the fade animation of the main manager. Default: 0.09");
			ConfigRequirementsRemark = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Requirements Remark", true, "Show the requirements remark in Report Screen. It's just a visual aid to notice when some parameters are missing. Default: true");
			ConfigConfirmationSound = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Confirmation Sound", true, "Play a confirmation sound when a report is sent. Default: true");
			ConfigDiscordID = ((BaseUnityPlugin)this).Config.Bind<string>("ServerRequirements", "Discord ID", "Discord ID", "Your Discord ID. Default: Discord ID");
			ConfigAPIKey = ((BaseUnityPlugin)this).Config.Bind<string>("ServerRequirements", "API Key", "API_KEY", "Server's API Key. Default: API_KEY");
			ConfigWorldName = ((BaseUnityPlugin)this).Config.Bind<string>("ServerRequirements", "World Name", "WORLD_NAME", "Server's World Name. Default: WORLD_NAME");
			ConfigMapZoom = ((BaseUnityPlugin)this).Config.Bind<float>("Screenshots", "Map Zoom", 0.5f, "The zoom level of the map on the screenshots. 0.5f - 1.0f is a balanced zoom for seeing the area. // 0.5f is a good value. The smaller the number, the closer (0.1 very close, 1.0 very far). Default: 0.5");
			ConfigImageFormat = ((BaseUnityPlugin)this).Config.Bind<ImageFormat>("Screenshots", "Image Format", ImageFormat.JPG, "The format of the screenshots ouput. This is just client side. Reports will always send JPG high compression images. Default: JPG");
			ConfigDeleteLogs = ((BaseUnityPlugin)this).Config.Bind<bool>("LogSystem", "Delete Reports", false, "Delete the report files when the maximum number of reports is reached. Default: false");
			ConfigMaxLogs = ((BaseUnityPlugin)this).Config.Bind<int>("LogSystem", "Max Logs", 10, "The maximum number of report files to keep. Default: 10");
			ConfigOutputMode = ((BaseUnityPlugin)this).Config.Bind<bool>("LogSystem", "Output Mode", false, "Enable output mode. It will output the logs a .log file. Default: false");
			ConfigDebugMode = ((BaseUnityPlugin)this).Config.Bind<bool>("DebugMode", "Debug Mode", false, "Enable debug mode. For developers only. Default: false");
			Utils.debugMode = ConfigDebugMode.Value;
			Utils.outputMode = ConfigOutputMode.Value;
			if (ConfigDeleteLogs.Value && ConfigMaxLogs.Value > 0)
			{
				Utils.DeleteOldLogs();
			}
			Utils.LogSystem("ValheimReporter", "Awake", "Plugin Loaded Successfully.", "success", 3);
		}

		private bool HandleOpenManager()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus())
			{
				return false;
			}
			if (Console.IsVisible() || Menu.IsVisible() || TextInput.IsVisible())
			{
				return false;
			}
			if (Game.IsPaused())
			{
				return false;
			}
			if (Input.GetKeyDown(ConfigOpenKey.Value))
			{
				return true;
			}
			return false;
		}

		public static GameObject GetInstance()
		{
			return _instanciaUI;
		}

		private void EnsurePluginFoldersAndFiles()
		{
			try
			{
				if (!Directory.Exists(AssetsPath))
				{
					Directory.CreateDirectory(AssetsPath);
				}
				if (!Directory.Exists(ImagesPath))
				{
					Directory.CreateDirectory(ImagesPath);
				}
				if (!Directory.Exists(LogsPath))
				{
					Directory.CreateDirectory(LogsPath);
				}
				Dictionary<string, string> dictionary = new Dictionary<string, string>
				{
					{
						Path.Combine(AssetsPath, "confirm.ogg"),
						"ValheimReporter.ValheimReporter.Data.Assets.confirm.ogg"
					},
					{
						Path.Combine(AssetsPath, "valheim_reporter_bundle"),
						"ValheimReporter.ValheimReporter.Data.Assets.valheim_reporter_bundle"
					},
					{
						Path.Combine(ImagesPath, "NoPicture.png"),
						"ValheimReporter.ValheimReporter.Data.Images.NoPicture.png"
					},
					{
						Path.Combine(DataPath, "samples_categories.json"),
						"ValheimReporter.ValheimReporter.Data.samples_categories.json"
					},
					{
						Path.Combine(DataPath, "categories.json"),
						"ValheimReporter.ValheimReporter.Data.categories.json"
					}
				};
				foreach (KeyValuePair<string, string> item in dictionary)
				{
					string key = item.Key;
					string value = item.Value;
					if (!File.Exists(key))
					{
						Utils.LogSystem("ValheimReporter", "EnsurePluginFoldersAndFiles", "Extracting missing file: " + Path.GetFileName(key), "success", 1);
						ExtractEmbeddedResource(value, key);
					}
				}
			}
			catch (Exception ex)
			{
				Utils.LogSystem("ValheimReporter", "EnsurePluginFoldersAndFiles", "Error during folder/file setup: " + ex.Message, "error", 1);
			}
		}

		private void ExtractEmbeddedResource(string resourceName, string outputPath)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
			if (stream == null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Resource not found: " + resourceName));
				return;
			}
			using FileStream destination = new FileStream(outputPath, FileMode.Create, FileAccess.Write);
			stream.CopyTo(destination);
		}
	}
	public class ValheimReporterController : MonoBehaviour
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__59_10;

			public static UnityAction <>9__59_11;

			internal void <BindUIEvents>b__59_10()
			{
				Application.OpenURL("https://github.com/n1h1lius");
			}

			internal void <BindUIEvents>b__59_11()
			{
				Application.OpenURL("https://github.com/n1h1lius/Valheim-Reporter");
			}
		}

		[CompilerGenerated]
		private sealed class <CaptureCleanScreenshot>d__76 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ValheimReporterController <>4__this;

			private bool <hudWasActive>5__1;

			private bool <mapWasOpen>5__2;

			private FieldInfo <zoomField>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Invalid comparison between Unknown and I4
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Expected O, but got Unknown
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<hudWasActive>5__1 = (Object)(object)Hud.instance != (Object)null && (Object)(object)Hud.instance.m_rootObject != (Object)null && Hud.instance.m_rootObject.activeSelf;
					if ((Object)(object)Hud.instance != (Object)null && (Object)(object)Hud.instance.m_rootObject != (Object)null)
					{
						Hud.instance.m_rootObject.SetActive(false);
					}
					if ((Object)(object)<>4__this.mainCanvas != (Object)null)
					{
						((Behaviour)<>4__this.mainCanvas).enabled = false;
					}
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.screenshotImage1.texture = (Texture)(object)ScreenCapture.CaptureScreenshotAsTexture();
					if ((Object)(object)Minimap.instance != (Object)null)
					{
						Hud.instance.m_rootObject.SetActive(true);
						<mapWasOpen>5__2 = (int)Minimap.instance.m_mode == 2;
						Minimap.instance.SetMapMode((MapMode)2);
						<zoomField>5__3 = typeof(Minimap).GetField("m_largeZoom", BindingFlags.Instance | BindingFlags.NonPublic);
						if (<zoomField>5__3 != null)
						{
							<zoomField>5__3.SetValue(Minimap.instance, ValheimReporter.ConfigMapZoom.Value);
						}
						<>2__current = (object)new WaitForEndOfFrame();
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					<>4__this.screenshotImage2.texture = (Texture)(object)ScreenCapture.CaptureScreenshotAsTexture();
					if (!<mapWasOpen>5__2)
					{
						Minimap.instance.SetMapMode((MapMode)1);
					}
					<zoomField>5__3 = null;
					break;
				}
				<>4__this.screenshotTaken = true;
				if ((Object)(object)<>4__this.mainCanvas != (Object)null)
				{
					((Behaviour)<>4__this.mainCanvas).enabled = true;
				}
				if (((Object)(object)Hud.instance != (Object)null && (Object)(object)Hud.instance.m_rootObject != (Object)null) & <hudWasActive>5__1)
				{
					Hud.instance.m_rootObject.SetActive(true);
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <Fade>d__67 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CanvasGroup group;

			public float startAlpha;

			public float endAlpha;

			public Action onComplete;

			public ValheimReporterController <>4__this;

			private float <elapsedTime>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<elapsedTime>5__1 = 0f;
					group.alpha = startAlpha;
					if (endAlpha > 0f)
					{
						group.blocksRaycasts = true;
						group.interactable = true;
					}
					else
					{
						group.blocksRaycasts = false;
						group.interactable = false;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsedTime>5__1 < <>4__this.fadeDuration)
				{
					<elapsedTime>5__1 += Time.unscaledDeltaTime;
					group.alpha = Mathf.Lerp(startAlpha, endAlpha, <elapsedTime>5__1 / <>4__this.fadeDuration);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				group.alpha = endAlpha;
				onComplete?.Invoke();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <FetchStanza>d__74 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ValheimReporterController <>4__this;

			private UnityWebRequest <webRequest>5__1;

			private string <jsonResult>5__2;

			private string <cleanJson>5__3;

			private string[] <parts>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<webRequest>5__1 = null;
				<jsonResult>5__2 = null;
				<cleanJson>5__3 = null;
				<parts>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Invalid comparison between Unknown and I4
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<webRequest>5__1 = UnityWebRequest.Get(<>4__this.apiUrl);
						<>1__state = -3;
						<>2__current = <webRequest>5__1.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<webRequest>5__1.result == 2 || (int)<webRequest>5__1.result == 3)
						{
							Debug.LogError((object)("FETCHING API ERROR: " + <webRequest>5__1.error));
						}
						else
						{
							<jsonResult>5__2 = <webRequest>5__1.downloadHandler.text;
							<cleanJson>5__3 = <jsonResult>5__2.Trim('[', ']');
							<parts>5__4 = <cleanJson>5__3.Split(new string[1] { "\",\"" }, StringSplitOptions.None);
							if (<parts>5__4.Length >= 2)
							{
								((TMP_Text)<>4__this.stanzaText).text = <parts>5__4[0].Replace("\"", "");
								((TMP_Text)<>4__this.referenceText).text = "Hávamál - " + <parts>5__4[1].Replace("\"", "");
							}
							<jsonResult>5__2 = null;
							<cleanJson>5__3 = null;
							<parts>5__4 = null;
						}
						<>m__Finally1();
						<webRequest>5__1 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<webRequest>5__1 != null)
				{
					((IDisposable)<webRequest>5__1).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <LoadAndPlay>d__83 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string path;

			public ValheimReporterController <>4__this;

			private string <url>5__1;

			private UnityWebRequest <www>5__2;

			private AudioClip <clip>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<url>5__1 = null;
				<www>5__2 = null;
				<clip>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Invalid comparison between Unknown and I4
				//IL_00c5: 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)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<url>5__1 = "file://" + path;
						<www>5__2 = UnityWebRequestMultimedia.GetAudioClip(<url>5__1, (AudioType)14);
						<>1__state = -3;
						<>2__current = <www>5__2.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<www>5__2.result == 1)
						{
							<clip>5__3 = DownloadHandlerAudioClip.GetContent(<www>5__2);
							if ((Object)(object)Player.m_localPlayer != (Object)null)
							{
								AudioSource.PlayClipAtPoint(<clip>5__3, ((Component)Player.m_localPlayer).transform.position, 1f);
								Utils.LogSystem("ValheimReporterController", "LoadAndPlay", $"Audio played at: {((Component)Player.m_localPlayer).transform.position}", "log", 4);
							}
							<clip>5__3 = null;
						}
						else
						{
							Utils.LogSystem("Audio", "Error", "Cannot load audio: " + <www>5__2.error, "error", 1);
						}
						<>m__Finally1();
						<www>5__2 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<www>5__2 != null)
				{
					((IDisposable)<www>5__2).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <TransitionSequence>d__66 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Canvas nextCanvas;

			public CanvasGroup nextGroup;

			public string mode;

			public ValheimReporterController <>4__this;

			private string <>s__1;

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

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

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

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

			private bool MoveNext()
			{
				string text;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)<>4__this.currentActiveSubModal != (Object)null && ((Component)<>4__this.currentActiveSubModal).gameObject.activeSelf)
					{
						<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.Fade(<>4__this.currentActiveSubModalGroup, 1f, 0f));
						<>1__state = 1;
						return true;
					}
					goto IL_00b8;
				case 1:
					<>1__state = -1;
					((Component)<>4__this.currentActiveSubModal).gameObject.SetActive(false);
					goto IL_00b8;
				case 2:
					{
						<>1__state = -1;
						<>4__this.currentActiveSubModal = nextCanvas;
						<>4__this.currentActiveSubModalGroup = nextGroup;
						return false;
					}
					IL_00b8:
					text = mode;
					<>s__1 = text;
					switch (<>s__1)
					{
					case "reporter":
						<>4__this.isReporterOpen = true;
						<>4__this.HandleDropdown(<>4__this.reportTypeDropdown, "type");
						<>4__this.HandleDropdown(<>4__this.reportSubTypeDropdown, "subtype");
						break;
					case "help":
						<>4__this.isReporterOpen = false;
						<>4__this.stanzaText = <>4__this.helpStanzaText;
						<>4__this.referenceText = <>4__this.helpStanzaReference;
						break;
					case "about":
						<>4__this.isReporterOpen = false;
						<>4__this.stanzaText = <>4__this.aboutStanzaText;
						<>4__this.referenceText = <>4__this.aboutStanzaReference;
						break;
					}
					<>s__1 = null;
					((Component)nextCanvas).gameObject.SetActive(true);
					if (<>4__this.finishedReport)
					{
						<>4__this.ResetReporterModal();
					}
					if (mode != "reporter")
					{
						<>4__this.RequestNewStanza();
					}
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.Fade(nextGroup, 0f, 1f));
					<>1__state = 2;
					return true;
				}
			}

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

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

		[Header("Status")]
		private bool isReporterOpen = false;

		private bool isMainReporterOpen = false;

		[Header("Main Settings")]
		private float fadeDuration = ValheimReporter.ConfigFadeDuration.Value;

		private Canvas mainCanvas;

		private CanvasGroup mainCanvasGroup;

		[Header("Navigation Buttons")]
		private Button openReportsModalButton;

		private Button helpButton;

		private Button aboutButton;

		[Header("Reports Modal")]
		private Canvas reportsModalCanvas;

		private CanvasGroup reportsModalCanvasGroup;

		private TextMeshProUGUI modalSectionTitle;

		private TextMeshProUGUI modalSectionType;

		private TextMeshProUGUI modalSectionSubType;

		[Header("Reports Body Content")]
		private Canvas reportsModalBodyCanvas;

		private Button generateScreenshotsButton;

		private Button submitReportButton;

		private RawImage screenshotImage1;

		private RawImage screenshotImage2;

		private TMP_Dropdown reportTypeDropdown;

		private TMP_Dropdown reportSubTypeDropdown;

		private TMP_InputField reportAboutInput;

		private TMP_InputField reportContentInput;

		[Header("Help Modal")]
		private Canvas helpModalCanvas;

		private CanvasGroup helpModalCanvasGroup;

		private TextMeshProUGUI helpStanzaText;

		private TextMeshProUGUI helpStanzaReference;

		[Header("About Modal")]
		private Canvas aboutModalCanvas;

		private CanvasGroup aboutModalCanvasGroup;

		private TextMeshProUGUI aboutStanzaText;

		private TextMeshProUGUI aboutStanzaReference;

		private Button checkMyGithubButton;

		private Button checkModGithubButton;

		[Header("Footer Info")]
		private TextMeshProUGUI footerDateLabel;

		private TextMeshProUGUI footerTimeLabel;

		private TextMeshProUGUI footerCoorLabel;

		[Header("Transition Tracking")]
		private Canvas currentActiveSubModal = null;

		private CanvasGroup currentActiveSubModalGroup = null;

		[Header("Warning Modal")]
		private Canvas warningModalCanvas;

		private CanvasGroup warningModalCanvasGroup;

		private TextMeshProUGUI warningTextReason;

		private Button warningAcceptButton;

		private TextMeshProUGUI stanzaText;

		private TextMeshProUGUI referenceText;

		private Texture2D defaultTexture;

		private Category currentCategory;

		private Subcategory currentSubcategory;

		private bool aboutIsRequired = false;

		private bool aboutIsRequiredAnimationFlag = false;

		private bool contentIsRequiredAnimationFlag = false;

		private bool pulsatingIsRequired = false;

		private int stoppedPulsating = 0;

		private bool contentIsRequired = false;

		public bool finishedReport = false;

		public bool screenshotTaken = false;

		private string apiUrl = "https://odin-api.orlog.workers.dev/havamal/english/random";

		private void Awake()
		{
			mainCanvasGroup = ((Component)this).GetComponent<CanvasGroup>();
		}

		private void Update()
		{
			if (ValheimReporter.ConfigRequirementsRemark.Value)
			{
				if (aboutIsRequired)
				{
					RequiredAnimation(reportAboutInput, ref aboutIsRequiredAnimationFlag);
				}
				if (contentIsRequired)
				{
					RequiredAnimation(reportContentInput, ref contentIsRequiredAnimationFlag);
				}
				if (stoppedPulsating < 2)
				{
					RequiredImageAnimation(screenshotImage1, pulsatingIsRequired);
					RequiredImageAnimation(screenshotImage2, pulsatingIsRequired);
				}
			}
			if (ValheimReporter.ConfigConfirmationSound.Value && ValheimReporter.playSoundFlag)
			{
				PlayConfirmSound();
				ValheimReporter.playSoundFlag = false;
				if (ValheimReporter.ConfigCloseOnSend.Value)
				{
					ToggleMainManager();
				}
			}
		}

		public void StartReporter()
		{
			Utils.LogSystem("ValheimReporterController", "StartReporter", "Initializing Valheim Reporter...", "log", 4);
			InitializeReferences();
			BindUIEvents();
			SetupInitialState();
			((Component)mainCanvas).gameObject.SetActive(false);
			Utils.LogSystem("ValheimReporterController", "StartReporter", "Valheim Reporter initialized.", "success", 3);
		}

		private void InitializeReferences()
		{
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Initializing Valheim Reporter references...", "log", 4);
			mainCanvas = ((Component)this).GetComponent<Canvas>();
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Initializing Navigation references...", "log", 4);
			openReportsModalButton = GameObject.Find("ReporterFrameOpenReportsModalButton").GetComponent<Button>();
			helpButton = GameObject.Find("ReporterFrameHelpButton").GetComponent<Button>();
			aboutButton = GameObject.Find("ReporterFrameAboutButton").GetComponent<Button>();
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Initializing Reports Modal & Header references...", "log", 4);
			reportsModalCanvas = GameObject.Find("ReporterModalCanvas").GetComponent<Canvas>();
			reportsModalCanvasGroup = ((Component)reportsModalCanvas).GetComponent<CanvasGroup>();
			modalSectionTitle = GameObject.Find("ReporterModalSectionTitle").GetComponent<TextMeshProUGUI>();
			modalSectionType = GameObject.Find("ReporterModalSectionType").GetComponent<TextMeshProUGUI>();
			modalSectionSubType = GameObject.Find("ReporterModalSectionSubType").GetComponent<TextMeshProUGUI>();
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Initializing Reports Body references...", "log", 4);
			Texture2D val = LoadTextureFromFile(Path.Combine(ValheimReporter.ImagesPath, "NoPicture.png"));
			defaultTexture = val;
			reportsModalBodyCanvas = GameObject.Find("ReporterModalBody").GetComponent<Canvas>();
			generateScreenshotsButton = GameObject.Find("GenerateScreenshotsButton").GetComponent<Button>();
			submitReportButton = GameObject.Find("SubmitReportButton").GetComponent<Button>();
			screenshotImage1 = GameObject.Find("ScreenshotImage1").GetComponent<RawImage>();
			screenshotImage2 = GameObject.Find("ScreenshotImage2").GetComponent<RawImage>();
			reportTypeDropdown = GameObject.Find("ReportInfoTypeDropdown").GetComponent<TMP_Dropdown>();
			reportSubTypeDropdown = GameObject.Find("ReportInfoSubTypeDropdown").GetComponent<TMP_Dropdown>();
			reportAboutInput = GameObject.Find("ReportInfoAboutInput").GetComponent<TMP_InputField>();
			reportContentInput = GameObject.Find("ReportInfoContentInput").GetComponent<TMP_InputField>();
			ResetReporterModal();
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Initializing Help Modal references...", "log", 4);
			helpModalCanvas = GameObject.Find("HelpModalCanvas").GetComponent<Canvas>();
			helpModalCanvasGroup = ((Component)helpModalCanvas).GetComponent<CanvasGroup>();
			helpStanzaText = GameObject.Find("HelpStanzaText").GetComponent<TextMeshProUGUI>();
			helpStanzaReference = GameObject.Find("HelpStanzaReference").GetComponent<TextMeshProUGUI>();
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Initializing About Modal references...", "log", 4);
			aboutModalCanvas = GameObject.Find("AboutModalCanvas").GetComponent<Canvas>();
			aboutModalCanvasGroup = ((Component)aboutModalCanvas).GetComponent<CanvasGroup>();
			aboutStanzaText = GameObject.Find("AboutStanzaText").GetComponent<TextMeshProUGUI>();
			aboutStanzaReference = GameObject.Find("AboutStanzaReference").GetComponent<TextMeshProUGUI>();
			checkMyGithubButton = GameObject.Find("CheckMyGithubButton").GetComponent<Button>();
			checkModGithubButton = GameObject.Find("CheckModGithubButton").GetComponent<Button>();
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Initializing Footer references...", "log", 4);
			footerDateLabel = GameObject.Find("ReporterModalFooterDateLabel").GetComponent<TextMeshProUGUI>();
			footerTimeLabel = GameObject.Find("ReporterModalFooterTimeLabel").GetComponent<TextMeshProUGUI>();
			footerCoorLabel = GameObject.Find("ReporterModalFooterCoorLabel").GetComponent<TextMeshProUGUI>();
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Initializing Warning Modal references...", "log", 4);
			warningModalCanvas = GameObject.Find("WarningModalCanvas").GetComponent<Canvas>();
			warningModalCanvasGroup = ((Component)warningModalCanvas).GetComponent<CanvasGroup>();
			warningTextReason = GameObject.Find("WarningTextReason").GetComponent<TextMeshProUGUI>();
			warningAcceptButton = GameObject.Find("WarningAcceptButton").GetComponent<Button>();
			Utils.LogSystem("ValheimReporterController", "InitializeReferences", "Valheim Reporter references initialized.", "success", 4);
		}

		private void BindUIEvents()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//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_0169: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			Utils.LogSystem("ValheimReporterController", "BindUIEvents", "Binding Valheim Reporter UI events...", "log", 4);
			((UnityEvent)openReportsModalButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchSubModal(reportsModalCanvas, reportsModalCanvasGroup, "reporter");
			});
			((UnityEvent)helpButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchSubModal(helpModalCanvas, helpModalCanvasGroup, "help");
			});
			((UnityEvent)aboutButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchSubModal(aboutModalCanvas, aboutModalCanvasGroup, "about");
			});
			((UnityEvent<string>)(object)reportAboutInput.onValueChanged).AddListener((UnityAction<string>)delegate
			{
				SetRequiredFlags();
			});
			((UnityEvent<string>)(object)reportContentInput.onValueChanged).AddListener((UnityAction<string>)delegate
			{
				SetRequiredFlags();
			});
			((UnityEvent)generateScreenshotsButton.onClick).AddListener((UnityAction)delegate
			{
				TakeScreenshot();
			});
			((UnityEvent)submitReportButton.onClick).AddListener((UnityAction)delegate
			{
				SubmitReport();
			});
			((UnityEvent)warningAcceptButton.onClick).AddListener((UnityAction)delegate
			{
				((MonoBehaviour)this).StartCoroutine(Fade(warningModalCanvasGroup, 1f, 0f, delegate
				{
					((Component)warningModalCanvas).gameObject.SetActive(false);
				}));
			});
			((UnityEvent<int>)(object)reportTypeDropdown.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				HandleDropdown(reportTypeDropdown, "type");
			});
			((UnityEvent<int>)(object)reportSubTypeDropdown.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				HandleDropdown(reportSubTypeDropdown, "subtype");
			});
			ButtonClickedEvent onClick = checkMyGithubButton.onClick;
			object obj = <>c.<>9__59_10;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					Application.OpenURL("https://github.com/n1h1lius");
				};
				<>c.<>9__59_10 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = checkModGithubButton.onClick;
			object obj2 = <>c.<>9__59_11;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					Application.OpenURL("https://github.com/n1h1lius/Valheim-Reporter");
				};
				<>c.<>9__59_11 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			Utils.LogSystem("ValheimReporterController", "BindUIEvents", "Valheim Reporter UI events bound.", "log", 4);
		}

		private void SetupInitialState()
		{
			Utils.LogSystem("ValheimReporterController", "SetupInitialState", "Setting Valheim Reporter initial state...", "log", 4);
			PopulateCategories(init: true);
			mainCanvasGroup.alpha = 0f;
			reportsModalCanvasGroup.alpha = 0f;
			helpModalCanvasGroup.alpha = 0f;
			aboutModalCanvasGroup.alpha = 0f;
			((Component)reportsModalCanvas).gameObject.SetActive(false);
			((Component)helpModalCanvas).gameObject.SetActive(false);
			((Component)aboutModalCanvas).gameObject.SetActive(false);
			((Component)warningModalCanvas).gameObject.SetActive(false);
			Utils.LogSystem("ValheimReporterController", "SetupInitialState", "Valheim Reporter initial state set.", "log", 4);
		}

		public void UpdateFooterInfo()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0069: 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)
			((TMP_Text)footerDateLabel).text = DateTime.Now.ToString("dd/MM/yyyy");
			((TMP_Text)footerTimeLabel).text = DateTime.Now.ToString("HH:mm:ss");
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				Vector3 playerPosition = Utils.PlayerUtils.GetPlayerPosition();
				((TMP_Text)footerCoorLabel).text = $"({playerPosition.x:F0}, {playerPosition.y:F0}, {playerPosition.z:F0})";
			}
		}

		public void ToggleMainManager()
		{
			if (((Component)mainCanvas).gameObject.activeSelf && mainCanvasGroup.alpha >= 0.9f)
			{
				Utils.LogSystem("ValheimReporterController", "ToggleMainManager", "Closing Valheim Reporter...", "log", 4);
				isReporterOpen = false;
				Utils.isReporterOpen = false;
				isMainReporterOpen = false;
				Utils.isReporterOpen = false;
				reportTypeDropdown.value = 0;
				reportSubTypeDropdown.value = 0;
				HandleDropdown(reportTypeDropdown, "type");
				((MonoBehaviour)this).StartCoroutine(Fade(mainCanvasGroup, 1f, 0f, delegate
				{
					((Component)mainCanvas).gameObject.SetActive(false);
				}));
				Utils.Screen.ToggleCursorMode(preventPlayerMovement: true);
			}
			else if (!((Component)mainCanvas).gameObject.activeSelf)
			{
				Utils.LogSystem("ValheimReporterController", "ToggleMainManager", "Opening Valheim Reporter...", "log", 4);
				CloseAllModals();
				isMainReporterOpen = true;
				Utils.isReporterOpen = true;
				((Component)mainCanvas).gameObject.SetActive(true);
				((MonoBehaviour)this).StartCoroutine(Fade(mainCanvasGroup, 0f, 1f));
				Utils.Screen.ToggleCursorMode(preventPlayerMovement: true);
			}
		}

		public void CloseAllModals()
		{
			if (((Component)reportsModalCanvas).gameObject.activeSelf && finishedReport)
			{
				((MonoBehaviour)this).StartCoroutine(Fade(reportsModalCanvasGroup, 1f, 0f, delegate
				{
					((Component)reportsModalCanvas).gameObject.SetActive(false);
				}));
			}
			if (((Component)helpModalCanvas).gameObject.activeSelf)
			{
				((MonoBehaviour)this).StartCoroutine(Fade(helpModalCanvasGroup, 1f, 0f, delegate
				{
					((Component)helpModalCanvas).gameObject.SetActive(false);
				}));
			}
			if (((Component)aboutModalCanvas).gameObject.activeSelf)
			{
				((MonoBehaviour)this).StartCoroutine(Fade(aboutModalCanvasGroup, 1f, 0f, delegate
				{
					((Component)aboutModalCanvas).gameObject.SetActive(false);
				}));
			}
			Utils.LogSystem("ValheimReporterController", "CloseAllModals", "All Valheim Reporter modals closed.", "log", 4);
		}

		private void ResetReporterModal()
		{
			screenshotImage1.texture = (Texture)(object)defaultTexture;
			screenshotImage2.texture = (Texture)(object)defaultTexture;
			reportAboutInput.text = "";
			reportContentInput.text = "";
			finishedReport = false;
			Utils.LogSystem("ValheimReporterController", "ResetReporterModal", "Valheim Reporter modal reset.", "log", 4);
		}

		private void SwitchSubModal(Canvas targetCanvas, CanvasGroup targetGroup, string mode)
		{
			((MonoBehaviour)this).StartCoroutine(TransitionSequence(targetCanvas, targetGroup, mode));
		}

		[IteratorStateMachine(typeof(<TransitionSequence>d__66))]
		private IEnumerator TransitionSequence(Canvas nextCanvas, CanvasGroup nextGroup, string mode)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TransitionSequence>d__66(0)
			{
				<>4__this = this,
				nextCanvas = nextCanvas,
				nextGroup = nextGroup,
				mode = mode
			};
		}

		[IteratorStateMachine(typeof(<Fade>d__67))]
		private IEnumerator Fade(CanvasGroup group, float startAlpha, float endAlpha, Action onComplete = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Fade>d__67(0)
			{
				<>4__this = this,
				group = group,
				startAlpha = startAlpha,
				endAlpha = endAlpha,
				onComplete = onComplete
			};
		}

		private void HandleDropdown(TMP_Dropdown dropdown, string mode)
		{
			if (dropdown.options.Count == 0)
			{
				return;
			}
			SetRequiredFlags(reset: true);
			string text = dropdown.options[dropdown.value].text;
			if (!(mode == "type"))
			{
				if (mode == "subtype")
				{
					((TMP_Text)modalSectionSubType).text = text;
					currentSubcategory = ValheimReporter.ReportCategories.GetSubcategoryByName(text);
				}
			}
			else
			{
				((TMP_Text)modalSectionType).text = text;
				currentCategory = ValheimReporter.ReportCategories.GetCategoryByName(text);
				PopulateCategories();
			}
			SetRequiredFlags();
		}

		private void SetRequiredFlags(bool reset = false)
		{
			if (!ValheimReporter.ConfigRequirementsRemark.Value)
			{
				return;
			}
			Outline val = ((Component)reportAboutInput).GetComponent<Outline>();
			Outline val2 = ((Component)reportContentInput).GetComponent<Outline>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)reportAboutInput).gameObject.AddComponent<Outline>();
			}
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)reportContentInput).gameObject.AddComponent<Outline>();
			}
			if (reset)
			{
				ApplyOutlineEffect(status: false, val);
				ApplyOutlineEffect(status: false, val2);
				RequiredImageAnimation(screenshotImage1, flag: false);
				RequiredImageAnimation(screenshotImage2, flag: false);
			}
			else if (currentSubcategory != null)
			{
				if ((currentSubcategory.Required.Pictures && !screenshotTaken) || (currentSubcategory.Required.Pictures && currentCategory.Required.Pictures && !screenshotTaken))
				{
					pulsatingIsRequired = true;
					stoppedPulsating = 0;
				}
				if (currentSubcategory.Required.Subject || (currentSubcategory.Required.Subject && currentCategory.Required.Subject))
				{
					aboutIsRequired = ApplyOutlineEffect(reportAboutInput.text == "", val);
				}
				if (currentSubcategory.Required.Description || (currentSubcategory.Required.Description && currentCategory.Required.Description))
				{
					contentIsRequired = ApplyOutlineEffect(reportContentInput.text == "", val2);
				}
			}
			else
			{
				if (currentCategory.Required.Pictures && !screenshotTaken)
				{
					pulsatingIsRequired = true;
					stoppedPulsating = 0;
				}
				if (currentCategory.Required.Subject)
				{
					aboutIsRequired = ApplyOutlineEffect(reportAboutInput.text == "", val);
				}
				if (currentCategory.Required.Description)
				{
					contentIsRequired = ApplyOutlineEffect(reportContentInput.text == "", val2);
				}
			}
		}

		private bool ApplyOutlineEffect(bool status, Outline outline)
		{
			//IL_0017: 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)
			if (ValheimReporter.ConfigRequirementsRemark.Value)
			{
				if (status)
				{
					((Shadow)outline).effectColor = Color.red;
					((Shadow)outline).effectDistance = new Vector2(5f, -5f);
					((Behaviour)outline).enabled = true;
				}
				else
				{
					((Behaviour)outline).enabled = false;
				}
				return status;
			}
			return false;
		}

		private void RequiredAnimation(TMP_InputField inputField, ref bool flag)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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)
			Outline component = ((Component)inputField).GetComponent<Outline>();
			if (((Shadow)component).effectDistance.x < 10f && !flag)
			{
				((Shadow)component).effectDistance = ((Shadow)component).effectDistance + new Vector2(25f * Time.deltaTime, 25f * Time.deltaTime * -1f);
				if (((Shadow)component).effectDistance.x >= 10f)
				{
					flag = true;
				}
			}
			else if (flag)
			{
				((Shadow)component).effectDistance = ((Shadow)component).effectDistance + new Vector2(25f * Time.deltaTime * -1f, 25f * Time.deltaTime);
				if (((Shadow)component).effectDistance.x <= 0f)
				{
					flag = false;
				}
			}
		}

		private void RequiredImageAnimation(RawImage image, bool flag)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (flag)
			{
				float num = Mathf.PingPong(Time.time * 2f, 0.5f) + 0.5f;
				((Graphic)image).color = new Color(1f, num, num, 1f);
			}
			else
			{
				((Graphic)image).color = Color.white;
				stoppedPulsating++;
			}
		}

		public void RequestNewStanza()
		{
			((MonoBehaviour)this).StartCoroutine(FetchStanza());
		}

		[IteratorStateMachine(typeof(<FetchStanza>d__74))]
		private IEnumerator FetchStanza()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FetchStanza>d__74(0)
			{
				<>4__this = this
			};
		}

		public void TakeScreenshot()
		{
			((MonoBehaviour)this).StartCoroutine(CaptureCleanScreenshot());
			pulsatingIsRequired = false;
		}

		[IteratorStateMachine(typeof(<CaptureCleanScreenshot>d__76))]
		private IEnumerator CaptureCleanScreenshot()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CaptureCleanScreenshot>d__76(0)
			{
				<>4__this = this
			};
		}

		public void SubmitReport()
		{
			if (ValheimReporter.ConfigWorldName.Value == "WORLD_NAME" || ValheimReporter.ConfigWorldName.Value != ZNet.instance.GetWorldName())
			{
				ShowDefaultWarning(4);
				return;
			}
			Utils.LogSystem("ValheimReporterController", "SubmitReport", "Checking Category + Subcategory requirements...", "log", 4);
			Category categoryByName = ValheimReporter.ReportCategories.GetCategoryByName(reportTypeDropdown.options[reportTypeDropdown.value].text);
			Subcategory subcategoryByName = ValheimReporter.ReportCategories.GetSubcategoryByName(reportSubTypeDropdown.options[reportSubTypeDropdown.value].text);
			if (categoryByName.Webhook.StartsWith(Utils.ENCRIPTION_HEADER))
			{
				if (ValheimReporter.ConfigDiscordID.Value == "Discord ID")
				{
					ShowDefaultWarning(5);
					return;
				}
				if (string.IsNullOrEmpty(ValheimReporter.ConfigDiscordID.Value) || !char.IsDigit(ValheimReporter.ConfigDiscordID.Value[0]))
				{
					ShowDefaultWarning(5);
					return;
				}
			}
			if (subcategoryByName != null)
			{
				Utils.LogSystem("ValheimReporterController", "SubmitReport", "Subcategory exists. Checking Subcategory requirements...", "log", 4);
				if (!screenshotTaken && subcategoryByName.Required.Pictures)
				{
					ShowDefaultWarning(1);
					return;
				}
				if (subcategoryByName.Required.Subject && reportAboutInput.text == "")
				{
					ShowDefaultWarning(2);
					return;
				}
				if (subcategoryByName.Required.Description && reportContentInput.text == "")
				{
					ShowDefaultWarning(3);
					return;
				}
				if (!screenshotTaken && categoryByName.Required.Pictures && subcategoryByName.Required.Pictures)
				{
					ShowDefaultWarning(1);
					return;
				}
				if (categoryByName.Required.Subject && subcategoryByName.Required.Subject && reportAboutInput.text == "")
				{
					ShowDefaultWarning(2);
					return;
				}
				if (categoryByName.Required.Description && subcategoryByName.Required.Description && reportContentInput.text == "")
				{
					ShowDefaultWarning(3);
					return;
				}
				Utils.LogSystem("ValheimReporterController", "SubmitReport", "Subcategory requirements met.", "success", 4);
			}
			else
			{
				Utils.LogSystem("ValheimReporterController", "SubmitReport", "Subcategory does not exist. Checking Category requirements...", "log", 4);
				if (!screenshotTaken && categoryByName.Required.Pictures)
				{
					ShowDefaultWarning(1);
					return;
				}
				if (categoryByName.Required.Subject && reportAboutInput.text == "")
				{
					ShowDefaultWarning(2);
					return;
				}
				if (categoryByName.Required.Description && reportContentInput.text == "")
				{
					ShowDefaultWarning(3);
					return;
				}
				Utils.LogSystem("ValheimReporterController", "SubmitReport", "Category requirements met.", "success", 4);
			}
			Utils.LogSystem("ValheimReporterController", "SubmitReport", "Generating Report...", "log", 4);
			Report report = new Report();
			report.PlayerName = Player.m_localPlayer.GetPlayerName();
			report.SteamID = Player.m_localPlayer.GetPlayerID().ToString();
			report.DiscordID = ValheimReporter.ConfigDiscordID.Value;
			report.Coordinates = ((TMP_Text)footerCoorLabel).text;
			Utils.LogSystem("ValheimReporterController", "SubmitReport", "Basic Data Fetched -> Name: " + report.PlayerName + ", SteamID: " + report.SteamID + ", DiscordID: " + report.DiscordID + ", Coordinates: " + report.Coordinates, "success", 4);
			Utils.LogSystem("ValheimReporterController", "SubmitReport", "Trying to Fetch Raw Images", "log", 4);
			if (screenshotTaken)
			{
				Utils.LogSystem("ValheimReporterController", "SubmitReport", "Raw Image 1 -> Fetching", "success", 4);
				Texture texture = screenshotImage1.texture;
				report.Image1 = (Texture2D)(object)((texture is Texture2D) ? texture : null);
				Utils.LogSystem("ValheimReporterController", "SubmitReport", "Raw Image 2 -> Fetching", "success", 4);
				Texture texture2 = screenshotImage2.texture;
				report.Image2 = (Texture2D)(object)((texture2 is Texture2D) ? texture2 : null);
			}
			else
			{
				report.Image1 = null;
				report.Image2 = null;
			}
			report.Category = categoryByName.Name;
			if (subcategoryByName != null)
			{
				report.SubCategory = subcategoryByName.Name;
			}
			else
			{
				report.SubCategory = "None";
			}
			report.Subject = reportAboutInput.text;
			report.Description = reportContentInput.text;
			List<string> list = new List<string> { categoryByName.Webhook };
			if (subcategoryByName != null && ((subcategoryByName.Webhook != "" && subcategoryByName.Webhook != null && subcategoryByName.Webhook != " " && subcategoryByName.Webhook != "None" && subcategoryByName.Webhook != "none" && subcategoryByName.Webhook != "NONE" && subcategoryByName.Webhook != "Null" && subcategoryByName.Webhook != "null" && subcategoryByName.Webhook != "NULL" && !subcategoryByName.Webhook.Equals(categoryByName.Webhook)) || subcategoryByName.Webhook.StartsWith("[NH]-3247")))
			{
				list.Add(subcategoryByName.Webhook);
			}
			report.Webhook = list;
			((MonoBehaviour)this).StartCoroutine(report.SendReportCoroutine());
			finishedReport = true;
			screenshotTaken = false;
			CloseAllModals();
		}

		public void PopulateCategories(bool init = false)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			if (init)
			{
				reportTypeDropdown.ClearOptions();
				reportSubTypeDropdown.ClearOptions();
				bool flag = false;
				{
					foreach (Category item in ValheimReporter.ReportCategories.GetList())
					{
						reportTypeDropdown.options.Add(new OptionData(item.Name));
						if (flag)
						{
							continue;
						}
						foreach (Subcategory value in item.Subcategories.Values)
						{
							reportSubTypeDropdown.options.Add(new OptionData(value.Name));
						}
						flag = true;
					}
					return;
				}
			}
			Utils.LogSystem("ValheimReporterController", "PopulateCategories", "Clear Subtype Dropdown", "log", 4);
			reportSubTypeDropdown.ClearOptions();
			Utils.LogSystem("ValheimReporterController", "PopulateCategories", "Fetching Category", "log", 4);
			string text = reportTypeDropdown.options[reportTypeDropdown.value].text;
			Category categoryByName = ValheimReporter.ReportCategories.GetCategoryByName(text);
			if (categoryByName.HasSubcategories)
			{
				Utils.LogSystem("ValheimReporterController", "PopulateCategories", "Filling Subtype Dropdown", "log", 4);
				List<string> list = new List<string>();
				foreach (Subcategory value2 in categoryByName.Subcategories.Values)
				{
					list.Add(value2.Name);
				}
				reportSubTypeDropdown.AddOptions(list);
			}
			else
			{
				reportSubTypeDropdown.AddOptions(new List<string> { "------" });
				Utils.LogSystem("ValheimReporterController", "PopulateCategories", "No Subcategories found in Category [" + text + "]", "log", 4);
			}
			HandleDropdown(reportSubTypeDropdown, "subtype");
		}

		public void ShowWarning(string reason)
		{
			((Component)warningModalCanvas).gameObject.SetActive(true);
			((TMP_Text)warningTextReason).text = reason;
			((MonoBehaviour)this).StartCoroutine(Fade(warningModalCanvasGroup, 0f, 1f));
		}

		public void ShowDefaultWarning(int mode)
		{
			switch (mode)
			{
			case 1:
				ShowWarning("You haven't taken a screenshot yet! Please take a screenshot and try again.");
				break;
			case 2:
				ShowWarning("A subject is required for this category. Please enter a subject and try again.");
				break;
			case 3:
				ShowWarning("A description is required for this category. Please enter a description and try again.");
				break;
			case 4:
				ShowWarning("Your world name [ " + ValheimReporter.ConfigWorldName.Value + " ] does not match Server's World Name [ " + ZNet.instance.GetWorldName() + " ]. Make sure you have entered the correct world name / Make sure you are in the correct server and try again.");
				break;
			case 5:
				ShowWarning("Your Discord ID is invalid. Please enter a valid Discord ID and try again.");
				break;
			}
		}

		public static Texture2D LoadTextureFromFile(string filePath)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			if (File.Exists(filePath))
			{
				byte[] array = File.ReadAllBytes(filePath);
				Texture2D val = new Texture2D(2, 2);
				if (ImageConversion.LoadImage(val, array))
				{
					return val;
				}
			}
			Utils.LogSystem("Utils", "LoadTexture", "Failed to load texture at: " + filePath, "error", 1);
			return null;
		}

		public void PlayConfirmSound()
		{
			string text = Path.Combine(ValheimReporter.AssetsPath, "confirm.ogg");
			if (!File.Exists(text))
			{
				Utils.LogSystem("Audio", "Load", "Audio is not present in: " + text, "error", 1);
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(LoadAndPlay(text));
			}
		}

		[IteratorStateMachine(typeof(<LoadAndPlay>d__83))]
		private IEnumerator LoadAndPlay(string path)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAndPlay>d__83(0)
			{
				<>4__this = this,
				path = path
			};
		}

		public TMP_InputField getReportAboutInput()
		{
			return reportAboutInput;
		}

		public string getReportAboutInputText()
		{
			return reportAboutInput.text;
		}

		public TMP_InputField getReportContentInput()
		{
			return reportContentInput;
		}

		public string getReportContentInputText()
		{
			return reportContentInput.text;
		}

		public string getDateText()
		{
			return ((TMP_Text)footerDateLabel).text;
		}

		public string getTimeText()
		{
			return ((TMP_Text)footerTimeLabel).text;
		}

		public string getCoorText()
		{
			return ((TMP_Text)footerCoorLabel).text;
		}

		public TextMeshProUGUI getDateLabel()
		{
			return footerDateLabel;
		}

		public TextMeshProUGUI getTimeLabel()
		{
			return footerTimeLabel;
		}

		public TextMeshProUGUI getCoorLabel()
		{
			return footerCoorLabel;
		}

		public Canvas getMainCanvas()
		{
			return mainCanvas;
		}

		public CanvasGroup getMainCanvasGroup()
		{
			return mainCanvasGroup;
		}

		public bool getIsMainReporterOpen()
		{
			return isMainReporterOpen;
		}

		public bool getIsReporterOpen()
		{
			return isReporterOpen;
		}

		public float getFadeDuration()
		{
			return fadeDuration;
		}

		public RawImage getScreenshot1()
		{
			return screenshotImage1;
		}

		public RawImage getScreenshot2()
		{
			return screenshotImage2;
		}

		public Button getOpenReportsModalButton()
		{
			return openReportsModalButton;
		}

		public Button getHelpButton()
		{
			return helpButton;
		}

		public Button getAboutButton()
		{
			return aboutButton;
		}

		public Button getGenerateScreenshotsButton()
		{
			return generateScreenshotsButton;
		}

		public Button getSubmitReportButton()
		{
			return submitReportButton;
		}

		public TMP_Dropdown getReportTypeDropdown()
		{
			return reportTypeDropdown;
		}

		public TMP_Dropdown getReportSubTypeDropdown()
		{
			return reportSubTypeDropdown;
		}

		public void SetReportAboutInputText(string text)
		{
			reportAboutInput.text = text;
		}

		public void SetReportContentInputText(string text)
		{
			reportContentInput.text = text;
		}

		public void setDate(string date)
		{
			((TMP_Text)footerDateLabel).text = date;
		}

		public void setTime(string time)
		{
			((TMP_Text)footerTimeLabel).text = time;
		}

		public void setCoor(string coor)
		{
			((TMP_Text)footerCoorLabel).text = coor;
		}

		public void setFadeDuration(float duration)
		{
			fadeDuration = duration;
		}

		public void setScreenshot1(Texture image)
		{
			screenshotImage1.texture = image;
		}

		public void setScreenshot2(Texture image)
		{
			screenshotImage2.texture = image;
		}
	}
}