using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("MesaDeTrabajo")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MesaDeTrabajo")]
[assembly: AssemblyTitle("MesaDeTrabajo")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MesaDeTrabajo
{
	internal static class AreaMesa
	{
		internal const float RadioSinLimite = 100000f;

		[ThreadStatic]
		internal static bool LeyendoAlcanceReal;

		internal static float AlcanceRealDe(CraftingStation estacion)
		{
			LeyendoAlcanceReal = true;
			try
			{
				return estacion.GetStationBuildRange();
			}
			finally
			{
				LeyendoAlcanceReal = false;
			}
		}
	}
	[HarmonyPatch(typeof(CraftingStation), "GetStationBuildRange")]
	internal static class ParcheRadioVisible
	{
		private static void Postfix(ref float __result)
		{
			if (AreaMesa.LeyendoAlcanceReal)
			{
				return;
			}
			MesaDeTrabajoPlugin instancia = MesaDeTrabajoPlugin.Instancia;
			if (!((Object)(object)instancia == (Object)null))
			{
				if (!instancia.LimiteAreaActivo)
				{
					__result = 100000f;
				}
				else
				{
					__result = Mathf.Max(__result, instancia.RadioArea);
				}
			}
		}
	}
	[HarmonyPatch(typeof(CraftingStation), "HaveBuildStationInRange")]
	internal static class ParcheEstacionEnRango
	{
		private static readonly FieldInfo CampoEstaciones = AccessTools.Field(typeof(CraftingStation), "m_allStations");

		private static void Postfix(string name, Vector3 point, ref CraftingStation __result)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__result != (Object)null)
			{
				return;
			}
			MesaDeTrabajoPlugin instancia = MesaDeTrabajoPlugin.Instancia;
			if ((Object)(object)instancia == (Object)null || CampoEstaciones == null)
			{
				return;
			}
			bool flag = !instancia.LimiteAreaActivo;
			if (!(CampoEstaciones.GetValue(null) is List<CraftingStation> list))
			{
				return;
			}
			CraftingStation val = null;
			float num = float.MaxValue;
			foreach (CraftingStation item in list)
			{
				if ((Object)(object)item == (Object)null || (!string.IsNullOrEmpty(name) && item.m_name != name))
				{
					continue;
				}
				float num2 = Vector3.Distance(point, ((Component)item).transform.position);
				if (num2 >= num)
				{
					continue;
				}
				if (!flag)
				{
					float num3 = Mathf.Max(AreaMesa.AlcanceRealDe(item), instancia.RadioArea);
					if (num2 > num3)
					{
						continue;
					}
				}
				val = item;
				num = num2;
			}
			__result = val;
		}
	}
	[BepInPlugin("altairfernando.mesadetrabajo", "MesaDeTrabajo", "1.0.0")]
	public class MesaDeTrabajoPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "altairfernando.mesadetrabajo";

		public const string PluginName = "MesaDeTrabajo";

		public const string PluginVersion = "1.0.0";

		private const float IntervaloReparacion = 1f;

		internal static MesaDeTrabajoPlugin Instancia;

		private ConfigEntry<bool> _limiteArea;

		private ConfigEntry<float> _radioArea;

		private ConfigEntry<bool> _autoReparar;

		private float _proximaRevisionReparar;

		internal bool LimiteAreaActivo
		{
			get
			{
				if (_limiteArea != null)
				{
					return _limiteArea.Value;
				}
				return true;
			}
		}

		internal float RadioArea
		{
			get
			{
				if (_radioArea == null)
				{
					return 0f;
				}
				return _radioArea.Value;
			}
		}

		private void Awake()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			Instancia = this;
			_limiteArea = ((BaseUnityPlugin)this).Config.Bind<bool>("1 - Area de mesa", "LimitarArea", true, "Si lo apagas, desaparece el limite de area de la mesa de trabajo para construir.");
			_radioArea = ((BaseUnityPlugin)this).Config.Bind<float>("1 - Area de mesa", "Radio", 20f, new ConfigDescription("Radio en metros del area de la mesa de trabajo. 20 es el valor de fabrica. Se ignora si LimitarArea esta apagado.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 200f), Array.Empty<object>()));
			_autoReparar = ((BaseUnityPlugin)this).Config.Bind<bool>("2 - Reparacion", "AutoReparar", true, "Repara solo todo lo reparable al acercarte a una estacion utilizable (con techo).");
			new Harmony("altairfernando.mesadetrabajo").PatchAll(Assembly.GetExecutingAssembly());
			((BaseUnityPlugin)this).Logger.LogInfo((object)"MesaDeTrabajo 1.0.0 cargado.");
		}

		private void Update()
		{
			if (!_autoReparar.Value || Time.time < _proximaRevisionReparar)
			{
				return;
			}
			_proximaRevisionReparar = Time.time + 1f;
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				int num = Reparacion.Intentar(localPlayer);
				if (num > 0)
				{
					Mensaje((num == 1) ? "Reparado 1 objeto" : ("Reparados " + num + " objetos"));
				}
			}
		}

		private static void Mensaje(string texto)
		{
			MessageHud instance = MessageHud.instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.ShowMessage((MessageType)2, texto, 0, (Sprite)null, false, false);
			}
		}
	}
	internal static class Reparacion
	{
		private const int MaximoPorIntento = 60;

		private static readonly MethodInfo MetodoRepararUno = AccessTools.Method(typeof(InventoryGui), "RepairOneItem", (Type[])null, (Type[])null);

		private static readonly MethodInfo MetodoHayReparables = AccessTools.Method(typeof(InventoryGui), "HaveRepairableItems", (Type[])null, (Type[])null);

		internal static bool Disponible
		{
			get
			{
				if (MetodoRepararUno != null)
				{
					return MetodoHayReparables != null;
				}
				return false;
			}
		}

		internal static int Intentar(Player jugador)
		{
			if (!Disponible || (Object)(object)jugador == (Object)null)
			{
				return 0;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 0;
			}
			CraftingStation currentCraftingStation = jugador.GetCurrentCraftingStation();
			if ((Object)(object)currentCraftingStation == (Object)null || !currentCraftingStation.CheckUsable(jugador, false))
			{
				return 0;
			}
			int i;
			for (i = 0; i < 60; i++)
			{
				if (!HayReparables(instance))
				{
					break;
				}
				float num = DurabilidadTotal(jugador);
				MetodoRepararUno.Invoke(instance, null);
				if (DurabilidadTotal(jugador) <= num)
				{
					break;
				}
			}
			return i;
		}

		private static bool HayReparables(InventoryGui gui)
		{
			object obj = MetodoHayReparables.Invoke(gui, null);
			if (obj is bool)
			{
				return (bool)obj;
			}
			return false;
		}

		private static float DurabilidadTotal(Player jugador)
		{
			Inventory inventory = ((Humanoid)jugador).GetInventory();
			if (inventory == null)
			{
				return 0f;
			}
			float num = 0f;
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem != null && allItem.m_shared != null && allItem.m_shared.m_canBeReparied)
				{
					num += allItem.m_durability;
				}
			}
			return num;
		}
	}
}