using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PitConfortavel.Configuration;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("PitConfortavel")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Mod para Valheim que personaliza o alcance e exibe informações de itens de conforto")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PitConfortavel")]
[assembly: AssemblyTitle("PitConfortavel")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace PitConfortavel
{
	[BepInPlugin("com.marce.pitconfortavel", "PitConfortavel", "1.0.0")]
	public class PitConfortavelPlugin : BaseUnityPlugin
	{
		public const string ModGUID = "com.marce.pitconfortavel";

		public const string ModName = "PitConfortavel";

		public const string ModVersion = "1.0.0";

		internal static ManualLogSource Log;

		private Harmony _harmony;

		private void Awake()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			ModConfig.Initialize(((BaseUnityPlugin)this).Config);
			_harmony = new Harmony("com.marce.pitconfortavel");
			_harmony.PatchAll();
			Log.LogInfo((object)"=============================================================");
			Log.LogInfo((object)" PitConfortavel v1.0.0 carregado com sucesso!");
			Log.LogInfo((object)$" Raio de conforto configurado: {ModConfig.ComfortRadius.Value}m (Original: 10m)");
			Log.LogInfo((object)"=============================================================");
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
}
namespace PitConfortavel.Patches
{
	[HarmonyPatch(typeof(Hud), "SetupPieceInfo")]
	public static class BuildHudPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Hud __instance, Piece piece)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.ShowComfortInBuildHud.Value && !((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.m_pieceDescription == (Object)null) && !((Object)(object)piece == (Object)null))
			{
				if (piece.m_comfort > 0)
				{
					string friendlyGroupName = GetFriendlyGroupName(piece.m_comfortGroup);
					string text = ((ModConfig.ShowComfortGroup.Value && !string.IsNullOrEmpty(friendlyGroupName)) ? (" <color=#CCCCCC>(" + friendlyGroupName + ")</color>") : "");
					string text2 = (ModConfig.ShowConfiguredRadiusInHud.Value ? $" <color=#70C0FF>[Raio: {ModConfig.ComfortRadius.Value:0.#}m]</color>" : "");
					string text3 = (((Object)(object)piece.m_comfortObject != (Object)null) ? "\n<color=#FFA24C>⚠ Requer fogo/aceso para conceder conforto</color>" : "");
					TMP_Text pieceDescription = __instance.m_pieceDescription;
					pieceDescription.text += $"\n\n<color=#FFD700>★ Conforto: +{piece.m_comfort}</color>{text}{text2}{text3}";
				}
				else if (ModConfig.ShowNonComfortItems.Value)
				{
					TMP_Text pieceDescription2 = __instance.m_pieceDescription;
					pieceDescription2.text += "\n\n<color=#888888>○ Não concede conforto</color>";
				}
			}
		}

		private unsafe static string GetFriendlyGroupName(ComfortGroup group)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected I4, but got Unknown
			return (int)group switch
			{
				2 => "Cama", 
				4 => "Cadeira/Trono", 
				5 => "Mesa", 
				1 => "Fogo/Fogueira", 
				3 => "Estandarte", 
				6 => "Tapete", 
				7 => "Expositor", 
				8 => "Decoração", 
				9 => "Guirlanda", 
				10 => "Lanterna", 
				11 => "Lazer/Jacuzzi", 
				0 => "Sem Grupo (Acumula)", 
				_ => ((object)(*(ComfortGroup*)(&group))/*cast due to .constrained prefix*/).ToString(), 
			};
		}
	}
	[HarmonyPatch(typeof(SE_Rested), "GetNearbyComfortPieces")]
	public static class ComfortRangePatch
	{
		private static readonly List<Piece> CustomComfortPieces = new List<Piece>();

		[HarmonyPrefix]
		public static bool Prefix(Vector3 point, ref List<Piece> __result)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			CustomComfortPieces.Clear();
			float num = ModConfig.ComfortRadius.Value;
			if (num <= 0f)
			{
				num = 10f;
			}
			Piece.GetAllComfortPiecesInRadius(point, num, CustomComfortPieces);
			__result = CustomComfortPieces;
			return false;
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	public static class ComfortScannerPatch
	{
		private class ComfortItemInfo
		{
			public string PrefabName;

			public string DisplayName;

			public int ComfortValue;

			public ComfortGroup Group;

			public bool RequiresFire;
		}

		private static bool _alreadyScanned;

		[HarmonyPostfix]
		public static void Postfix(ZNetScene __instance)
		{
			if (_alreadyScanned || !ModConfig.ExportComfortItemsList.Value || (Object)(object)__instance == (Object)null || __instance.m_prefabs == null)
			{
				return;
			}
			try
			{
				ScanAndExportComfortItems(__instance.m_prefabs);
				_alreadyScanned = true;
			}
			catch (Exception arg)
			{
				PitConfortavelPlugin.Log.LogError((object)$"Erro ao escanear e exportar itens de conforto: {arg}");
			}
		}

		private static void ScanAndExportComfortItems(List<GameObject> prefabs)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			List<ComfortItemInfo> list = new List<ComfortItemInfo>();
			foreach (GameObject prefab in prefabs)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				Piece component = prefab.GetComponent<Piece>();
				if (!((Object)(object)component != (Object)null) || component.m_comfort <= 0)
				{
					continue;
				}
				string text = component.m_name;
				try
				{
					if (Localization.instance != null && !string.IsNullOrEmpty(component.m_name))
					{
						text = Localization.instance.Localize(component.m_name);
					}
				}
				catch
				{
					text = ((Object)prefab).name;
				}
				list.Add(new ComfortItemInfo
				{
					PrefabName = ((Object)prefab).name,
					DisplayName = (string.IsNullOrEmpty(text) ? ((Object)prefab).name : text),
					ComfortValue = component.m_comfort,
					Group = component.m_comfortGroup,
					RequiresFire = ((Object)(object)component.m_comfortObject != (Object)null)
				});
			}
			list = (from i in list
				group i by i.PrefabName into g
				select g.First() into i
				orderby ((object)Unsafe.As<ComfortGroup, ComfortGroup>(ref i.Group)/*cast due to .constrained prefix*/).ToString(), i.ComfortValue descending, i.DisplayName
				select i).ToList();
			PitConfortavelPlugin.Log.LogInfo((object)$"[PitConfortavel] Foram identificados {list.Count} itens de conforto no Valheim!");
			string text2 = Path.Combine(Paths.ConfigPath, "PitConfortavel_Itens.txt");
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("========================================================================");
			stringBuilder.AppendLine("                     PIT CONFORTÁVEL - ITENS DE CONFORTO               ");
			stringBuilder.AppendLine("========================================================================");
			stringBuilder.AppendLine($"Total de itens de conforto encontrados: {list.Count}");
			stringBuilder.AppendLine($"Alcance de conforto configurado no mod: {ModConfig.ComfortRadius.Value} metros");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("DICA SOBRE O CONFORTO NO VALHEIM:");
			stringBuilder.AppendLine("- Itens do MESMO grupo não acumulam conforto entre si (apenas o maior valor conta).");
			stringBuilder.AppendLine("- Itens 'Sem Grupo' acumulam livremente com qualquer outro item.");
			stringBuilder.AppendLine("- Peças com aviso de fogo requerem estar acesas para fornecer conforto.");
			stringBuilder.AppendLine("========================================================================");
			stringBuilder.AppendLine();
			foreach (IGrouping<ComfortGroup, ComfortItemInfo> item in from i in list
				group i by i.Group)
			{
				stringBuilder.AppendLine($"--- GRUPO: {item.Key} ---");
				foreach (ComfortItemInfo item2 in item)
				{
					string text3 = (item2.RequiresFire ? " [Requer Fogo Aceso]" : "");
					stringBuilder.AppendLine($"  • {item2.DisplayName,-25} | Conforto: +{item2.ComfortValue} | Prefab: {item2.PrefabName}{text3}");
				}
				stringBuilder.AppendLine();
			}
			File.WriteAllText(text2, stringBuilder.ToString(), Encoding.UTF8);
			PitConfortavelPlugin.Log.LogInfo((object)("[PitConfortavel] Lista detalhada exportada com sucesso para: " + text2));
		}
	}
}
namespace PitConfortavel.Configuration
{
	public static class ModConfig
	{
		public static ConfigEntry<float> ComfortRadius { get; private set; }

