using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EinjarheimProfessions;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
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: AssemblyTitle("Profesiones")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Profesiones")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("50CF68F9-AA2B-4F41-B995-4C2EB29C4A19")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[HarmonyPatch(typeof(WearNTear), "GetMaterialProperties")]
internal static class Construction_Patch_GetMaterialProperties
{
	private static void Postfix(WearNTear __instance, ref float maxSupport, ref float minSupport, ref float horizontalLoss, ref float verticalLoss)
	{
		try
		{
			if (!((Object)(object)__instance.m_nview != (Object)null) || !__instance.m_nview.IsValid())
			{
				return;
			}
			ZDO zDO = __instance.m_nview.GetZDO();
			if (zDO == null)
			{
				return;
			}
			float num = zDO.GetFloat("nazhi_construction_maxsupport", 0f);
			if (num > 0f)
			{
				float num2 = minSupport / maxSupport;
				maxSupport = num;
				minSupport = num * num2;
				float num3 = zDO.GetFloat("nazhi_construction_maxsupport_vloss", 0f);
				float num4 = zDO.GetFloat("nazhi_construction_maxsupport_hloss", 0f);
				if (num3 > 0f)
				{
					verticalLoss = num3;
				}
				if (num4 > 0f)
				{
					horizontalLoss = num4;
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogError((object)$"[Construction] Error GetMaterialProperties: {arg}");
		}
	}
}
namespace EinjarheimProfessions;

[BepInPlugin("nazhi.einjarheim.professions", "Einjarheim Professions", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInProcess("valheim.exe")]
public class EinjarheimProfessionsPlugin : BaseUnityPlugin
{
	public const string PluginGuid = "nazhi.einjarheim.professions";

	public const string PluginName = "Einjarheim Professions";

	public const string PluginVersion = "1.0.0";

	internal static ManualLogSource Log;

	internal static ConfigEntry<float> ConstructionSupportPerLevel;

	internal const string ZdoKeyMaxSupport = "nazhi_construction_maxsupport";

	internal static SE_Stats ChefRegenHP;

	internal static SE_Stats ChefRegenStamina;

	internal static SE_Stats ChefRegenEitr;

	private Harmony _harmony;

	internal static EinjarheimProfessionsPlugin Instance { get; private set; }

	private void Awake()
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Expected O, but got Unknown
		Instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		Log.LogInfo((object)"[Einjarheim Professions] v1.0.0 – iniciando...");
		BindConfigs();
		InitChefSEs();
		BlacksmithingSystem.RegisterSkill();
		AlchemySystem.RegisterSkill();
		SpecializationSystem.RegisterCommand();
		_harmony = new Harmony("nazhi.einjarheim.professions");
		_harmony.PatchAll();
		Log.LogInfo((object)"[Einjarheim Professions] Profesiones cargadas:");
		Log.LogInfo((object)"[Einjarheim Professions]   · Cooking       – bonus HP/Stamina/Eitr según nivel de cocina del chef");
		Log.LogInfo((object)"[Einjarheim Professions]   · Blacksmithing – durabilidad, daño y armadura según nivel de herrería");
		Log.LogInfo((object)"[Einjarheim Professions]   · Construction  – HP de estructuras y descuento de recursos según Crafting");
		Log.LogInfo((object)"[Einjarheim Professions]   · Alchemy       – potencia, duración y fermentación según nivel de alquimia");
		Log.LogInfo((object)"[Einjarheim Professions]   · Comando /masterizar disponible");
		Log.LogInfo((object)string.Format("[{0}]   · Construction SupportPerLevel={1}", "Einjarheim Professions", ConstructionSupportPerLevel.Value));
	}

	private static void InitChefSEs()
	{
		ChefRegenHP = ScriptableObject.CreateInstance<SE_Stats>();
		((Object)ChefRegenHP).name = "nazhi_chef_regen_hp";
		((StatusEffect)ChefRegenHP).m_name = "Sazón del Chef (HP)";
		((StatusEffect)ChefRegenHP).m_tooltip = "Comida maestra: regeneración de HP aumentada";
		ChefRegenHP.m_healthRegenMultiplier = 1.3f;
		((StatusEffect)ChefRegenHP).m_startMessage = "Sazón del Chef activo (HP)";
		ChefRegenStamina = ScriptableObject.CreateInstance<SE_Stats>();
		((Object)ChefRegenStamina).name = "nazhi_chef_regen_stamina";
		((StatusEffect)ChefRegenStamina).m_name = "Sazón del Chef (Stamina)";
		((StatusEffect)ChefRegenStamina).m_tooltip = "Comida maestra: regeneración de Stamina aumentada";
		ChefRegenStamina.m_staminaRegenMultiplier = 1.2f;
		((StatusEffect)ChefRegenStamina).m_startMessage = "Sazón del Chef activo (Stamina)";
		ChefRegenEitr = ScriptableObject.CreateInstance<SE_Stats>();
		((Object)ChefRegenEitr).name = "nazhi_chef_regen_eitr";
		((StatusEffect)ChefRegenEitr).m_name = "Sazón del Chef (Eitr)";
		((StatusEffect)ChefRegenEitr).m_tooltip = "Comida maestra: regeneración de Eitr aumentada";
		ChefRegenEitr.m_eitrRegenMultiplier = 1.2f;
		((StatusEffect)ChefRegenEitr).m_startMessage = "Sazón del Chef activo (Eitr)";
		Log.LogInfo((object)"[Cooking] SE de Chef maestro inicializados (x10 testing)");
	}

	private void BindConfigs()
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Expected O, but got Unknown
		ConstructionSupportPerLevel = ((BaseUnityPlugin)this).Config.Bind<float>("Construction", "SupportPerLevel", 0.5f, new ConfigDescription("Buff de estabilidad cada 10 niveles de Crafting (escalonado). El techo de soporte se multiplica por (1 + tier * valor) donde tier = nivel/10. Las losses se dividen por (1 + tier * valor*0.5). Ej: 0.25 → lv10 +25% soporte (~2 bloques extra en Wood). Para producción usar ~0.25.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
	}

	private void OnDestroy()
	{
		ManualLogSource log = Log;
		if (log != null)
		{
			log.LogInfo((object)"[Einjarheim Professions] OnDestroy – deshaciendo patches.");
		}
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
	}
}
public enum ProfessionType
{
	None,
	Cooking,
	Blacksmithing,
	Construction,
	Alchemy
}
internal static class SpecializationSystem
{
	private const string ProfileKey = "nazhi_specialization";

	internal const float LevelCap = 50f;

	internal const float SpecializedCap = 100f;

	private static readonly Dictionary<long, ProfessionType> _specializations = new Dictionary<long, ProfessionType>();

	private static string RejectedKey(ProfessionType profession)
	{
		return $"nazhi_spec_rejected_{profession}";
	}

	internal static void RegisterCommand()
	{
		CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new MasterizarCommand());
		CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new RenegarCommand());
	}

	internal static void Save(Player player, ProfessionType spec)
	{
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		_specializations[player.GetPlayerID()] = spec;
		try
		{
			MethodInfo method = typeof(Player).GetMethod("SetCustomData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method != null)
			{
				object[] obj = new object[2] { "nazhi_specialization", null };
				int num = (int)spec;
				obj[1] = num.ToString();
				method.Invoke(player, obj);
			}
			else if (typeof(Player).GetField("m_customData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(player) is Dictionary<string, string> dictionary)
			{
				int num = (int)spec;
				dictionary["nazhi_specialization"] = num.ToString();
			}
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Specialization] Guardado: {player.GetPlayerName()} → {spec}");
		}
		catch (Exception ex)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)("[Specialization] Save error: " + ex.Message));
		}
	}

	internal static ProfessionType Load(Player player)
	{
		if ((Object)(object)player == (Object)null)
		{
			return ProfessionType.None;
		}
		try
		{
			MethodInfo method = typeof(Player).GetMethod("GetCustomData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			string value = null;
			if (method != null)
			{
				value = method.Invoke(player, new object[1] { "nazhi_specialization" }) as string;
			}
			else if (typeof(Player).GetField("m_customData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(player) is Dictionary<string, string> dictionary)
			{
				dictionary.TryGetValue("nazhi_specialization", out value);
			}
			if (!string.IsNullOrEmpty(value) && int.TryParse(value, out var result))
			{
				return (ProfessionType)result;
			}
		}
		catch (Exception ex)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)("[Specialization] Load error: " + ex.Message));
		}
		return ProfessionType.None;
	}

	internal static void SaveRejection(Player player, ProfessionType profession)
	{
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		try
		{
			MethodInfo method = typeof(Player).GetMethod("SetCustomData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method != null)
			{
				method.Invoke(player, new object[2]
				{
					RejectedKey(profession),
					"1"
				});
			}
			else if (typeof(Player).GetField("m_customData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(player) is Dictionary<string, string> dictionary)
			{
				dictionary[RejectedKey(profession)] = "1";
			}
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Specialization] Rechazo guardado: {profession}");
		}
		catch (Exception ex)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)("[Specialization] SaveRejection error: " + ex.Message));
		}
	}

	internal static bool HasRejected(Player player, ProfessionType profession)
	{
		if ((Object)(object)player == (Object)null)
		{
			return false;
		}
		try
		{
			MethodInfo method = typeof(Player).GetMethod("GetCustomData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			string value = null;
			if (method != null)
			{
				value = method.Invoke(player, new object[1] { RejectedKey(profession) }) as string;
			}
			else if (typeof(Player).GetField("m_customData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(player) is Dictionary<string, string> dictionary)
			{
				dictionary.TryGetValue(RejectedKey(profession), out value);
			}
			return value == "1";
		}
		catch
		{
			return false;
		}
	}

	internal static ProfessionType GetSpecialization(Player player)
	{
		if ((Object)(object)player == (Object)null)
		{
			return ProfessionType.None;
		}
		long playerID = player.GetPlayerID();
		if (_specializations.TryGetValue(playerID, out var value))
		{
			return value;
		}
		ProfessionType professionType = Load(player);
		_specializations[playerID] = professionType;
		return professionType;
	}

	internal static bool IsMaster(Player player)
	{
		return GetSpecialization(player) != ProfessionType.None;
	}

	internal static bool IsMasterOf(Player player, ProfessionType profession)
	{
		return GetSpecialization(player) == profession;
	}

	internal static float GetCap(Player player, ProfessionType profession)
	{
		return IsMasterOf(player, profession) ? 100f : 50f;
	}

	internal static void Specialize(Player player, ProfessionType newSpec)
	{
		if ((Object)(object)player == (Object)null || newSpec == ProfessionType.None)
		{
			return;
		}
		ProfessionType specialization = GetSpecialization(player);
		if (specialization != ProfessionType.None && specialization != newSpec)
		{
			float skillLevel = GetSkillLevel(player, specialization);
			if (skillLevel > 50f)
			{
				ClampSkill(player, specialization, 50f);
				EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Specialization] {specialization} bajado a {50f}");
			}
		}
		Save(player, newSpec);
		ProfessionType[] array = new ProfessionType[4]
		{
			ProfessionType.Cooking,
			ProfessionType.Blacksmithing,
			ProfessionType.Construction,
			ProfessionType.Alchemy
		};
		foreach (ProfessionType professionType in array)
		{
			if (professionType != newSpec)
			{
				float skillLevel2 = GetSkillLevel(player, professionType);
				if (skillLevel2 >= 50f)
				{
					ClampSkill(player, professionType, 50f);
					EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Specialization] {professionType} clampeado a {50f} al masterizar {newSpec}");
				}
			}
		}
		Player localPlayer = Player.m_localPlayer;
		if (localPlayer != null)
		{
			((Character)localPlayer).Message((MessageType)2, "<color=#FFD700>¡Te has especializado en " + GetProfessionDisplayName(newSpec) + "!</color>", 0, (Sprite)null);
		}
		EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Specialization] {player.GetPlayerName()} → Maestro de {newSpec}");
	}

	internal static void ExecuteMasterizar(Player player)
	{
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		if (IsMaster(player))
		{
			ProfessionType specialization = GetSpecialization(player);
			((Character)player).Message((MessageType)1, "<color=#FFD700>Ya eres Maestro de " + GetProfessionDisplayName(specialization) + ".</color>", 0, (Sprite)null);
			return;
		}
		List<ProfessionType> list = new List<ProfessionType>();
		ProfessionType[] array = new ProfessionType[4]
		{
			ProfessionType.Cooking,
			ProfessionType.Blacksmithing,
			ProfessionType.Construction,
			ProfessionType.Alchemy
		};
		foreach (ProfessionType professionType in array)
		{
			if (GetSkillLevel(player, professionType) >= 50f)
			{
				list.Add(professionType);
			}
		}
		if (list.Count == 0)
		{
			((Character)player).Message((MessageType)1, "<color=#FF8888>Necesitás al menos nivel 50 en una profesión para masterizarte.</color>", 0, (Sprite)null);
		}
		else
		{
			ShowSpecializationPopup(player, list);
		}
	}

	internal static void ExecuteRenegar(Player player)
	{
		if (!((Object)(object)player == (Object)null))
		{
			if (!IsMaster(player))
			{
				((Character)player).Message((MessageType)1, "<color=#FF8888>No sos Maestro de ninguna profesión.</color>", 0, (Sprite)null);
				return;
			}
			ProfessionType specialization = GetSpecialization(player);
			ShowRenegarPopup(player, specialization);
		}
	}

	internal static void ShowRenegarPopup(Player player, ProfessionType current)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Expected O, but got Unknown
		if (!StoreGui.IsVisible() && !InventoryGui.IsVisible())
		{
			GameObject val = new GameObject("EinjarheimRenegarPopup");
			RenegarPopupHandler renegarPopupHandler = val.AddComponent<RenegarPopupHandler>();
			renegarPopupHandler.Init(player, current);
		}
	}

	internal static void RemoveMastery(Player player)
	{
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		_specializations[player.GetPlayerID()] = ProfessionType.None;
		try
		{
			MethodInfo method = typeof(Player).GetMethod("SetCustomData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method != null)
			{
				method.Invoke(player, new object[2]
				{
					"nazhi_specialization",
					0.ToString()
				});
			}
			else if (typeof(Player).GetField("m_customData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(player) is Dictionary<string, string> dictionary)
			{
				dictionary["nazhi_specialization"] = 0.ToString();
			}
		}
		catch (Exception ex)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)("[Specialization] RemoveMastery error: " + ex.Message));
		}
		ProfessionType[] array = new ProfessionType[4]
		{
			ProfessionType.Cooking,
			ProfessionType.Blacksmithing,
			ProfessionType.Construction,
			ProfessionType.Alchemy
		};
		foreach (ProfessionType profession in array)
		{
			float skillLevel = GetSkillLevel(player, profession);
			if (skillLevel > 50f)
			{
				ClampSkill(player, profession, 50f);
			}
		}
		((Character)player).Message((MessageType)2, "<color=#FF8888>Has abandonado tu Maestría. Todas las profesiones quedan limitadas a nivel 50.</color>", 0, (Sprite)null);
		EinjarheimProfessionsPlugin.Log.LogInfo((object)("[Specialization] " + player.GetPlayerName() + " abandonó su Maestría."));
	}

	internal static void ShowSpecializationPopup(Player player, List<ProfessionType> available)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Expected O, but got Unknown
		if (!StoreGui.IsVisible() && !InventoryGui.IsVisible())
		{
			GameObject val = new GameObject("EinjarheimSpecPopup");
			SpecializationPopupHandler specializationPopupHandler = val.AddComponent<SpecializationPopupHandler>();
			specializationPopupHandler.Init(player, available);
		}
	}

	internal static float GetSkillLevel(Player player, ProfessionType profession)
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null)
		{
			return 0f;
		}
		return profession switch
		{
			ProfessionType.Cooking => ((Character)player).GetSkillLevel((SkillType)105), 
			ProfessionType.Construction => ((Character)player).GetSkillLevel((SkillType)107), 
			ProfessionType.Blacksmithing => ((int)BlacksmithingSystem.BlacksmithingSkillType != 0) ? ((Character)player).GetSkillLevel(BlacksmithingSystem.BlacksmithingSkillType) : 0f, 
			ProfessionType.Alchemy => ((int)AlchemySystem.SkillType != 0) ? ((Character)player).GetSkillLevel(AlchemySystem.SkillType) : 0f, 
			_ => 0f, 
		};
	}

	internal static SkillType GetSkillType(ProfessionType profession)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		return (SkillType)(profession switch
		{
			ProfessionType.Cooking => 105, 
			ProfessionType.Blacksmithing => BlacksmithingSystem.BlacksmithingSkillType, 
			ProfessionType.Construction => 107, 
			ProfessionType.Alchemy => AlchemySystem.SkillType, 
			_ => 0, 
		});
	}

	internal static string GetProfessionDisplayName(ProfessionType profession)
	{
		return profession switch
		{
			ProfessionType.Cooking => "Cocina", 
			ProfessionType.Blacksmithing => "Herrería", 
			ProfessionType.Construction => "Construcción", 
			ProfessionType.Alchemy => "Alquimia", 
			_ => "Ninguna", 
		};
	}

	internal static void ClampSkill(Player player, ProfessionType profession, float cap)
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Invalid comparison between Unknown and I4
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		try
		{
			object? obj = typeof(Player).GetField("m_skills", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(player);
			Skills val = (Skills)((obj is Skills) ? obj : null);
			if (!((Object)(object)val == (Object)null))
			{
				SkillType skillType = GetSkillType(profession);
				if ((int)skillType != 0 && val.m_skillData.TryGetValue(skillType, out var value) && value.m_level >= cap)
				{
					value.m_level = cap;
					value.m_accumulator = 0f;
					EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Specialization] ClampSkill: {profession} → {cap}");
				}
			}
		}
		catch (Exception ex)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)$"[Specialization] ClampSkill error ({profession}): {ex.Message}");
		}
	}

	internal static void OnPlayerSpawned(Player player)
	{
		if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
		{
			return;
		}
		ProfessionType specialization = GetSpecialization(player);
		ProfessionType[] array = new ProfessionType[4]
		{
			ProfessionType.Cooking,
			ProfessionType.Blacksmithing,
			ProfessionType.Construction,
			ProfessionType.Alchemy
		};
		foreach (ProfessionType profession in array)
		{
			float skillLevel = GetSkillLevel(player, profession);
			float cap = GetCap(player, profession);
			if (skillLevel > cap)
			{
				ClampSkill(player, profession, cap);
			}
		}
		EinjarheimProfessionsPlugin.Log.LogInfo((object)("[Specialization] " + player.GetPlayerName() + " → Maestro: " + GetProfessionDisplayName(specialization)));
	}
}
internal class MasterizarCommand : ConsoleCommand
{
	public override string Name => "masterizar";