		public static ConfigEntry<bool> ShowComfortInBuildHud { get; private set; }

		public static ConfigEntry<bool> ShowNonComfortItems { get; private set; }

		public static ConfigEntry<bool> ShowComfortGroup { get; private set; }

		public static ConfigEntry<bool> ShowConfiguredRadiusInHud { get; private set; }

		public static ConfigEntry<bool> ExportComfortItemsList { get; private set; }

		public static void Initialize(ConfigFile config)
		{
			ComfortRadius = config.Bind<float>("Geral", "ComfortRadius", 100f, "Raio de alcance em metros para detectar itens de conforto ao redor do jogador (Padrão original do jogo: 10 metros).");
			ShowComfortInBuildHud = config.Bind<bool>("Interface (HUD de Construção)", "ShowComfortInBuildHud", true, "Exibe no canto inferior direito se a peça selecionada no modo build concede conforto ou não.");
			ShowNonComfortItems = config.Bind<bool>("Interface (HUD de Construção)", "ShowNonComfortItems", true, "Exibe uma indicação ('Sem bônus de conforto') quando a peça selecionada não concede conforto.");
			ShowComfortGroup = config.Bind<bool>("Interface (HUD de Construção)", "ShowComfortGroup", true, "Exibe o grupo do item (ex: Cadeira, Mesa, Cama, Fogueira). Lembre-se: itens do mesmo grupo não acumulam conforto entre si no Valheim.");
			ShowConfiguredRadiusInHud = config.Bind<bool>("Interface (HUD de Construção)", "ShowConfiguredRadiusInHud", true, "Exibe o alcance configurado de conforto diretamente no HUD da peça (ex: [Alcance: 100m]).");
			ExportComfortItemsList = config.Bind<bool>("Exportação", "ExportComfortItemsList", true, "Exporta automaticamente um arquivo de texto formatado (PitConfortavel_Itens.txt) na pasta BepInEx/config listando todos os itens de conforto existentes no jogo.");
		}
	}
}