	public override string Help => "Abre el menú de especialización de profesión si tenés nivel 50+.";

	public override bool IsCheat => false;

	public override void Run(string[] args)
	{
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null)
		{
			Console.instance.Print("No hay jugador local.");
		}
		else
		{
			SpecializationSystem.ExecuteMasterizar(localPlayer);
		}
	}
}
internal class SpecializationPopupHandler : MonoBehaviour
{
	private Player _player;

	private List<ProfessionType> _available;

	private float _waitTimer;

	private bool _shown;

	private GameObject _panel;

	internal void Init(Player player, List<ProfessionType> available)
	{
		_player = player;
		_available = available;
		_shown = false;
		_waitTimer = 0f;
	}

	private void Update()
	{
		if (!_shown)
		{
			_waitTimer += Time.deltaTime;
			if (!(_waitTimer < 0.3f) && !InventoryGui.IsVisible() && !TextInput.IsVisible())
			{
				BuildUI();
				_shown = true;
			}
		}
	}

	private void BuildUI()
	{
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_0219: Unknown result type (might be due to invalid IL or missing references)
		//IL_0228: Unknown result type (might be due to invalid IL or missing references)
		//IL_023d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0267: Unknown result type (might be due to invalid IL or missing references)
		//IL_0271: Expected O, but got Unknown
		//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d5: 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)
		//IL_030a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0314: Expected O, but got Unknown
		if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)"[Specialization] GUIManager no disponible.");
			Object.Destroy((Object)(object)((Component)this).gameObject);
			return;
		}
		float num = 380f + (float)_available.Count * 80f;
		_panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 700f, num, false);
		GameObject val = GUIManager.Instance.CreateText("Elige tu Especialización", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -70f), GUIManager.Instance.AveriaSerifBold, 44, GUIManager.Instance.ValheimOrange, true, Color.black, 640f, 70f, false);
		val.GetComponent<Text>().alignment = (TextAnchor)4;
		GameObject val2 = GUIManager.Instance.CreateText("<color=#AADDAA>La profesión elegida podrá subir hasta nivel 100.</color>\n<color=#DDAAAA>Las otras 3 quedarán limitadas al nivel 50.</color>", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -155f), GUIManager.Instance.AveriaSerif, 28, Color.white, false, Color.black, 640f, 80f, false);
		val2.GetComponent<Text>().alignment = (TextAnchor)4;
		float num2 = -260f;
		for (int i = 0; i < _available.Count; i++)
		{
			ProfessionType prof = _available[i];
			string professionDisplayName = SpecializationSystem.GetProfessionDisplayName(prof);
			float skillLevel = SpecializationSystem.GetSkillLevel(_player, prof);
			GameObject val3 = GUIManager.Instance.CreateButton($"<color=#88FF88>{professionDisplayName}</color>  <color=#FFD700>(Nivel {skillLevel:0})</color>", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num2 - (float)i * 80f), 500f, 65f);
			((UnityEvent)val3.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				SpecializationSystem.Specialize(_player, prof);
				GUIManager.BlockInput(false);
				Object.Destroy((Object)(object)_panel);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			});
		}
		float num3 = num2 - (float)_available.Count * 80f;
		GameObject val4 = GUIManager.Instance.CreateButton("<color=#FF8888>Cancelar</color>", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num3), 280f, 65f);
		((UnityEvent)val4.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
		{
			GUIManager.BlockInput(false);
			Object.Destroy((Object)(object)_panel);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		});
		GUIManager.BlockInput(true);
		EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Specialization] Popup mostrado con {_available.Count} opcion(es).");
	}

	private void OnDestroy()
	{
		_shown = false;
		GUIManager.BlockInput(false);
	}
}
internal class RenegarCommand : ConsoleCommand
{
	public override string Name => "renegar";

	public override string Help => "Abre confirmación para abandonar tu Maestría actual.";

	public override bool IsCheat => false;

	public override void Run(string[] args)
	{
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null)
		{
			Console.instance.Print("No hay jugador local.");
		}
		else
		{
			SpecializationSystem.ExecuteRenegar(localPlayer);
		}
	}
}
internal class RenegarPopupHandler : MonoBehaviour
{
	private Player _player;

	private ProfessionType _current;

	private float _waitTimer;

	private bool _shown;

	private GameObject _panel;

	internal void Init(Player player, ProfessionType current)
	{
		_player = player;
		_current = current;
		_shown = false;
		_waitTimer = 0f;
	}

	private void Update()
	{
		if (!_shown)
		{
			_waitTimer += Time.deltaTime;
			if (!(_waitTimer < 0.3f) && !InventoryGui.IsVisible() && !TextInput.IsVisible())
			{
				BuildUI();
				_shown = true;
			}
		}
	}

	private void BuildUI()
	{
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0160: Unknown result type (might be due to invalid IL or missing references)
		//IL_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0208: Expected O, but got Unknown
		//IL_0228: Unknown result type (might be due to invalid IL or missing references)
		//IL_0237: Unknown result type (might be due to invalid IL or missing references)
		//IL_0246: Unknown result type (might be due to invalid IL or missing references)
		//IL_026f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Expected O, but got Unknown
		if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)"[Specialization] GUIManager no disponible.");
			Object.Destroy((Object)(object)((Component)this).gameObject);
			return;
		}
		string professionDisplayName = SpecializationSystem.GetProfessionDisplayName(_current);
		_panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 700f, 450f, false);
		GameObject val = GUIManager.Instance.CreateText("Abandonar Maestría", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -75f), GUIManager.Instance.AveriaSerifBold, 44, GUIManager.Instance.ValheimOrange, true, Color.black, 640f, 70f, false);
		val.GetComponent<Text>().alignment = (TextAnchor)4;
		GameObject val2 = GUIManager.Instance.CreateText("¿Estás seguro que querés abandonar tu Maestría en <color=#FFD700>" + professionDisplayName + "</color>?\n\n<color=#DDAAAA>Todas las profesiones quedarán limitadas al nivel 50.\nPodrás volver a masterizarte con /masterizar.</color>", _panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 20f), GUIManager.Instance.AveriaSerif, 26, Color.white, false, Color.black, 640f, 180f, false);
		val2.GetComponent<Text>().alignment = (TextAnchor)4;
		GameObject val3 = GUIManager.Instance.CreateButton("<color=#FF6666>Abandonar Maestría</color>", _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-180f, 70f), 300f, 60f);
		((UnityEvent)val3.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
		{
			SpecializationSystem.RemoveMastery(_player);
			GUIManager.BlockInput(false);
			Object.Destroy((Object)(object)_panel);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		});
		GameObject val4 = GUIManager.Instance.CreateButton("<color=#88FF88>Cancelar</color>", _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(180f, 70f), 220f, 60f);
		((UnityEvent)val4.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
		{
			GUIManager.BlockInput(false);
			Object.Destroy((Object)(object)_panel);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		});
		GUIManager.BlockInput(true);
		EinjarheimProfessionsPlugin.Log.LogInfo((object)"[Specialization] Popup renegar mostrado.");
	}

	private void OnDestroy()
	{
		_shown = false;
		GUIManager.BlockInput(false);
	}
}
[HarmonyPatch(typeof(Player), "RaiseSkill")]
internal static class Specialization_Patch_RaiseSkill
{
	private static void Postfix(Player __instance, SkillType skill)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
		{
			return;
		}
		ProfessionType professionType = SkillToProfession(skill);
		if (professionType != ProfessionType.None && !SpecializationSystem.IsMasterOf(__instance, professionType))
		{
			float skillLevel = SpecializationSystem.GetSkillLevel(__instance, professionType);
			if (skillLevel >= 50f)
			{
				SpecializationSystem.ClampSkill(__instance, professionType, 50f);
			}
		}
	}

	internal static ProfessionType SkillToProfession(SkillType skill)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Invalid comparison between Unknown and I4
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Invalid comparison between Unknown and I4
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		if ((int)skill == 105)
		{
			return ProfessionType.Cooking;
		}
		if ((int)skill == 107)
		{
			return ProfessionType.Construction;
		}
		if ((int)BlacksmithingSystem.BlacksmithingSkillType != 0 && skill == BlacksmithingSystem.BlacksmithingSkillType)
		{
			return ProfessionType.Blacksmithing;
		}
		if ((int)AlchemySystem.SkillType != 0 && skill == AlchemySystem.SkillType)
		{
			return ProfessionType.Alchemy;
		}
		return ProfessionType.None;
	}
}
[HarmonyPatch(typeof(Player), "OnSpawned")]
internal static class Specialization_Patch_OnSpawned
{
	private static void Postfix(Player __instance)
	{
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
		{
			SpecializationSystem.OnPlayerSpawned(__instance);
		}
	}
}
internal static class AlchemySystem
{
	public const string SkillIdentifier = "nazhi.alchemist";

	private static SkillType s_skillType = (SkillType)0;

	public const string CD_ALCHEMIST_LV = "nazhi_alchemist_lv";

	public const string CD_ALCHEMIST_NAME = "nazhi_alchemist_name";

	public const string CD_ALCHEMIST_MASTER = "nazhi_alchemist_master";

	public const string ZDO_CRAFTER_NAME = "nazhi_alchemist_crafter_name";

	public const string ZDO_CRAFTER_LEVEL = "nazhi_alchemist_crafter_level";

	private const float XP_PotionConsumed = 1f;

	private const float XP_PotionCrafted = 2f;

	private const float BasePowerBonus = 0.1f;

	private const float PowerPerLevel = 0.003f;

	private const float MaxPowerBonus = 0.4f;

	private const float BaseDurationBonus = 0.2f;

	private const float DurationPerLevel = 0.005f;

	private const float MaxDurationBonus = 0.7f;

	private const float BaseExtraChance = 0.15f;

	private const float ExtraChancePerLevel = 0.0015f;

	private const float MaxExtraChance = 0.3f;

	private const float BaseCooldownReduction = 0.1f;

	private const float CooldownReductionPerLevel = 0.002f;

	private const float MaxCooldownReduction = 0.3f;

	private const float BaseFermentReduction = 0.2f;

	private const float FermentReductionPerLevel = 0.004f;

	private const float MaxFermentReduction = 0.6f;

	private static bool _minLevelApplied = false;

	private static readonly Dictionary<long, int> _pendingConsumeLevel = new Dictionary<long, int>();

	internal static SkillType SkillType => s_skillType;

	internal static void ResetMinLevelFlag()
	{
		_minLevelApplied = false;
	}

	internal static void SetPendingConsumeLevel(long playerID, int level)
	{
		_pendingConsumeLevel[playerID] = level;
	}

	internal static bool TryConsumePendingLevel(long playerID, out int level)
	{
		if (_pendingConsumeLevel.TryGetValue(playerID, out level))
		{
			_pendingConsumeLevel.Remove(playerID);
			return true;
		}
		level = 1;
		return false;
	}

	internal static void RegisterSkill()
	{
		//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_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Expected O, but got Unknown
		//IL_0045: 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_005e: Unknown result type (might be due to invalid IL or missing references)
		SkillConfig val = new SkillConfig
		{
			Identifier = "nazhi.alchemist",
			Name = "Alquimista",
			Description = "$skill_alchemist_desc",
			Icon = null,
			IncreaseStep = 1f
		};
		s_skillType = SkillManager.Instance.AddSkill(val);
		EinjarheimProfessionsPlugin.Log.LogInfo((object)string.Format("[Alchemy] Skill registrada: {0} ({1})", "nazhi.alchemist", s_skillType));
	}

	internal static void AddExperience(Player player, float amount)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)player == (Object)null) && (int)s_skillType != 0 && !(amount <= 0f) && !((Object)(object)((Character)player).m_nview == (Object)null) && ((Character)player).m_nview.IsOwner())
		{
			((Character)player).RaiseSkill(s_skillType, amount);
		}
	}

	internal static void OnPotionConsumed(Player player)
	{
		AddExperience(player, 1f);
	}

	internal static void OnPotionCrafted(Player player)
	{
		AddExperience(player, 2f);
	}

	internal static float GetLevel(Player player)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null)
		{
			return 0f;
		}
		return ((Character)player).GetSkillLevel(s_skillType);
	}

	internal static int GetLevelInt(Player player)
	{
		return Mathf.Max(1, Mathf.FloorToInt(GetLevel(player)));
	}

	internal static void StampItem(ItemData item, Player alchemist)
	{
		if (item != null && !((Object)(object)alchemist == (Object)null))
		{
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			item.m_customData["nazhi_alchemist_lv"] = GetLevelInt(alchemist).ToString();
			item.m_customData["nazhi_alchemist_name"] = alchemist.GetPlayerName();
			if (SpecializationSystem.IsMasterOf(alchemist, ProfessionType.Alchemy))
			{
				item.m_customData["nazhi_alchemist_master"] = "1";
			}
			else
			{
				item.m_customData.Remove("nazhi_alchemist_master");
			}
		}
	}

	internal static void StampItemDirect(ItemData item, string crafterName, int crafterLevel)
	{
		if (item != null)
		{
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			item.m_customData["nazhi_alchemist_lv"] = Mathf.Max(1, crafterLevel).ToString();
			item.m_customData["nazhi_alchemist_name"] = (string.IsNullOrEmpty(crafterName) ? "Desconocido" : crafterName);
		}
	}

	internal static bool IsAlchemistMaster(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return false;
		}
		string value;
		return item.m_customData.TryGetValue("nazhi_alchemist_master", out value) && value == "1";
	}

	internal static int GetStampedLevel(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return 1;
		}
		if (item.m_customData.TryGetValue("nazhi_alchemist_lv", out var value) && int.TryParse(value, out var result))
		{
			return Mathf.Max(1, result);
		}
		return 1;
	}

	internal static string GetStampedName(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return "Desconocido";
		}
		if (item.m_customData.TryGetValue("nazhi_alchemist_name", out var value) && !string.IsNullOrEmpty(value))
		{
			return value;
		}
		return "Desconocido";
	}

	internal static bool HasStamp(ItemData item)
	{
		return item?.m_customData != null && item.m_customData.ContainsKey("nazhi_alchemist_lv");
	}

	internal static float GetPotionPowerMultiplier(int level)
	{
		float num = 0.1f + 0.003f * (float)level;
		return 1f + Mathf.Clamp(num, 0.1f, 0.4f);
	}

	internal static float GetPotionDurationMultiplier(int level)
	{
		float num = 0.2f + 0.005f * (float)level;
		return 1f + Mathf.Clamp(num, 0.2f, 0.7f);
	}

	internal static float GetExtraPotionChance(Player player)
	{
		float num = 0.15f + 0.0015f * GetLevel(player);
		return Mathf.Clamp(num, 0.15f, 0.3f);
	}

	internal static float GetPotionCooldownMultiplier(Player player)
	{
		float num = 0.1f + 0.002f * GetLevel(player);
		return 1f - Mathf.Clamp(num, 0.1f, 0.3f);
	}

	internal static float GetFermentationReduction(Player player)
	{
		float num = 0.2f + 0.004f * GetLevel(player);
		return Mathf.Clamp(num, 0f, 0.6f);
	}

	internal static float GetFermentationTimeMultiplier(Player player)
	{
		return 1f - GetFermentationReduction(player);
	}

	internal static bool RollExtraPotion(Player player)
	{
		return Random.value <= GetExtraPotionChance(player);
	}

	internal static void EnsureMinLevel(Player player)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Invalid comparison between Unknown and I4
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		if (!_minLevelApplied && !((Object)(object)player == (Object)null) && (int)s_skillType != 0)
		{
			if (((Character)player).GetSkillLevel(s_skillType) < 1f)
			{
				((Character)player).RaiseSkill(s_skillType, 0.5f);
				EinjarheimProfessionsPlugin.Log.LogInfo((object)"[Alchemy] Nivel inicial de Alquimia establecido a 1.");
			}
			_minLevelApplied = true;
		}
	}
}
internal static class AlchemyPotionUtils
{
	internal static bool IsPotion(ItemData item)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Invalid comparison between Unknown and I4
		if (item?.m_shared == null)
		{
			return false;
		}
		if ((int)item.m_shared.m_itemType != 2)
		{
			return false;
		}
		return (Object)(object)item.m_shared.m_consumeStatusEffect != (Object)null;
	}

	internal static bool IsMeadBase(ItemData item)
	{
		if (item?.m_shared == null)
		{
			return false;
		}
		string text = item.m_shared.m_name.ToLowerInvariant();
		return text.Contains("item_meadbase") || text.Contains("meadbase") || text.Contains("mead_base") || (text.Contains("ketill") && (text.Contains("mead") || text.Contains("base")));
	}

	internal static bool IsFinalMead(ItemData item)
	{
		if (item?.m_shared == null)
		{
			return false;
		}
		string text = item.m_shared.m_name.ToLowerInvariant();
		return text.Contains("item_mead_") || (text.Contains("mead") && !text.Contains("meadbase"));
	}
}
internal static class AlchemyStatsApplier
{
	internal static void ApplyPowerAndDuration(int alchemistLevel, SE_Stats stats)
	{
		if (!((Object)(object)stats == (Object)null) && alchemistLevel > 0)
		{
			float potionDurationMultiplier = AlchemySystem.GetPotionDurationMultiplier(alchemistLevel);
			float potionPowerMultiplier = AlchemySystem.GetPotionPowerMultiplier(alchemistLevel);
			if (!(stats.m_healthUpFront > 0f) && !(stats.m_staminaUpFront > 0f) && !(stats.m_eitrUpFront > 0f) && !(stats.m_healthOverTime > 0f) && !(stats.m_staminaOverTime > 0f) && !(stats.m_eitrOverTime > 0f) && !(stats.m_healthOverTimeDuration > 0f) && !(stats.m_staminaOverTimeDuration > 0f) && !(stats.m_eitrOverTimeDuration > 0f) && ((StatusEffect)stats).m_ttl > 0f)
			{
				((StatusEffect)stats).m_ttl = ((StatusEffect)stats).m_ttl * potionDurationMultiplier;
			}
			if (stats.m_healthOverTimeDuration > 0f)
			{
				stats.m_healthOverTimeDuration *= potionDurationMultiplier;
			}
			if (stats.m_staminaOverTimeDuration > 0f)
			{
				stats.m_staminaOverTimeDuration *= potionDurationMultiplier;
			}
			if (stats.m_eitrOverTimeDuration > 0f)
			{
				stats.m_eitrOverTimeDuration *= potionDurationMultiplier;
			}
			stats.m_healthUpFront *= potionPowerMultiplier;
			stats.m_staminaUpFront *= potionPowerMultiplier;
			stats.m_eitrUpFront *= potionPowerMultiplier;
			stats.m_healthOverTime *= potionPowerMultiplier;
			stats.m_staminaOverTime *= potionPowerMultiplier;
			stats.m_eitrOverTime *= potionPowerMultiplier;
			stats.m_healthRegenMultiplier *= potionPowerMultiplier;
			stats.m_staminaRegenMultiplier *= potionPowerMultiplier;
			stats.m_eitrRegenMultiplier *= potionPowerMultiplier;
		}
	}
}
[HarmonyPatch(typeof(Player), "Update")]
internal static class Alchemy_Patch_EnsureMinLevel
{
	private static void Postfix(Player __instance)
	{
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
		{
			AlchemySystem.EnsureMinLevel(__instance);
		}
	}
}
[HarmonyPatch(typeof(Player), "OnSpawned")]
internal static class Alchemy_Patch_OnSpawned
{
	private static void Postfix(Player __instance)
	{
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
		{
			AlchemySystem.ResetMinLevelFlag();
		}
	}
}
[HarmonyPatch(typeof(Player), "ConsumeItem")]
internal static class Alchemy_Patch_ConsumeItem
{
	private static void Prefix(Player __instance, ItemData item)
	{
		try
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && AlchemyPotionUtils.IsPotion(item))
			{
				AlchemySystem.OnPotionConsumed(__instance);
				int num = (AlchemySystem.HasStamp(item) ? AlchemySystem.GetStampedLevel(item) : AlchemySystem.GetLevelInt(__instance));
				AlchemySystem.SetPendingConsumeLevel(__instance.GetPlayerID(), num);
				EinjarheimProfessionsPlugin.Log.LogInfo((object)($"[Alchemy] ConsumeItem: usando nivel alquimista={num} " + $"(stamp={AlchemySystem.HasStamp(item)})"));
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)$"[Alchemy] Error en ConsumeItem: {arg}");
		}
	}
}
[HarmonyPatch(typeof(SE_Stats), "Setup")]
internal static class Alchemy_Patch_SE_Stats_Setup
{
	private static void Prefix(SE_Stats __instance, Character character)
	{
		try
		{
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val != null && !((Object)(object)val != (Object)(object)Player.m_localPlayer) && AlchemySystem.TryConsumePendingLevel(val.GetPlayerID(), out var level))
			{
				AlchemyStatsApplier.ApplyPowerAndDuration(level, __instance);
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)$"[Alchemy] Error en SE_Stats.Setup: {arg}");
		}
	}
}
[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
internal static class Alchemy_Patch_DoCrafting_Stamp
{
	internal static readonly Dictionary<long, (string name, int level)> _pendingCrafter = new Dictionary<long, (string, int)>();

	private static void Prefix(InventoryGui __instance, Player player)
	{
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		Recipe craftRecipe = __instance.m_craftRecipe;
		if (craftRecipe?.m_item?.m_itemData != null)
		{
			ItemData itemData = craftRecipe.m_item.m_itemData;
			if (AlchemyPotionUtils.IsPotion(itemData) || AlchemyPotionUtils.IsFinalMead(itemData) || AlchemyPotionUtils.IsMeadBase(itemData))
			{
				long playerID = player.GetPlayerID();
				_pendingCrafter[playerID] = (player.GetPlayerName(), AlchemySystem.GetLevelInt(player));
				EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Alchemy] DoCrafting: pending stamp para {player.GetPlayerName()} lv={AlchemySystem.GetLevelInt(player)}");
			}
		}
	}
}
[HarmonyPatch]
internal static class Alchemy_Patch_Inventory_AddItem_Stamp
{
	private static IEnumerable<MethodBase> TargetMethods()
	{
		return from m in typeof(Inventory).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			where m.Name == "AddItem" && m.GetParameters().Length != 0 && m.GetParameters()[0].ParameterType == typeof(ItemData)
			select m;
	}

	private static void Prefix(Inventory __instance, ItemData item)
	{
		try
		{
			if (item == null || (!AlchemyPotionUtils.IsPotion(item) && !AlchemyPotionUtils.IsFinalMead(item) && !AlchemyPotionUtils.IsMeadBase(item)) || AlchemySystem.HasStamp(item))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Humanoid)localPlayer).GetInventory() != __instance)
			{
				return;
			}
			long playerID = localPlayer.GetPlayerID();
			if (Alchemy_Patch_DoCrafting_Stamp._pendingCrafter.TryGetValue(playerID, out (string, int) value))
			{
				if (item.m_customData == null)
				{
					item.m_customData = new Dictionary<string, string>();
				}
				item.m_customData["nazhi_alchemist_name"] = value.Item1;
				item.m_customData["nazhi_alchemist_lv"] = value.Item2.ToString();
				Alchemy_Patch_DoCrafting_Stamp._pendingCrafter.Remove(playerID);
				EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Alchemy] Stamp aplicado (caldero): {item.m_shared?.m_name} → {value.Item1} lv={value.Item2}");
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)$"[Alchemy] Error en AddItem Stamp: {arg}");
		}
	}
}
[HarmonyPatch(typeof(Fermenter), "AddItem")]
internal static class Alchemy_Patch_Fermenter_AddItem
{
	private static void Postfix(Fermenter __instance, Humanoid user, ItemData item, bool __result)
	{
		try
		{
			if (!__result || item == null || !AlchemyPotionUtils.IsMeadBase(item))
			{
				return;
			}
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Alchemy] Mead base en fermenter: {item.m_shared.m_name} x{item.m_stack}");
			Player val = (Player)(object)((user is Player) ? user : null);
			if (val != null && (Object)(object)val == (Object)(object)Player.m_localPlayer)
			{
				AlchemySystem.OnPotionCrafted(val);
				int num = (AlchemySystem.HasStamp(item) ? AlchemySystem.GetStampedLevel(item) : AlchemySystem.GetLevelInt(val));
				string text = (AlchemySystem.HasStamp(item) ? AlchemySystem.GetStampedName(item) : val.GetPlayerName());
				ZNetView nview = __instance.m_nview;
				if (((nview != null) ? nview.GetZDO() : null) != null)
				{
					__instance.m_nview.GetZDO().Set("nazhi_alchemist_crafter_name", text);
					__instance.m_nview.GetZDO().Set("nazhi_alchemist_crafter_level", num);
					EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Alchemy] Crafter guardado en ZDO: {text} lv={num}");
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)$"[Alchemy] Error en Fermenter.AddItem: {arg}");
		}
	}
}
[HarmonyPatch(typeof(Fermenter), "RPC_AddItem")]
internal static class Alchemy_Patch_Fermenter_RPC_AddItem
{
	private static void Postfix(Fermenter __instance, long sender, string name)
	{
		try
		{
			if ((Object)(object)__instance?.m_nview == (Object)null || !__instance.m_nview.IsOwner())
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			float fermentationReduction = AlchemySystem.GetFermentationReduction(localPlayer);
			if (!(fermentationReduction <= 0f))
			{
				ZDO zDO = __instance.m_nview.GetZDO();
				long num = zDO.GetLong(ZDOVars.s_startTime, 0L);
				if (num != 0)
				{
					double num2 = __instance.m_fermentationDuration * fermentationReduction;
					long num3 = (long)(num2 * 10000000.0);
					long num4 = Math.Max(0L, num - num3);
					zDO.Set(ZDOVars.s_startTime, num4);
					EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Alchemy] Fermentación acelerada -{fermentationReduction * 100f:0}% (~{num2:0}s) para '{name}'.");
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)$"[Alchemy] Error en RPC_AddItem: {arg}");
		}
	}
}
[HarmonyPatch(typeof(Fermenter), "DelayedTap")]
internal static class Alchemy_Patch_Fermenter_DelayedTap
{
	private static void Postfix(Fermenter __instance)
	{
		try
		{
			string delayedTapItem = __instance.m_delayedTapItem;
			if (string.IsNullOrEmpty(delayedTapItem))
			{
				return;
			}
			ItemConversion itemConversion = __instance.GetItemConversion(delayedTapItem);
			if ((Object)(object)itemConversion?.m_to == (Object)null)
			{
				return;
			}
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Alchemy] Fermenter produjo: {itemConversion.m_to.m_itemData?.m_shared?.m_name} x{itemConversion.m_producedItems}");
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				AlchemySystem.OnPotionCrafted(localPlayer);
				string text = "Desconocido";
				int num = 1;
				ZNetView nview = __instance.m_nview;
				if (((nview != null) ? nview.GetZDO() : null) != null)
				{
					text = __instance.m_nview.GetZDO().GetString("nazhi_alchemist_crafter_name", "Desconocido");
					num = __instance.m_nview.GetZDO().GetInt("nazhi_alchemist_crafter_level", 1);
					EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Alchemy] Crafter leído del ZDO: {text} lv={num}");
				}
				long playerID = localPlayer.GetPlayerID();
				Alchemy_Patch_DoCrafting_Stamp._pendingCrafter[playerID] = (text, num);
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)$"[Alchemy] Error en DelayedTap: {arg}");
		}
	}
}
[HarmonyPatch]
internal static class Alchemy_Patch_Tooltip
{
	private static IEnumerable<MethodBase> TargetMethods()
	{
		return from m in typeof(ItemData).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			where m.Name == "GetTooltip" && m.ReturnType == typeof(string)
			select m;
	}

	private static void Postfix(ItemData __instance, ref string __result)
	{
		try
		{
			if (__instance?.m_shared != null)
			{
				bool flag = AlchemyPotionUtils.IsPotion(__instance);
				bool flag2 = AlchemyPotionUtils.IsMeadBase(__instance);
				bool flag3 = AlchemyPotionUtils.IsFinalMead(__instance);
				if ((flag || flag2 || flag3) && !__result.Contains("=== Alquimia ==="))
				{
					int stampedLevel = AlchemySystem.GetStampedLevel(__instance);
					string stampedName = AlchemySystem.GetStampedName(__instance);
					float num = (AlchemySystem.GetPotionDurationMultiplier(stampedLevel) - 1f) * 100f;
					float num2 = (AlchemySystem.GetPotionPowerMultiplier(stampedLevel) - 1f) * 100f;
					Player localPlayer = Player.m_localPlayer;
					float num3 = (((Object)(object)localPlayer != (Object)null) ? (AlchemySystem.GetFermentationReduction(localPlayer) * 100f) : 0f);
					string text = (AlchemySystem.IsAlchemistMaster(__instance) ? "[GranAlquimista] " : "");
					__result = __result + $"\n\n<color=#E9C46A><b>==== Alquimia Level <color=#FFF44F>[{stampedLevel}]</color> ====</b></color>" + "\n<color=#00FFFF>Preparada por: " + text + stampedName + "</color>" + $"\nPotencia de poción: <color=#FF5CDF>+{num2:0}%</color>" + $"\nDuración de poción: <color=#CBA0FF>+{num:0}%</color>" + ((flag2 || flag3) ? $"\nFermentación rápida: <color=#A6FF4D>-{num3:0}%</color>" : "");
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)$"[Alchemy] Error en Tooltip: {arg}");
		}
	}
}
internal static class BlacksmithingSystem
{
	private const string DurabilityKey = "nazhi_blacksmith_durability";

	private const string LevelKey = "nazhi_blacksmith_lvl";

	private const string CrafterKey = "nazhi_blacksmith_crafter";

	private const string MasterKey = "nazhi_blacksmith_master";

	private const float MaxDurabilityBonusAt100 = 0.6f;

	private const float DamageMaxBonusAt100 = 0.5f;

	private const float ArmorMaxBonusAt100 = 0.5f;

	internal static SkillType BlacksmithingSkillType;

	private static bool _minLevelApplied;

	internal static void ResetMinLevelFlag()
	{
		_minLevelApplied = false;
	}

	internal static void RegisterSkill()
	{
		//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_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Expected O, but got Unknown
		//IL_0045: 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)
		SkillConfig val = new SkillConfig
		{
			Identifier = "nazhi.blacksmithing.skill",
			Name = "Herreria",
			Description = "Mejora la durabilidad y calidad del equipo forjado en fragua, fragua negra y mesa de trabajo.",
			Icon = null,
			IncreaseStep = 5f
		};
		BlacksmithingSkillType = SkillManager.Instance.AddSkill(val);
	}

	internal static float GetLevel(Player player)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Invalid comparison between Unknown and I4
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null || (int)BlacksmithingSkillType == 0)
		{
			return 0f;
		}
		return Mathf.Clamp(((Character)player).GetSkillLevel(BlacksmithingSkillType), 0f, 100f);
	}

	internal static float GetDurabilityFactor(float level)
	{
		if (level <= 0f)
		{
			return 1f;
		}
		return 1f + 0.6f * Mathf.Clamp01(level / 100f);
	}

	internal static float GetDamageFactor(int level)
	{
		if (level <= 0)
		{
			return 1f;
		}
		return 1f + 0.5f * Mathf.Clamp01((float)level / 100f);
	}

	internal static float GetDamagePercent(int level)
	{
		return (GetDamageFactor(level) - 1f) * 100f;
	}

	internal static float GetArmorFactor(int level)
	{
		if (level <= 0)
		{
			return 1f;
		}
		return 1f + 0.5f * Mathf.Clamp01((float)level / 100f);
	}

	internal static float GetArmorPercent(int level)
	{
		return (GetArmorFactor(level) - 1f) * 100f;
	}

	internal static void OnItemForged(Player player, ItemData item)
	{
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null || item == null || item.m_shared == null)
		{
			return;
		}
		string text = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : "");
		string text2 = item.m_shared.m_name ?? "";
		if (text.IndexOf("arrow", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("flecha", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("seed", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("semilla", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("twig", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("arrow", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("flecha", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("seeds", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("semillas", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("twig", StringComparison.OrdinalIgnoreCase) >= 0 || text == "Cultivator")
		{
			return;
		}
		int num = Mathf.RoundToInt(GetLevel(player));
		if ((text.IndexOf("Club", StringComparison.OrdinalIgnoreCase) >= 0 && num >= 50) || (text.IndexOf("Torch", StringComparison.OrdinalIgnoreCase) >= 0 && num >= 55) || (text.IndexOf("Hammer", StringComparison.OrdinalIgnoreCase) >= 0 && num >= 60) || (text.IndexOf("Hoe", StringComparison.OrdinalIgnoreCase) >= 0 && num >= 65))
		{
			return;
		}
		if (HasSignature(item))
		{
			((Character)player).RaiseSkill(BlacksmithingSkillType, 1f);
			return;
		}
		float level = GetLevel(player);
		float durabilityFactor = GetDurabilityFactor(level);
		int num2 = Mathf.RoundToInt(level);
		string playerName = player.GetPlayerName();
		if (item.m_customData == null)
		{
			item.m_customData = new Dictionary<string, string>();
		}
		item.m_customData["nazhi_blacksmith_durability"] = durabilityFactor.ToString(CultureInfo.InvariantCulture);
		item.m_customData["nazhi_blacksmith_lvl"] = num2.ToString(CultureInfo.InvariantCulture);
		item.m_customData["nazhi_blacksmith_crafter"] = playerName;
		if (SpecializationSystem.IsMasterOf(player, ProfessionType.Blacksmithing) && GetLevel(player) >= 50f)
		{
			item.m_customData["nazhi_blacksmith_master"] = "1";
		}
		else
		{
			item.m_customData.Remove("nazhi_blacksmith_master");
		}
		((Character)player).RaiseSkill(BlacksmithingSkillType, 1f);
	}

	internal static float GetSavedDurabilityFactor(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return 1f;
		}
		if (!item.m_customData.TryGetValue("nazhi_blacksmith_durability", out var value))
		{
			return 1f;
		}
		if (!float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
		{
			return 1f;
		}
		return (result > 1f) ? result : 1f;
	}

	internal static int GetSavedLevel(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return 0;
		}
		if (!item.m_customData.TryGetValue("nazhi_blacksmith_lvl", out var value))
		{
			return 0;
		}
		int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
		return result;
	}

	internal static string GetSavedCrafter(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return null;
		}
		item.m_customData.TryGetValue("nazhi_blacksmith_crafter", out var value);
		return value;
	}

	internal static bool IsMasterForged(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return false;
		}
		string value;
		return item.m_customData.TryGetValue("nazhi_blacksmith_master", out value) && value == "1";
	}

	internal static bool HasSignature(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return false;
		}
		return item.m_customData.ContainsKey("nazhi_blacksmith_durability") || item.m_customData.ContainsKey("nazhi_blacksmith_lvl") || item.m_customData.ContainsKey("nazhi_blacksmith_crafter");
	}

	internal static bool IsExcludedUtility(ItemData item)
	{
		if (item == null)
		{
			return false;
		}
		string text = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : (item.m_shared?.m_name ?? ""));
		return text == "Cultivator";
	}

	internal static void EnsureMinLevel(Player player)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Invalid comparison between Unknown and I4
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		if (!_minLevelApplied && !((Object)(object)player == (Object)null) && (int)BlacksmithingSkillType != 0)
		{
			float skillLevel = ((Character)player).GetSkillLevel(BlacksmithingSkillType);
			if (skillLevel < 1f)
			{
				((Character)player).RaiseSkill(BlacksmithingSkillType, 0.5f);
			}
			_minLevelApplied = true;
		}
	}
}
internal static class BlacksmithingCraftContext
{
	[ThreadStatic]
	private static bool _active;

	[ThreadStatic]
	private static CraftingStation _station;

	[ThreadStatic]
	private static Player _crafter;

	internal static bool Active
	{
		get
		{
			return _active;
		}
		set
		{
			_active = value;
		}
	}

	internal static CraftingStation Station
	{
		get
		{
			return _station;
		}
		set
		{
			_station = value;
		}
	}

	internal static Player Crafter
	{
		get
		{
			return _crafter;
		}
		set
		{
			_crafter = value;
		}
	}

	internal static bool IsForgeStation(CraftingStation station)
	{
		if ((Object)(object)station == (Object)null)
		{
			return false;
		}
		return station.m_name == "$piece_forge" || station.m_name == "$piece_blackforge" || station.m_name == "$piece_workbench";
	}

	internal static void Begin(Player player)
	{
		Active = true;
		Crafter = player;
		Station = ((player != null) ? player.GetCurrentCraftingStation() : null);
	}

	internal static void End()
	{
		Active = false;
		Station = null;
		Crafter = null;
	}
}
[HarmonyPatch(typeof(Player), "Update")]
internal static class Blacksmithing_Patch_EnsureMinLevel
{
	private static void Postfix(Player __instance)
	{
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
		{
			BlacksmithingSystem.EnsureMinLevel(__instance);
		}
	}
}
[HarmonyPatch(typeof(Player), "OnSpawned")]
internal static class Blacksmithing_Patch_OnSpawned
{
	private static void Postfix(Player __instance)
	{
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
		{
			BlacksmithingSystem.ResetMinLevelFlag();
		}
	}
}
[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
internal static class Blacksmithing_Patch_DoCrafting
{
	private static void Prefix(Player player)
	{
		BlacksmithingCraftContext.Begin(player);
	}

	private static void Finalizer()
	{
		BlacksmithingCraftContext.End();
	}
}
[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
{
	typeof(string),
	typeof(int),
	typeof(int),
	typeof(int),
	typeof(long),
	typeof(string),
	typeof(Vector2i),
	typeof(bool)
})]
internal static class Blacksmithing_Patch_AddItem
{
	private static void Postfix(ref ItemData __result)
	{
		if (BlacksmithingCraftContext.Active && __result != null)
		{
			CraftingStation station = BlacksmithingCraftContext.Station;
			Player crafter = BlacksmithingCraftContext.Crafter;
			bool flag = BlacksmithingCraftContext.IsForgeStation(station);
			if ((!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsDedicated()) && !((Object)(object)crafter == (Object)null) && flag)
			{
				BlacksmithingSystem.OnItemForged(crafter, __result);
			}
		}
	}
}
[HarmonyPatch(typeof(ItemData), "GetMaxDurability", new Type[] { })]
internal static class Blacksmithing_Patch_MaxDurability
{
	private static void Postfix(ItemData __instance, ref float __result)
	{
		if (__instance != null)
		{
			float savedDurabilityFactor = BlacksmithingSystem.GetSavedDurabilityFactor(__instance);
			if (savedDurabilityFactor > 1f)
			{
				__result *= savedDurabilityFactor;
			}
		}
	}
}
[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
{
	typeof(ItemData),
	typeof(int),
	typeof(bool),
	typeof(float),
	typeof(int)
})]
internal static class Blacksmithing_Patch_Tooltip
{
	private static void Postfix([HarmonyArgument(0)] ItemData item, ref string __result)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Invalid comparison between Unknown and I4
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Invalid comparison between Unknown and I4
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Invalid comparison between Unknown and I4
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Invalid comparison between Unknown and I4
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Invalid comparison between Unknown and I4
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Invalid comparison between Unknown and I4
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Invalid comparison between Unknown and I4
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Invalid comparison between Unknown and I4
		if (item != null && BlacksmithingSystem.HasSignature(item))
		{
			float savedDurabilityFactor = BlacksmithingSystem.GetSavedDurabilityFactor(item);
			int savedLevel = BlacksmithingSystem.GetSavedLevel(item);
			string text = BlacksmithingSystem.GetSavedCrafter(item) ?? item.m_crafterName;
			SharedData shared = item.m_shared;
			ItemType val = (ItemType)((shared != null) ? ((int)shared.m_itemType) : 0);
			bool flag = (int)val == 3 || (int)val == 14 || (int)val == 4 || (int)val == 19;
			bool flag2 = (int)val == 6 || (int)val == 7 || (int)val == 11 || (int)val == 17;
			if (flag && BlacksmithingSystem.IsExcludedUtility(item))
			{
				flag = false;
			}
			float damagePercent = BlacksmithingSystem.GetDamagePercent(savedLevel);
			float armorPercent = BlacksmithingSystem.GetArmorPercent(savedLevel);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine();
			stringBuilder.AppendLine();
			if (savedDurabilityFactor > 1f)
			{
				stringBuilder.AppendLine($"<color=#00ff00>Durabilidad extra +{(savedDurabilityFactor - 1f) * 100f:0.#}%</color>");
			}
			if (flag && damagePercent > 0.01f)
			{
				stringBuilder.AppendLine($"<color=#ffcc00>Daño aumentado +{damagePercent:0.#}%</color>");
			}
			else if (flag2 && armorPercent > 0.01f)
			{
				stringBuilder.AppendLine($"<color=#ffcc00>Armadura aumentada +{armorPercent:0.#}%</color>");
			}
			string text2 = ((!string.IsNullOrEmpty(text)) ? text : "Desconocido");
			string text3 = ((savedLevel > 0) ? savedLevel.ToString() : "?");
			string text4 = (BlacksmithingSystem.IsMasterForged(item) ? "Maestro Herrero" : "Herrero");
			stringBuilder.AppendLine("<color=#cccccc>Forjado por: " + text2 + " · " + text4 + " nivel " + text3 + "</color>");
			__result += stringBuilder.ToString();
		}
	}
}
[HarmonyPatch(typeof(ItemData), "GetDamage", new Type[]
{
	typeof(int),
	typeof(float)
})]
internal static class Blacksmithing_Patch_Damage
{
	private static void Postfix(ItemData __instance, ref DamageTypes __result)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Invalid comparison between Unknown and I4
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Invalid comparison between Unknown and I4
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Invalid comparison between Unknown and I4
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Invalid comparison between Unknown and I4
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Invalid comparison between Unknown and I4
		if (__instance == null || !BlacksmithingSystem.HasSignature(__instance))
		{
			return;
		}
		SharedData shared = __instance.m_shared;
		ItemType val = (ItemType)((shared != null) ? ((int)shared.m_itemType) : 0);
		if (((int)val == 3 || (int)val == 14 || (int)val == 4 || (int)val == 19 || (int)val == 5) && !BlacksmithingSystem.IsExcludedUtility(__instance))
		{
			int savedLevel = BlacksmithingSystem.GetSavedLevel(__instance);
			float damageFactor = BlacksmithingSystem.GetDamageFactor(savedLevel);
			if (!(damageFactor <= 1f))
			{
				__result.m_blunt *= damageFactor;
				__result.m_slash *= damageFactor;
				__result.m_pierce *= damageFactor;
				__result.m_chop *= damageFactor;
				__result.m_pickaxe *= damageFactor;
				__result.m_fire *= damageFactor;
				__result.m_frost *= damageFactor;
				__result.m_lightning *= damageFactor;
				__result.m_poison *= damageFactor;
				__result.m_spirit *= damageFactor;
			}
		}
	}
}
[HarmonyPatch(typeof(ItemData), "GetArmor", new Type[]
{
	typeof(int),
	typeof(float)
})]
internal static class Blacksmithing_Patch_Armor
{
	private static void Postfix(ItemData __instance, ref float __result)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Invalid comparison between Unknown and I4
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Invalid comparison between Unknown and I4
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Invalid comparison between Unknown and I4
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Invalid comparison between Unknown and I4
		if (__instance == null || !BlacksmithingSystem.HasSignature(__instance))
		{
			return;
		}
		SharedData shared = __instance.m_shared;
		ItemType val = (ItemType)((shared != null) ? ((int)shared.m_itemType) : 0);
		if ((int)val == 6 || (int)val == 7 || (int)val == 11 || (int)val == 17)
		{
			int savedLevel = BlacksmithingSystem.GetSavedLevel(__instance);
			float armorFactor = BlacksmithingSystem.GetArmorFactor(savedLevel);
			if (!(armorFactor <= 1f))
			{
				__result *= armorFactor;
			}
		}
	}
}
[HarmonyPatch(typeof(InventoryGui), "RepairOneItem")]
internal static class Blacksmithing_Patch_Repair
{
	[ThreadStatic]
	private static float _missingPct;

	private static void Prefix(InventoryGui __instance)
	{
		_missingPct = 0f;
		if ((Object)(object)Player.m_localPlayer == (Object)null)
		{
			return;
		}
		CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
		if (!BlacksmithingCraftContext.IsForgeStation(currentCraftingStation))
		{
			return;
		}
		List<ItemData> list = new List<ItemData>();
		((Humanoid)Player.m_localPlayer).GetInventory().GetWornItems(list);
		foreach (ItemData item in list)
		{
			if (__instance.CanRepair(item))
			{
				float maxDurability = item.GetMaxDurability();
				if (maxDurability > 0f)
				{
					_missingPct = Mathf.Clamp01(1f - item.m_durability / maxDurability);
				}
				break;
			}
		}
	}

	private static void Postfix()
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		if (!(_missingPct <= 0.05f))
		{
			Player localPlayer = Player.m_localPlayer;
			if (BlacksmithingCraftContext.IsForgeStation((localPlayer != null) ? localPlayer.GetCurrentCraftingStation() : null))
			{
				((Character)Player.m_localPlayer).RaiseSkill(BlacksmithingSystem.BlacksmithingSkillType, _missingPct * 0.5f);
			}
		}
	}
}
internal static class ConstructionSystem
{
	internal const string ZdoKeyMaxHealth = "nazhi_construction_maxhp";

	internal const string ZdoKeyPaidPrefix = "nazhi_paid_";

	internal const string RpcSetBuilderMult = "nazhi_construction_SetBuilderHP";

	internal const string RpcSetBuilderTier = "nazhi_construction_SetBuilderTier";

	private static readonly Dictionary<long, float> _pendingMult = new Dictionary<long, float>();

	private static readonly Dictionary<long, int> _pendingTier = new Dictionary<long, int>();

	internal static readonly Dictionary<string, int> PendingPaid = new Dictionary<string, int>();

	private static HashSet<Container> _acbContainers = null;

	internal static void RegisterRpc()
	{
		ZRoutedRpc.instance.Register<float>("nazhi_construction_SetBuilderHP", (Action<long, float>)OnRpcSetBuilderMult);
		ZRoutedRpc.instance.Register<float>("nazhi_construction_SetBuilderTier", (Action<long, float>)OnRpcSetBuilderTier);
	}

	private static void OnRpcSetBuilderMult(long senderPeerID, float hpMult)
	{
		ZNet instance = ZNet.instance;
		ZNetPeer val = ((instance != null) ? instance.GetPeer(senderPeerID) : null);
		if (val != null)
		{
			long userID = ((ZDOID)(ref val.m_characterID)).UserID;
			_pendingMult[userID] = hpMult;
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] RPC HP uid={userID} hpMult={hpMult:0.000}");
		}
	}

	private static void OnRpcSetBuilderTier(long senderPeerID, float tierFloat)
	{
		ZNet instance = ZNet.instance;
		ZNetPeer val = ((instance != null) ? instance.GetPeer(senderPeerID) : null);
		if (val != null)
		{
			long userID = ((ZDOID)(ref val.m_characterID)).UserID;
			_pendingTier[userID] = (int)tierFloat;
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] RPC Tier uid={userID} tier={(int)tierFloat}");
		}
	}

	internal static bool TryConsumePendingMult(long uid, out float hpMult)
	{
		if (_pendingMult.TryGetValue(uid, out hpMult))
		{
			_pendingMult.Remove(uid);
			return true;
		}
		hpMult = 1f;
		return false;
	}

	internal static bool TryConsumePendingTier(long uid, out int tier)
	{
		if (_pendingTier.TryGetValue(uid, out tier))
		{
			_pendingTier.Remove(uid);
			return true;
		}
		tier = 0;
		return false;
	}

	internal static float GetCraftingLevel(Player player)
	{
		if ((Object)(object)player == (Object)null)
		{
			return 0f;
		}
		return ((Character)player).GetSkillLevel((SkillType)107);
	}

	internal static float GetHealthMultiplier(Player player)
	{
		return 1f + GetCraftingLevel(player) * 0.01f;
	}

	private static HashSet<Container> GetAcbContainers()
	{
		if (_acbContainers != null)
		{
			return _acbContainers;
		}
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (!assembly.GetName().Name.Contains("AzuCraftyBoxes"))
				{
					continue;
				}
				Type type = assembly.GetType("AzuCraftyBoxes.Util.Functions.Boxes");
				if (!(type == null))
				{
					FieldInfo field = type.GetField("Containers", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if (!(field == null))
					{
						_acbContainers = field.GetValue(null) as HashSet<Container>;
						EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] ACB Boxes.Containers: {_acbContainers?.Count ?? (-1)} contenedores");
						break;
					}
				}
			}
		}
		catch (Exception ex)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)("[Construction] No se pudo obtener Boxes.Containers: " + ex.Message));
		}
		return _acbContainers;
	}

	internal static List<Container> GetNearbyContainers(Player player, float radius = 10f)
	{
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		List<Container> list = new List<Container>();
		if ((Object)(object)player == (Object)null)
		{
			return list;
		}
		HashSet<Container> acbContainers = GetAcbContainers();
		if (acbContainers != null && acbContainers.Count > 0)
		{
			foreach (Container item in acbContainers)
			{
				if (!((Object)(object)item == (Object)null) && item.GetInventory() != null && !((Object)(object)item.m_nview == (Object)null) && item.m_nview.IsValid() && Vector3.Distance(((Component)item).transform.position, ((Component)player).transform.position) <= radius)
				{
					list.Add(item);
				}
			}
			return list;
		}
		int num = ((Piece.s_pieceRayMask != 0) ? Piece.s_pieceRayMask : LayerMask.GetMask(new string[2] { "piece", "piece_nonsolid" }));
		Collider[] array = Physics.OverlapSphere(((Component)player).transform.position, radius, num);
		Collider[] array2 = array;
		foreach (Collider val in array2)
		{
			if (!((Object)(object)val == (Object)null))
			{
				Container componentInParent = ((Component)val).GetComponentInParent<Container>();
				if (!((Object)(object)componentInParent == (Object)null) && !list.Contains(componentInParent) && componentInParent.GetInventory() != null && !((Object)(object)componentInParent.m_nview == (Object)null) && componentInParent.m_nview.IsValid())
				{
					list.Add(componentInParent);
				}
			}
		}
		return list;
	}

	internal static int CountItemsTotal(Player player, string matName, List<Container> containers)
	{
		int num = ((Humanoid)player).m_inventory.CountItems(matName, -1, true);
		foreach (Container container in containers)
		{
			num += container.GetInventory().CountItems(matName, -1, true);
		}
		return num;
	}

	internal static bool ConsumeFromInventoryAndContainers(Player player, string matName, int amount, int itemQuality, List<Container> containers)
	{
		int num = amount;
		int num2 = ((Humanoid)player).m_inventory.CountItems(matName, -1, true);
		if (num2 > 0)
		{
			int num3 = Mathf.Min(num2, num);
			((Humanoid)player).m_inventory.RemoveItem(matName, num3, itemQuality, true);
			num -= num3;
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] Consume inv '{matName}' -{num3} quedan={num}");
		}
		foreach (Container container in containers)
		{
			if (num <= 0)
			{
				break;
			}
			int num4 = container.GetInventory().CountItems(matName, -1, true);
			if (num4 > 0)
			{
				int num5 = Mathf.Min(num4, num);
				container.GetInventory().RemoveItem(matName, num5, itemQuality, true);
				num -= num5;
				EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] Consume container '{((Object)container).name}' '{matName}' -{num5} quedan={num}");
			}
		}
		return num <= 0;
	}

	private static string ZdoPaidKey(string itemName)
	{
		return "nazhi_paid_" + Math.Abs(itemName.GetHashCode()) % 100000;
	}

	internal static void SavePaidToZDO(ZDO zdo, string itemName, int amount)
	{
		if (zdo != null)
		{
			zdo.Set(ZdoPaidKey(itemName), amount);
		}
	}

	internal static int GetPaidFromZDO(ZDO zdo, string itemName)
	{
		if (zdo == null)
		{
			return -1;
		}
		return zdo.GetInt(ZdoPaidKey(itemName), -1);
	}

	internal static bool HasPaidData(ZDO zdo, Piece piece)
	{
		if (zdo == null || (Object)(object)piece == (Object)null)
		{
			return false;
		}
		Requirement[] resources = piece.m_resources;
		foreach (Requirement val in resources)
		{
			if (!((Object)(object)val?.m_resItem == (Object)null) && val.m_amount > 0 && GetPaidFromZDO(zdo, val.m_resItem.m_itemData.m_shared.m_name) >= 0)
			{
				return true;
			}
		}
		return false;
	}

	internal static void SpawnRefundDrops(Piece piece, ZDO zdo, Vector3 position)
	{
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		Requirement[] resources = piece.m_resources;
		foreach (Requirement val in resources)
		{
			if ((Object)(object)val?.m_resItem == (Object)null || val.m_amount <= 0)
			{
				continue;
			}
			string name = val.m_resItem.m_itemData.m_shared.m_name;
			int num = GetPaidFromZDO(zdo, name);
			if (num < 0)
			{
				num = val.m_amount;
			}
			int num2 = Mathf.Max(1, Mathf.RoundToInt((float)num * 0.5f));
			for (int j = 0; j < num2; j++)
			{
				GameObject gameObject = ((Component)val.m_resItem).gameObject;
				if (!((Object)(object)gameObject == (Object)null))
				{
					GameObject val2 = Object.Instantiate<GameObject>(gameObject, position + Random.insideUnitSphere * 0.3f, Quaternion.identity);
					Rigidbody component = val2.GetComponent<Rigidbody>();
					if (component != null)
					{
						component.AddForce(Vector3.up * 2f + Random.insideUnitSphere, (ForceMode)2);
					}
				}
			}
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] Refund '{name}' pagado={num} devuelto={num2}");
		}
	}
}
internal static class ConstructionPlaceContext
{
	private static bool _active;

	internal static bool IsActive => _active;

	internal static void Begin()
	{
		_active = true;
	}

	internal static void End()
	{
		_active = false;
	}
}
[HarmonyPatch(typeof(ZNet), "Awake")]
internal static class Construction_Patch_RegisterRpc
{
	private static void Postfix()
	{
		ConstructionSystem.RegisterRpc();
	}
}
[HarmonyPatch(typeof(Player), "SetPlaceMode", new Type[] { typeof(PieceTable) })]
internal static class Construction_Patch_SetPlaceMode
{
	private static void Postfix(Player __instance)
	{
		if (!((Object)(object)__instance == (Object)null))
		{
			float craftingLevel = ConstructionSystem.GetCraftingLevel(__instance);
			float healthMultiplier = ConstructionSystem.GetHealthMultiplier(__instance);
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] Modo construcción Crafting={craftingLevel:0} HPmult={healthMultiplier:0.000}");
		}
	}
}
[HarmonyPatch(typeof(Player), "SetSelectedPiece", new Type[] { typeof(Vector2Int) })]
internal static class Construction_Patch_SetSelectedPiece
{
	private static void Postfix(Player __instance)
	{
		if (!((Object)(object)__instance == (Object)null))
		{
			Piece selectedPiece = __instance.GetSelectedPiece();
			if (!((Object)(object)selectedPiece == (Object)null))
			{
				WearNTear component = ((Component)selectedPiece).GetComponent<WearNTear>();
				float num = (((Object)(object)component != (Object)null) ? component.m_health : (-1f));
				float healthMultiplier = ConstructionSystem.GetHealthMultiplier(__instance);
				float craftingLevel = ConstructionSystem.GetCraftingLevel(__instance);
				EinjarheimProfessionsPlugin.Log.LogInfo((object)("[Construction] Pieza=" + ((Object)selectedPiece).name + " BaseHP=" + ((num >= 0f) ? num.ToString("0.0") : "N/A") + " " + string.Format("BuffedHP={0} Crafting={1:0}", (num >= 0f) ? (num * healthMultiplier).ToString("0.0") : "N/A", craftingLevel)));
			}
		}
	}
}
[HarmonyPatch(typeof(Player), "PlacePiece", new Type[]
{
	typeof(Piece),
	typeof(Vector3),
	typeof(Quaternion),
	typeof(bool)
})]
internal static class Construction_Patch_PlacePiece
{
	private static void Prefix(Player __instance, Piece piece)
	{
		if ((Object)(object)__instance == (Object)null || (Object)(object)piece == (Object)null)
		{
			return;
		}
		ConstructionPlaceContext.Begin();
		__instance.m_customData["ACB_PreventPulling"] = "0";
		float healthMultiplier = ConstructionSystem.GetHealthMultiplier(__instance);
		int num = (int)(ConstructionSystem.GetCraftingLevel(__instance) / 10f);
		if (ZRoutedRpc.instance != null)
		{
			long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
			if (healthMultiplier > 1f)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "nazhi_construction_SetBuilderHP", new object[1] { healthMultiplier });
			}
			if (num > 0)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "nazhi_construction_SetBuilderTier", new object[1] { (float)num });
			}
		}
	}

	private static void Postfix(Player __instance, Piece piece)
	{
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)piece == (Object)null))
		{
			ConstructionPlaceContext.End();
			__instance.m_customData["ACB_PreventPulling"] = "1";
			if (ConstructionSystem.PendingPaid.Count > 0)
			{
				Dictionary<string, int> paid = new Dictionary<string, int>(ConstructionSystem.PendingPaid);
				string pieceName = ((Object)piece).name.Replace("(Clone)", "").Trim();
				ConstructionSystem.PendingPaid.Clear();
				((MonoBehaviour)EinjarheimProfessionsPlugin.Instance).StartCoroutine(DelayedFlush(__instance, pieceName, paid));
			}
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] PlacePiece '{((Object)piece).name}' lvl={ConstructionSystem.GetCraftingLevel(__instance):0}");
		}
	}

	private static IEnumerator DelayedFlush(Player player, string pieceName, Dictionary<string, int> paid)
	{
		yield return null;
		List<Piece> nearby = new List<Piece>();
		Piece.GetAllPiecesInRadius(((Component)player).transform.position, 8f, nearby);
		float bestDist = 8f;
		ZDO bestZdo = null;
		foreach (Piece p in nearby)
		{
			if ((Object)(object)p == (Object)null || ((Object)p).name.Replace("(Clone)", "").Trim() != pieceName)
			{
				continue;
			}
			WearNTear wt = ((Component)p).GetComponent<WearNTear>();
			if (!((Object)(object)wt == (Object)null) && !((Object)(object)wt.m_nview == (Object)null) && wt.m_nview.IsValid())
			{
				float dist = Vector3.Distance(((Component)p).transform.position, ((Component)player).transform.position);
				if (dist < bestDist)
				{
					bestDist = dist;
					bestZdo = wt.m_nview.GetZDO();
				}
			}
		}
		if (bestZdo == null)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)("[Construction] DelayedFlush: no ZDO para '" + pieceName + "'"));
			yield break;
		}
		foreach (KeyValuePair<string, int> kvp in paid)
		{
			ConstructionSystem.SavePaidToZDO(bestZdo, kvp.Key, kvp.Value);
		}
		EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] DelayedFlush OK: {paid.Count} costes ZDO uid={bestZdo.m_uid}");
	}
}
[HarmonyPatch(typeof(Piece), "SetCreator", new Type[] { typeof(long) })]
internal static class Construction_Patch_SetCreator
{
	private static void Postfix(Piece __instance, long uid)
	{
		try
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			WearNTear component = ((Component)__instance).GetComponent<WearNTear>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.m_nview == (Object)null || !component.m_nview.IsValid())
			{
				return;
			}
			ZDO zDO = component.m_nview.GetZDO();
			if (zDO == null || zDO.GetFloat("nazhi_construction_maxhp", 0f) > 0f)
			{
				return;
			}
			float hpMult = 1f;
			if (!ConstructionSystem.TryConsumePendingMult(uid, out hpMult))
			{
				Player player = Player.GetPlayer(uid);
				if ((Object)(object)player != (Object)null)
				{
					hpMult = ConstructionSystem.GetHealthMultiplier(player);
				}
			}
			if (!(hpMult <= 1f))
			{
				float health = component.m_health;
				if (!(health <= 0f))
				{
					float num = (component.m_health = health * hpMult);
					zDO.Set("nazhi_construction_maxhp", num);
					EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] SetCreator HP '{((Object)__instance).name}' {health:0}→{num:0} x{hpMult:0.000}");
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogError((object)$"[Construction] Error SetCreator: {arg}");
		}
	}
}
[HarmonyPatch(typeof(WearNTear), "Awake")]
internal static class Construction_Patch_WearNTear_Awake
{
	private static void Postfix(WearNTear __instance)
	{
		try
		{
			if ((Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid())
			{
				return;
			}
			ZDO zDO = __instance.m_nview.GetZDO();
			if (zDO != null)
			{
				float num = zDO.GetFloat("nazhi_construction_maxhp", 0f);
				if (!(num <= 0f))
				{
					float health = __instance.m_health;
					__instance.m_health = num;
					EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] WearNTear.Awake restore '{((Object)__instance).name}' {health:0}→{num:0}");
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogError((object)$"[Construction] Error WearNTear.Awake: {arg}");
		}
	}
}
[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
{
	typeof(Piece),
	typeof(RequirementMode)
})]
internal static class Construction_Patch_HaveRequirements
{
	private static bool Prefix(Player __instance, Piece piece, RequirementMode mode, ref bool __result)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Invalid comparison between Unknown and I4
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)null || (Object)(object)piece == (Object)null)
		{
			return true;
		}
		if ((int)mode > 0)
		{
			return true;
		}
		if (Object.op_Implicit((Object)(object)piece.m_craftingStation) && !Object.op_Implicit((Object)(object)CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, ((Component)__instance).transform.position)) && !ZoneSystem.instance.GetGlobalKey((GlobalKeys)22))
		{
			__result = false;
			return false;
		}
		if (piece.m_dlc.Length > 0 && !DLCMan.instance.IsDLCInstalled(piece.m_dlc))
		{
			__result = false;
			return false;
		}
		if (ZoneSystem.instance.GetGlobalKey(piece.FreeBuildKey()))
		{
			__result = true;
			return false;
		}
		List<Container> nearbyContainers = ConstructionSystem.GetNearbyContainers(__instance);
		Requirement[] resources = piece.m_resources;
		foreach (Requirement val in resources)
		{
			if (Object.op_Implicit((Object)(object)val.m_resItem) && val.m_amount > 0)
			{
				string name = val.m_resItem.m_itemData.m_shared.m_name;
				int num = ConstructionSystem.CountItemsTotal(__instance, name, nearbyContainers);
				if (num < val.m_amount)
				{
					__result = false;
					return false;
				}
			}
		}
		__result = true;
		return false;
	}
}
[HarmonyPatch(typeof(Player), "ConsumeResources", new Type[]
{
	typeof(Requirement[]),
	typeof(int),
	typeof(int),
	typeof(int)
})]
[HarmonyPriority(800)]
[HarmonyBefore(new string[] { "Azumatt.AzuCraftyBoxes" })]
internal static class Construction_Patch_ConsumeResources
{
	private static bool Prefix(Player __instance, Requirement[] requirements, int qualityLevel, int itemQuality, int multiplier)
	{
		if (!ConstructionPlaceContext.IsActive)
		{
			return true;
		}
		if ((Object)(object)__instance == (Object)null || requirements == null)
		{
			return false;
		}
		List<Container> nearbyContainers = ConstructionSystem.GetNearbyContainers(__instance);
		EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] ConsumeResources containers={nearbyContainers.Count}");
		ConstructionSystem.PendingPaid.Clear();
		foreach (Requirement val in requirements)
		{
			if (Object.op_Implicit((Object)(object)val?.m_resItem))
			{
				int num = val.m_amount * multiplier;
				if (num > 0)
				{
					string name = val.m_resItem.m_itemData.m_shared.m_name;
					ConstructionSystem.ConsumeFromInventoryAndContainers(__instance, name, num, itemQuality, nearbyContainers);
					ConstructionSystem.PendingPaid[name] = num;
				}
			}
		}
		return false;
	}
}
[HarmonyPatch(typeof(Piece), "DropResources")]
internal static class Construction_Patch_DropResources
{
	private static bool Prefix(Piece __instance)
	{
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			WearNTear component = ((Component)__instance).GetComponent<WearNTear>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.m_nview == (Object)null || !component.m_nview.IsValid())
			{
				return true;
			}
			ZDO zDO = component.m_nview.GetZDO();
			if (zDO == null)
			{
				return true;
			}
			if (!ConstructionSystem.HasPaidData(zDO, __instance))
			{
				return true;
			}
			ConstructionSystem.SpawnRefundDrops(__instance, zDO, ((Component)__instance).transform.position + Vector3.up * 0.5f);
			return false;
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogError((object)$"[Construction] Error DropResources: {arg}");
			return true;
		}
	}
}
[HarmonyPatch(typeof(Hud), "SetupPieceInfo")]
internal static class Construction_Patch_HudPieceInfo
{
	private static void Postfix(Hud __instance, Piece piece)
	{
		try
		{
			if ((Object)(object)piece == (Object)null || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			TMP_Text pieceDescription = __instance.m_pieceDescription;
			if (!((Object)(object)pieceDescription == (Object)null))
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null))
				{
					float craftingLevel = ConstructionSystem.GetCraftingLevel(localPlayer);
					float healthMultiplier = ConstructionSystem.GetHealthMultiplier(localPlayer);
					WearNTear component = ((Component)piece).GetComponent<WearNTear>();
					float num = (((Object)(object)component != (Object)null) ? component.m_health : 0f);
					float num2 = num * healthMultiplier - num;
					string text = Localization.instance.Localize(piece.m_description);
					pieceDescription.text = text + $"\n<size=16><color=#FFD700>Crafting: Level {craftingLevel:0}</color></size>" + $"\n<size=16><color=#32CD32>Health: {num:0}</color> (+<color=#FFD700>{num2:0}</color>)</size>";
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogError((object)$"[Construction] Error HUD SetupPieceInfo: {arg}");
		}
	}
}
[HarmonyPatch(typeof(InventoryGui), "SetupRequirement", new Type[]
{
	typeof(Transform),
	typeof(Requirement),
	typeof(Player),
	typeof(bool),
	typeof(int),
	typeof(int)
})]
internal static class Construction_Patch_SetupRequirement
{
	private static void Postfix(Transform elementRoot, Requirement req, Player player, bool craft, int quality, int craftMultiplier)
	{
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)req?.m_resItem == (Object)null) && !craft && quality == 0)
			{
				Transform obj = elementRoot.Find("res_amount");
				TMP_Text val = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
				if (!((Object)(object)val == (Object)null))
				{
					List<Container> nearbyContainers = ConstructionSystem.GetNearbyContainers(player);
					int num = ConstructionSystem.CountItemsTotal(player, req.m_resItem.m_itemData.m_shared.m_name, nearbyContainers);
					bool flag = (!craft && ZoneSystem.instance.GetGlobalKey((GlobalKeys)19)) || (craft && ZoneSystem.instance.GetGlobalKey((GlobalKeys)20));
					((Graphic)val).color = ((req.m_amount <= 0 || num >= req.m_amount || flag) ? Color.white : ((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.white));
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogError((object)$"[Construction] Error SetupRequirement: {arg}");
		}
	}
}
[HarmonyPatch(typeof(Piece), "SetCreator", new Type[] { typeof(long) })]
internal static class Construction_Patch_SetCreator_Support
{
	private static void Postfix(Piece __instance, long uid)
	{
		try
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			WearNTear component = ((Component)__instance).GetComponent<WearNTear>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.m_nview == (Object)null || !component.m_nview.IsValid())
			{
				return;
			}
			ZDO zDO = component.m_nview.GetZDO();
			if (zDO == null || zDO.GetFloat("nazhi_construction_maxsupport", 0f) > 0f)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && localPlayer.GetPlayerID() == uid)
			{
				float craftingLevel = ConstructionSystem.GetCraftingLevel(localPlayer);
				int num = (int)(craftingLevel / 10f);
				if (num > 0)
				{
					float value = EinjarheimProfessionsPlugin.ConstructionSupportPerLevel.Value;
					float num2 = 1f + (float)num * value;
					float num3 = 1f + (float)num * (value * 0.5f);
					float num4 = default(float);
					float num5 = default(float);
					float num6 = default(float);
					float num7 = default(float);
					component.GetMaterialProperties(ref num4, ref num5, ref num6, ref num7);
					float num8 = num4 * num2;
					float num9 = num7 / num3;
					float num10 = num6 / num3;
					zDO.Set("nazhi_construction_maxsupport", num8);
					zDO.Set("nazhi_construction_maxsupport_vloss", num9);
					zDO.Set("nazhi_construction_maxsupport_hloss", num10);
					EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Construction] SetCreator Support '{((Object)__instance).name}' tier={num} maxSupport={num8:0} vLoss={num9:0.000} hLoss={num10:0.000}");
				}
			}
		}
		catch (Exception arg)
		{
			EinjarheimProfessionsPlugin.Log.LogError((object)$"[Construction] Error SetCreator_Support: {arg}");
		}
	}
}
internal static class CookingSystem
{
	internal struct ChefInfo
	{
		public long ChefId;

		public string ChefName;

		public int ChefLv;

		public int Count;
	}

	internal const string CD_CHEF_NAME = "nazhi_chef_name";

	internal const string CD_CHEF_ID = "nazhi_chef_id";

	internal const string CD_CHEF_LV = "nazhi_chef_cooking_lv";

	internal const string CD_CHEF_MASTER = "nazhi_chef_master";

	internal const string CD_CHEF_SPEC = "nazhi_chef_spec";

	internal const string ZDO_FOOD0_NAME = "nazhi_food0_name";

	internal const string ZDO_FOOD0_LV = "nazhi_food0_chef_lv";

	internal const string ZDO_FOOD0_CHEF = "nazhi_food0_chef_name";

	internal const string ZDO_FOOD1_NAME = "nazhi_food1_name";

	internal const string ZDO_FOOD1_LV = "nazhi_food1_chef_lv";

	internal const string ZDO_FOOD1_CHEF = "nazhi_food1_chef_name";

	internal const string ZDO_FOOD2_NAME = "nazhi_food2_name";

	internal const string ZDO_FOOD2_LV = "nazhi_food2_chef_lv";

	internal const string ZDO_FOOD2_CHEF = "nazhi_food2_chef_name";

	internal const int MASTER_COOKING_MIN_LEVEL = 50;

	internal static readonly Dictionary<string, ChefInfo> StationSlotChef = new Dictionary<string, ChefInfo>();

	internal static readonly Dictionary<long, Dictionary<string, ChefInfo>> PendingByPlayer = new Dictionary<long, Dictionary<string, ChefInfo>>();

	internal static bool IsFood(ItemData item)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Invalid comparison between Unknown and I4
		SharedData val = item?.m_shared;
		if (val == null)
		{
			return false;
		}
		if ((int)val.m_itemType != 2)
		{
			return false;
		}
		return val.m_food > 0f || val.m_foodStamina > 0f || val.m_foodEitr > 0f;
	}

	internal static int GetVanillaCookingLevel(Player p)
	{
		if ((Object)(object)p == (Object)null)
		{
			return 1;
		}
		return Mathf.Max(1, Mathf.FloorToInt(((Character)p).GetSkillLevel((SkillType)105)));
	}

	internal static int BonusFromChefLevel(int chefLv)
	{
		return Mathf.Max(1, chefLv);
	}

	internal static void CalculateBonus(ItemData item, int chefLv, out int bonusHp, out int bonusSt, out int bonusEi)
	{
		bonusHp = 0;
		bonusSt = 0;
		bonusEi = 0;
		if (item?.m_shared == null)
		{
			return;
		}
		int num = BonusFromChefLevel(chefLv);
		float food = item.m_shared.m_food;
		float foodStamina = item.m_shared.m_foodStamina;
		float foodEitr = item.m_shared.m_foodEitr;
		if (foodEitr > 0f)
		{
			if (food > 0f)
			{
				bonusHp = Mathf.RoundToInt((float)num * 0.2f);
			}
			if (foodStamina > 0f)
			{
				bonusSt = Mathf.RoundToInt((float)num * 0.2f);
			}
			bonusEi = Mathf.RoundToInt((float)num * 0.5f);
		}
		else if (food > 0f && foodStamina > 0f)
		{
			if (food >= foodStamina)
			{
				bonusHp = Mathf.RoundToInt((float)num * 0.8f);
				bonusSt = Mathf.RoundToInt((float)num * 0.2f);
			}
			else
			{
				bonusSt = Mathf.RoundToInt((float)num * 0.8f);
				bonusHp = Mathf.RoundToInt((float)num * 0.2f);
			}
		}
		else if (food > 0f)
		{
			bonusHp = num;
		}
		else if (foodStamina > 0f)
		{
			bonusSt = num;
		}
	}

	internal static void StampChef(ItemData item, ChefInfo chef)
	{
		if (item != null)
		{
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			item.m_customData["nazhi_chef_name"] = chef.ChefName;
			item.m_customData["nazhi_chef_id"] = chef.ChefId.ToString();
			item.m_customData["nazhi_chef_cooking_lv"] = chef.ChefLv.ToString();
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == chef.ChefId && SpecializationSystem.IsMasterOf(localPlayer, ProfessionType.Cooking))
			{
				item.m_customData["nazhi_chef_spec"] = "1";
			}
			else
			{
				item.m_customData.Remove("nazhi_chef_spec");
			}
			if ((Object)(object)localPlayer != (Object)null && localPlayer.GetPlayerID() == chef.ChefId && SpecializationSystem.IsMasterOf(localPlayer, ProfessionType.Cooking) && GetVanillaCookingLevel(localPlayer) >= 50)
			{
				item.m_customData["nazhi_chef_master"] = "1";
			}
			else
			{
				item.m_customData.Remove("nazhi_chef_master");
			}
		}
	}

	internal static bool IsChefMaster(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return false;
		}
		string value;
		return item.m_customData.TryGetValue("nazhi_chef_master", out value) && value == "1";
	}

	internal static ChefInfo BuildChef(Player chef)
	{
		return new ChefInfo
		{
			ChefId = chef.GetPlayerID(),
			ChefName = chef.GetPlayerName(),
			ChefLv = GetVanillaCookingLevel(chef),
			Count = 1
		};
	}

	internal static string SlotKey(CookingStation station, int slot)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		ZNetView nview = station.m_nview;
		ZDOID? val = ((nview == null) ? ((ZDOID?)null) : nview.GetZDO()?.m_uid);
		return $"{val}_{slot}";
	}

	internal static void SetPending(Player chef, string itemSharedName, int chefLv, string chefName)
	{
		if (!((Object)(object)chef == (Object)null) && !string.IsNullOrEmpty(itemSharedName))
		{
			long playerID = chef.GetPlayerID();
			if (!PendingByPlayer.TryGetValue(playerID, out var value) || value == null)
			{
				value = new Dictionary<string, ChefInfo>();
				PendingByPlayer[playerID] = value;
			}
			ChefInfo value3;
			ChefInfo value2 = new ChefInfo
			{
				ChefId = chef.GetPlayerID(),
				ChefName = chefName,
				ChefLv = chefLv,
				Count = ((!value.TryGetValue(itemSharedName, out value3)) ? 1 : (value3.Count + 1))
			};
			value[itemSharedName] = value2;
		}
	}

	internal static void SetPending(Player chef, string itemSharedName)
	{
		if (!((Object)(object)chef == (Object)null) && !string.IsNullOrEmpty(itemSharedName))
		{
			long playerID = chef.GetPlayerID();
			if (!PendingByPlayer.TryGetValue(playerID, out var value) || value == null)
			{
				value = new Dictionary<string, ChefInfo>();
				PendingByPlayer[playerID] = value;
			}
			if (value.TryGetValue(itemSharedName, out var value2))
			{
				value2.Count++;
				value[itemSharedName] = value2;
			}
			else
			{
				ChefInfo value3 = BuildChef(chef);
				value3.Count = 1;
				value[itemSharedName] = value3;
			}
		}
	}

	internal static bool TryConsumePending(Player receiver, string itemSharedName, out ChefInfo chef)
	{
		chef = default(ChefInfo);
		if ((Object)(object)receiver == (Object)null || string.IsNullOrEmpty(itemSharedName))
		{
			return false;
		}
		long playerID = receiver.GetPlayerID();
		if (!PendingByPlayer.TryGetValue(playerID, out var value) || value == null)
		{
			return false;
		}
		if (!value.TryGetValue(itemSharedName, out chef))
		{
			return false;
		}
		if (chef.Count <= 1)
		{
			value.Remove(itemSharedName);
		}
		else
		{
			ChefInfo value2 = chef;
			value2.Count--;
			value[itemSharedName] = value2;
		}
		return true;
	}

	internal static void ClearPending(long playerID)
	{
		PendingByPlayer.Remove(playerID);
	}

	internal static int GetChefLevelFromItem(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return 1;
		}
		if (item.m_customData.TryGetValue("nazhi_chef_cooking_lv", out var value) && int.TryParse(value, out var result))
		{
			return Mathf.Max(1, result);
		}
		return 1;
	}

	internal static string GetChefNameFromItem(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return "Desconocido";
		}
		if (item.m_customData.TryGetValue("nazhi_chef_name", out var value) && !string.IsNullOrEmpty(value))
		{
			return value;
		}
		return "Desconocido";
	}

	internal static string GetChefNameRaw(ItemData item)
	{
		if (item?.m_customData == null)
		{
			return "";
		}
		item.m_customData.TryGetValue("nazhi_chef_name", out var value);
		return value ?? "";
	}

	internal static void SaveFoodSlotToProfile(Player p, int slot, string foodName, int chefLv, string chefName)
	{
		if ((Object)(object)p == (Object)null)
		{
			return;
		}
		string text = $"naz_food{slot}_name";
		string text2 = $"naz_food{slot}_lv";
		string text3 = $"naz_food{slot}_chef";
		try
		{
			MethodInfo method = typeof(Player).GetMethod("SetCustomData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method != null)
			{
				method.Invoke(p, new object[2]
				{
					text,
					foodName ?? ""
				});
				method.Invoke(p, new object[2]
				{
					text2,
					Mathf.Max(1, chefLv).ToString()
				});
				method.Invoke(p, new object[2]
				{
					text3,
					chefName ?? ""
				});
			}
			else if (typeof(Player).GetField("m_customData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(p) is Dictionary<string, string> dictionary)
			{
				dictionary[text] = foodName ?? "";
				dictionary[text2] = Mathf.Max(1, chefLv).ToString();
				dictionary[text3] = chefName ?? "";
			}
			TryInvokeGameSaveProfile();
		}
		catch (Exception ex)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)("[Cooking] SaveFoodSlotToProfile error: " + ex.Message));
		}
	}

	internal static bool LoadFoodSlotFromProfile(Player p, int slot, out string foodName, out int chefLv, out string chefName)
	{
		foodName = "";
		chefLv = 1;
		chefName = "Desconocido";
		if ((Object)(object)p == (Object)null)
		{
			return false;
		}
		string text = $"naz_food{slot}_name";
		string text2 = $"naz_food{slot}_lv";
		string text3 = $"naz_food{slot}_chef";
		try
		{
			MethodInfo method = typeof(Player).GetMethod("GetCustomData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method != null)
			{
				foodName = (method.Invoke(p, new object[1] { text }) as string) ?? "";
				string s = (method.Invoke(p, new object[1] { text2 }) as string) ?? "1";
				chefName = (method.Invoke(p, new object[1] { text3 }) as string) ?? "Desconocido";
				int.TryParse(s, out chefLv);
			}
			else if (typeof(Player).GetField("m_customData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(p) is Dictionary<string, string> dictionary)
			{
				dictionary.TryGetValue(text, out foodName);
				dictionary.TryGetValue(text3, out chefName);
				if (dictionary.TryGetValue(text2, out var value))
				{
					int.TryParse(value, out chefLv);
				}
			}
		}
		catch (Exception ex)
		{
			EinjarheimProfessionsPlugin.Log.LogWarning((object)("[Cooking] LoadFoodSlotFromProfile error: " + ex.Message));
		}
		chefLv = Mathf.Max(1, chefLv);
		if (string.IsNullOrEmpty(foodName))
		{
			return false;
		}
		if (string.IsNullOrEmpty(chefName))
		{
			chefName = "Desconocido";
		}
		return true;
	}

	private static bool TryInvokeGameSaveProfile()
	{
		try
		{
			Game instance = Game.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			Type typeFromHandle = typeof(Game);
			MethodInfo methodInfo = typeFromHandle.GetMethod("SavePlayerProfile", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? typeFromHandle.GetMethod("SavePlayerProfileThreadsafe", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (methodInfo != null)
			{
				methodInfo.Invoke(instance, null);
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	internal static bool TryGetChefFromZDO(Player p, int slot, out string foodName, out int chefLv, out string chefName)
	{
		foodName = "";
		chefLv = 1;
		chefName = "Desconocido";
		if ((Object)(object)p == (Object)null)
		{
			return false;
		}
		ZNetView nview = ((Character)p).m_nview;
		ZDO val = ((nview != null) ? nview.GetZDO() : null);
		if (val == null)
		{
			return false;
		}
		switch (slot)
		{
		case 0:
			foodName = val.GetString("nazhi_food0_name", "");
			chefLv = Mathf.Max(1, val.GetInt("nazhi_food0_chef_lv", 1));
			chefName = val.GetString("nazhi_food0_chef_name", "Desconocido");
			break;
		case 1:
			foodName = val.GetString("nazhi_food1_name", "");
			chefLv = Mathf.Max(1, val.GetInt("nazhi_food1_chef_lv", 1));
			chefName = val.GetString("nazhi_food1_chef_name", "Desconocido");
			break;
		case 2:
			foodName = val.GetString("nazhi_food2_name", "");
			chefLv = Mathf.Max(1, val.GetInt("nazhi_food2_chef_lv", 1));
			chefName = val.GetString("nazhi_food2_chef_name", "Desconocido");
			break;
		}
		if (string.IsNullOrEmpty(foodName))
		{
			return false;
		}
		if (string.IsNullOrEmpty(chefName))
		{
			chefName = "Desconocido";
		}
		return true;
	}

	internal static void EnsureStampedFromFallback(ItemData item, int chefLv, string chefName)
	{
		if (item != null)
		{
			if (item.m_customData == null)
			{
				item.m_customData = new Dictionary<string, string>();
			}
			item.m_customData["nazhi_chef_cooking_lv"] = Mathf.Max(1, chefLv).ToString();
			item.m_customData["nazhi_chef_name"] = (string.IsNullOrEmpty(chefName) ? "Desconocido" : chefName);
		}
	}
}
[HarmonyPatch(typeof(ZNet), "Disconnect")]
internal static class Cooking_Patch_PeerDisconnect
{
	private static void Prefix(ZNetPeer peer)
	{
		if (peer != null)
		{
			long userID = ((ZDOID)(ref peer.m_characterID)).UserID;
			if (userID != 0)
			{
				CookingSystem.ClearPending(userID);
			}
		}
	}
}
[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
internal static class Cooking_Patch_Caldero_Pending
{
	private static void Prefix(InventoryGui __instance, Player player)
	{
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		Recipe craftRecipe = __instance.m_craftRecipe;
		if (craftRecipe?.m_item?.m_itemData != null)
		{
			ItemData itemData = craftRecipe.m_item.m_itemData;
			if (CookingSystem.IsFood(itemData))
			{
				CookingSystem.SetPending(player, itemData.m_shared.m_name);
			}
		}
	}
}
[HarmonyPatch(typeof(CookingStation), "CookItem")]
internal static class Cooking_Patch_CookItem
{
	private static void Prefix(CookingStation __instance, Humanoid user, ItemData item)
	{
		if ((Object)(object)user == (Object)null || item == null)
		{
			return;
		}
		Player val = (Player)(object)((user is Player) ? user : null);
		if (!((Object)(object)val == (Object)null) && (CookingSystem.IsFood(item) || __instance.IsItemAllowed(item)))
		{
			int freeSlot = __instance.GetFreeSlot();
			if (freeSlot >= 0)
			{
				string key = CookingSystem.SlotKey(__instance, freeSlot);
				CookingSystem.StationSlotChef[key] = new CookingSystem.ChefInfo
				{
					ChefId = val.GetPlayerID(),
					ChefName = val.GetPlayerName(),
					ChefLv = CookingSystem.GetVanillaCookingLevel(val),
					Count = 1
				};
				EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Cooking] CookItem slot={freeSlot} chef={val.GetPlayerName()} lv={CookingSystem.GetVanillaCookingLevel(val)}");
			}
		}
	}
}
[HarmonyPatch(typeof(CookingStation), "SpawnItem")]
internal static class Cooking_Patch_Station_SpawnItem
{
	private static void Prefix(CookingStation __instance, string name, int slot)
	{
		if (string.IsNullOrEmpty(name))
		{
			return;
		}
		ObjectDB instance = ObjectDB.instance;
		GameObject val = ((instance != null) ? instance.GetItemPrefab(name) : null);
		ItemData val2 = ((val == null) ? null : val.GetComponent<ItemDrop>()?.m_itemData);
		if (val2 == null || !CookingSystem.IsFood(val2))
		{
			return;
		}
		string text = val2.m_shared?.m_name;
		if (string.IsNullOrEmpty(text))
		{
			return;
		}
		string key = CookingSystem.SlotKey(__instance, slot);
		if (CookingSystem.StationSlotChef.TryGetValue(key, out var value))
		{
			CookingSystem.StationSlotChef.Remove(key);
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				CookingSystem.SetPending(localPlayer, text, value.ChefLv, value.ChefName);
				EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Cooking] SpawnItem slot={slot} '{text}' chef={value.ChefName} lv={value.ChefLv}");
			}
		}
	}
}
[HarmonyPatch]
internal static class Cooking_Patch_Inventory_AddItem_Stamp
{
	private static IEnumerable<MethodBase> TargetMethods()
	{
		return from m in typeof(Inventory).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			where m.Name == "AddItem"
			select m;
	}

	private static void Prefix(Inventory __instance, ref object __state, params object[] __args)
	{
		__state = null;
		if (__instance == null || __args == null)
		{
			return;
		}
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null || ((Humanoid)localPlayer).GetInventory() != __instance)
		{
			return;
		}
		foreach (object obj in __args)
		{
			ItemData val = (ItemData)((obj is ItemData) ? obj : null);
			if (val != null && CookingSystem.IsFood(val))
			{
				string name = val.m_shared.m_name;
				if (!CookingSystem.TryConsumePending(localPlayer, name, out var chef))
				{
					break;
				}
				CookingSystem.StampChef(val, chef);
				return;
			}
		}
		foreach (object obj2 in __args)
		{
			if (obj2 is string text && !string.IsNullOrEmpty(text))
			{
				__state = text;
				break;
			}
		}
	}

	private static void Postfix(Inventory __instance, object __state)
	{
		if (__instance == null || __state == null)
		{
			return;
		}
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null || ((Humanoid)localPlayer).GetInventory() != __instance)
		{
			return;
		}
		string text = __state as string;
		if (string.IsNullOrEmpty(text))
		{
			return;
		}
		string sharedName = text;
		if (!sharedName.StartsWith("$"))
		{
			ObjectDB instance = ObjectDB.instance;
			GameObject val = ((instance != null) ? instance.GetItemPrefab(sharedName) : null);
			ItemDrop val2 = ((val != null) ? val.GetComponent<ItemDrop>() : null);
			if (val2?.m_itemData?.m_shared != null)
			{
				sharedName = val2.m_itemData.m_shared.m_name;
			}
		}
		if (CookingSystem.TryConsumePending(localPlayer, sharedName, out var chef))
		{
			ItemData val3 = ((IEnumerable<ItemData>)__instance.GetAllItems()).LastOrDefault((Func<ItemData, bool>)((ItemData i) => i?.m_shared?.m_name == sharedName));
			if (val3 != null)
			{
				CookingSystem.StampChef(val3, chef);
			}
		}
	}
}
[HarmonyPatch]
internal static class Cooking_Patch_EatFood_Save
{
	private static IEnumerable<MethodBase> TargetMethods()
	{
		return from m in typeof(Player).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			where m.Name == "EatFood"
			select m;
	}

	private static void Prefix(Player __instance, ref object __state, params object[] __args)
	{
		__state = null;
		if ((Object)(object)__instance == (Object)null || __args == null)
		{
			return;
		}
		foreach (object obj in __args)
		{
			ItemData val = (ItemData)((obj is ItemData) ? obj : null);
			if (val != null && CookingSystem.IsFood(val))
			{
				__state = val;
				break;
			}
		}
	}

	private static void Postfix(Player __instance, object __state)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return;
		}
		ItemData val = (ItemData)((__state is ItemData) ? __state : null);
		if (val == null || !CookingSystem.IsFood(val))
		{
			return;
		}
		ZNetView nview = ((Character)__instance).m_nview;
		ZDO val2 = ((nview != null) ? nview.GetZDO() : null);
		if (val2 == null)
		{
			return;
		}
		int chefLevelFromItem = CookingSystem.GetChefLevelFromItem(val);
		string chefNameFromItem = CookingSystem.GetChefNameFromItem(val);
		string name = val.m_shared.m_name;
		IList<Food> list = (IList<Food>)AccessTools.Field(typeof(Player), "m_foods").GetValue(__instance);
		if (list == null)
		{
			return;
		}
		for (int i = 0; i < Mathf.Min(3, list.Count); i++)
		{
			if (!((list[i]?.m_item)?.m_shared?.m_name != name))
			{
				GetZdoKeys(i, out var name2, out var lv, out var chef);
				val2.Set(name2, name);
				val2.Set(lv, chefLevelFromItem);
				val2.Set(chef, chefNameFromItem);
				CookingSystem.SaveFoodSlotToProfile(__instance, i, name, chefLevelFromItem, chefNameFromItem);
				break;
			}
		}
		ApplyChefMasterSE(__instance, val);
	}

	private static void GetZdoKeys(int slot, out string name, out string lv, out string chef)
	{
		switch (slot)
		{
		case 0:
			name = "nazhi_food0_name";
			lv = "nazhi_food0_chef_lv";
			chef = "nazhi_food0_chef_name";
			break;
		case 1:
			name = "nazhi_food1_name";
			lv = "nazhi_food1_chef_lv";
			chef = "nazhi_food1_chef_name";
			break;
		default:
			name = "nazhi_food2_name";
			lv = "nazhi_food2_chef_lv";
			chef = "nazhi_food2_chef_name";
			break;
		}
	}

	private static void ApplyChefMasterSE(Player player, ItemData item)
	{
		if (CookingSystem.IsChefMaster(item) && !((Object)(object)EinjarheimProfessionsPlugin.ChefRegenHP == (Object)null) && !((Object)(object)EinjarheimProfessionsPlugin.ChefRegenStamina == (Object)null) && !((Object)(object)EinjarheimProfessionsPlugin.ChefRegenEitr == (Object)null))
		{
			SharedData shared = item.m_shared;
			float foodBurnTime = shared.m_foodBurnTime;
			SE_Stats val = ((shared.m_foodEitr > 0f) ? EinjarheimProfessionsPlugin.ChefRegenEitr : ((shared.m_food > 0f && shared.m_foodStamina > 0f) ? ((shared.m_food >= shared.m_foodStamina) ? EinjarheimProfessionsPlugin.ChefRegenHP : EinjarheimProfessionsPlugin.ChefRegenStamina) : ((!(shared.m_food > 0f)) ? EinjarheimProfessionsPlugin.ChefRegenStamina : EinjarheimProfessionsPlugin.ChefRegenHP)));
			((StatusEffect)val).m_ttl = foodBurnTime;
			((Character)player).GetSEMan().AddStatusEffect((StatusEffect)(object)val, false, 0, 0f);
			EinjarheimProfessionsPlugin.Log.LogInfo((object)$"[Cooking] SE Chef maestro aplicado: {((Object)val).name} ttl={foodBurnTime}s food={shared.m_name}");
		}
	}
}
[HarmonyPatch(typeof(Player), "OnSpawned")]
internal static class Cooking_Patch_OnSpawned_Restore
{
	private static void Postfix(Player __instance)
	{
		if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
		{
			return;
		}
		ZNetView nview = ((Character)__instance).m_nview;
		ZDO val = ((nview != null) ? nview.GetZDO() : null);
		IList<Food> list = (IList<Food>)AccessTools.Field(typeof(Player), "m_foods").GetValue(__instance);
		for (int i = 0; i < 3; i++)
		{
			if (!CookingSystem.LoadFoodSlotFromProfile(__instance, i, out var foodName, out var chefLv, out var chefName))
			{
				continue;
			}
			if (val != null)
			{
				switch (i)
				{
				case 0:
					val.Set("nazhi_food0_name", foodName);
					val.Set("nazhi_food0_chef_lv", chefLv);
					val.Set("nazhi_food0_chef_name", chefName);
					break;
				case 1:
					val.Set("nazhi_food1_name", foodName);
					val.Set("nazhi_food1_chef_lv", chefLv);
					val.Set("nazhi_food1_chef_name", chefName);
					break;
				default:
					val.Set("nazhi_food2_name", foodName);
					val.Set("nazhi_food2_chef_lv", chefLv);
					val.Set("nazhi_food2_chef_name", chefName);
					break;
				}
			}
			if (list != null && i < list.Count)
			{
				ItemData val2 = list[i]?.m_item;
				if (val2?.m_shared?.m_name == foodName)
				{
					CookingSystem.EnsureStampedFromFallback(val2, chefLv, chefName);
				}
			}
		}
		if (((Character)__instance).GetSkillLevel((SkillType)105) < 1f)
		{
			((Character)__instance).RaiseSkill((SkillType)105, 0.5f);
		}
	}
}
[HarmonyPatch]
internal static class Cooking_Patch_Tooltip
{
	private static IEnumerable<MethodBase> TargetMethods()
	{
		return from m in typeof(ItemData).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			where m.Name == "GetTooltip" && m.ReturnType == typeof(string)
			select m;
	}

	private static void Postfix(ItemData __instance, ref string __result)
	{
		if (__instance?.m_shared != null && CookingSystem.IsFood(__instance))
		{
			int chefLevelFromItem = CookingSystem.GetChefLevelFromItem(__instance);
			string chefNameFromItem = CookingSystem.GetChefNameFromItem(__instance);
			CookingSystem.CalculateBonus(__instance, chefLevelFromItem, out var bonusHp, out var bonusSt, out var bonusEi);
			List<string> list = new List<string>();
			if (bonusHp > 0)
			{
				list.Add($"<color=#FF6666>HP +{bonusHp}</color>");
			}
			if (bonusSt > 0)
			{
				list.Add($"<color=#66FF99>Stamina +{bonusSt}</color>");
			}
			if (bonusEi > 0)
			{
				list.Add($"<color=#66CCFF>Eitr +{bonusEi}</color>");
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine();
			if (list.Count > 0)
			{
				stringBuilder.AppendLine("<color=#FFD34D>Bonus al comer:</color> " + string.Join(", ", list));
			}
			string value;
			string text = ((CookingSystem.IsChefMaster(__instance) || (__instance.m_customData != null && __instance.m_customData.TryGetValue("nazhi_chef_spec", out value) && value == "1")) ? "<color=#00FFFF>[Chef]</color> " : "");
			stringBuilder.AppendLine("<color=#88CCFF>Cocinado por:</color> " + text + "<color=#FFFFFF>" + chefNameFromItem + "</color> " + $"<color=#FFFFAA>(Cooking Lv {chefLevelFromItem})</color>");
			if (CookingSystem.IsChefMaster(__instance))
			{
				SharedData shared = __instance.m_shared;
				string text2 = ((shared.m_foodEitr > 0f) ? "<color=#66CCFF>+30% Eitr Regen</color>" : ((shared.m_food > 0f && shared.m_foodStamina > 0f) ? ((shared.m_food >= shared.m_foodStamina) ? "<color=#FF6666>+30% HP Regen</color>" : "<color=#66FF99>+30% Stamina Regen</color>") : ((!(shared.m_food > 0f)) ? "<color=#66FF99>+30% Stamina Regen</color>" : "<color=#FF6666>+30% HP Regen</color>")));
				stringBuilder.AppendLine("<color=#00FFFF>Sazón del Chef:</color> " + text2);
			}
			if (!__result.Contains("Bonus al comer:") && !__result.Contains("Cocinado por:"))
			{
				__result += stringBuilder.ToString();
			}
		}
	}
}
[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
internal static class Cooking_Patch_TotalFoodValue
{
	private static readonly Dictionary<long, string> _lastSig = new Dictionary<long, string>();

	private static void Postfix(Player __instance, ref float hp, ref float stamina, ref float eitr)
	{
		if ((Object)(object)__instance == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
		{
			return;
		}
		IList<Food> list = (IList<Food>)AccessTools.Field(typeof(Player), "m_foods").GetValue(__instance);
		if (list == null || list.Count == 0)
		{
			return;
		}
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		List<string> list2 = new List<string>();
		for (int i = 0; i < list.Count; i++)
		{
			ItemData val = list[i]?.m_item;
			if (val?.m_shared != null)
			{
				string name = val.m_shared.m_name;
				int num4 = CookingSystem.GetChefLevelFromItem(val);
				string text = CookingSystem.GetChefNameFromItem(val);
				if (num4 <= 1 && text == "Desconocido" && CookingSystem.TryGetChefFromZDO(__instance, i, out var foodName, out var chefLv, out var chefName) && foodName == name)
				{
					num4 = chefLv;
					text = chefName;
					CookingSystem.EnsureStampedFromFallback(val, num4, text);
				}
				if (num4 <= 1 && text == "Desconocido" && CookingSystem.LoadFoodSlotFromProfile(__instance, i, out var foodName2, out var chefLv2, out var chefName2) && foodName2 == name)
				{
					num4 = chefLv2;
					text = chefName2;
					CookingSystem.EnsureStampedFromFallback(val, num4, text);
				}
				CookingSystem.CalculateBonus(val, num4, out var bonusHp, out var bonusSt, out var bonusEi);
				num += bonusHp;
				num2 += bonusSt;
				num3 += bonusEi;
				list2.Add($"{name}|{text}|Lv{num4}");
			}
		}
		hp += num;
		stamina += num2;
		eitr += num3;
		long playerID = __instance.GetPlayerID();
		string text2 = string.Join("##", list2);
		if (!_lastSig.TryGetValue(playerID, out var value) || value != text2)
		{
			_lastSig[playerID] = text2;
		}
	}
}
[HarmonyPatch]
internal static class Cooking_Patch_AddItem_Context
{
	[ThreadStatic]
	private static ItemData _incoming;

	internal static ItemData Incoming => _incoming;

	private static IEnumerable<MethodBase> TargetMethods()
	{
		return from m in typeof(Inventory).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			where m.Name == "AddItem" && m.GetParameters().Length != 0 && m.GetParameters()[0].ParameterType == typeof(ItemData)
			select m;
	}

	private static void Prefix(ItemData item)
	{
		_incoming = item;
	}

	private static void Finalizer()
	{
		_incoming = null;
	}
}
[HarmonyPatch(typeof(Inventory), "FindFreeStackItem")]
internal static class Cooking_Patch_FindFreeStackItem
{
	private static bool Prefix(Inventory __instance, string name, int quality, float worldLevel, ref ItemData __result)
	{
		ItemData incoming = Cooking_Patch_AddItem_Context.Incoming;
		if (incoming == null || !CookingSystem.IsFood(incoming))
		{
			return true;
		}
		if (string.IsNullOrEmpty(CookingSystem.GetChefNameRaw(incoming)))
		{
			return true;
		}
		int chefLevelFromItem = CookingSystem.GetChefLevelFromItem(incoming);
		foreach (ItemData item in __instance.m_inventory)
		{
			if (item?.m_shared?.m_name != name || item.m_quality != quality || item.m_stack >= item.m_shared.m_maxStackSize || (double)item.m_worldLevel != (double)worldLevel || CookingSystem.GetChefLevelFromItem(item) != chefLevelFromItem)
			{
				continue;
			}
			__result = item;
			return false;
		}
		__result = null;
		return false;
	}
}
[HarmonyPatch(typeof(Inventory), "CanAddItem", new Type[]
{
	typeof(ItemData),
	typeof(int)
})]
internal static class Cooking_Patch_CanAddItem
{
	private static bool Prefix(Inventory __instance, ItemData item, int stack, ref bool __result)
	{
		if (item == null || !CookingSystem.IsFood(item))
		{
			return true;
		}
		if (stack <= 0)
		{
			stack = item.m_stack;
		}
		int chefLevelFromItem = CookingSystem.GetChefLevelFromItem(item);
		int num = 0;
		foreach (ItemData item2 in __instance.m_inventory)
		{
			if (!(item2?.m_shared?.m_name != item.m_shared.m_name) && (double)item2.m_worldLevel == (double)item.m_worldLevel && (item2.m_shared.m_maxQuality <= 1 || item2.m_quality == item.m_quality) && item2.m_stack < item2.m_shared.m_maxStackSize && CookingSystem.GetChefLevelFromItem(item2) == chefLevelFromItem)
			{
				num += item2.m_shared.m_maxStackSize - item2.m_stack;
			}
		}
		int num2 = __instance.m_width * __instance.m_height - __instance.m_inventory.Count;
		int num3 = num2 * item.m_shared.m_maxStackSize;
		__result = num + num3 >= stack;
		return false;
	}
}
[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
{
	typeof(ItemData),
	typeof(int),
	typeof(int),
	typeof(int)
})]
internal static class Cooking_Patch_AddItemXY
{
	private static bool Prefix(Inventory __instance, ItemData item, int amount, int x, int y, ref bool __result)
	{
		if (item == null || !CookingSystem.IsFood(item))
		{
			return true;
		}
		ItemData itemAt = __instance.GetItemAt(x, y);
		if (itemAt == null)
		{
			return true;
		}
		if (CookingSystem.IsFood(itemAt) && itemAt.m_shared?.m_name == item.m_shared?.m_name && CookingSystem.GetChefLevelFromItem(itemAt) != CookingSystem.GetChefLevelFromItem(item))
		{
			__result = false;
			return false;
		}
		return true;
	}
}
[HarmonyPatch]
internal static class Cooking_Patch_SafeStamp_Fallback
{
	private static IEnumerable<MethodBase> TargetMethods()
	{
		return from m in typeof(Inventory).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
			where m.Name == "AddItem"
			select m;
	}

	private static void Prefix(Inventory __instance, ref object __state)
	{
		__state = null;
		Player localPlayer = Player.m_localPlayer;
		if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory() == __instance)
		{
			ItemData incoming = Cooking_Patch_AddItem_Context.Incoming;
			if (incoming != null && CookingSystem.IsFood(incoming))
			{
				__state = incoming;
			}
		}
	}

	private static void Postfix(Inventory __instance, object __state)
	{
		if (__state == null)
		{
			return;
		}
		Player localPlayer = Player.m_localPlayer;
		if (!((Object)(object)localPlayer == (Object)null) && ((Humanoid)localPlayer).GetInventory() == __instance)
		{
			ItemData val = (ItemData)((__state is ItemData) ? __state : null);
			if (val != null && string.IsNullOrEmpty(CookingSystem.GetChefNameRaw(val)))
			{
				CookingSystem.ChefInfo chef = CookingSystem.BuildChef(localPlayer);
				CookingSystem.StampChef(val, chef);
				EinjarheimProfessionsPlugin.Log.LogInfo((object)("[Cooking] SafeStamp → '" + val.m_shared?.m_name + "' " + $"sellado con {chef.ChefName} Lv{chef.ChefLv}"));
			}
		}
	}
}
public class CookingXPPatch
{
	[HarmonyPatch(typeof(Player), "RaiseSkill")]
	public class Player_RaiseSkill_CookingXP_Patch
	{
		private static void Prefix(SkillType skill, ref float value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			if ((int)skill == 105)
			{
				value *= 25f;
			}
		}
	}
}
public class CraftingXPPatch
{
	[HarmonyPatch(typeof(Player), "RaiseSkill")]
	public class Player_RaiseSkill_CraftingXP_Patch
	{
		private static void Prefix(SkillType skill, ref float value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			if ((int)skill == 107)
			{
				value *= 5f;
			}
		}
	}
}