using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
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("Laserflare")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A skill-based carry weight mod for Valheim")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BeastOfBurden")]
[assembly: AssemblyTitle("BeastOfBurden")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BeastOfBurden
{
	[BepInPlugin("com.laserflare.beastofburden", "Beast of Burden", "1.0.9")]
	public class BeastOfBurdenPlugin : BaseUnityPlugin
	{
		public const string PluginGUID = "com.laserflare.beastofburden";

		public const string PluginName = "Beast of Burden";

		public const string PluginVersion = "1.0.9";

		private static BeastOfBurdenPlugin _instance;

		private Harmony _harmony;

		public static ConfigEntry<float> CarryWeightPerSkillLevel;

		public static ConfigEntry<float> SkillGainRate;

		public static ConfigEntry<float> MinimumLoadPercentage;

		public static ConfigEntry<bool> EnableMod;

		private static float _skillExperience;

		private static float _skillLevel;

		private static float _lastSkillGainTime;

		private static Type _playerType;

		private static Type _znetViewType;

		private static FieldInfo _localPlayerField;

		private static FieldInfo _nviewField;

		private static MethodInfo _getComponentMethod;

		private static MethodInfo _getInventoryMethod;

		private static MethodInfo _getVelocityMethod;

		private static MethodInfo _getTotalWeightMethod;

		private static MethodInfo _getMaxCarryWeightMethod;

		private static FieldInfo _customDataField;

		private static MethodInfo _isValidMethod;

		private static MethodInfo _messageMethod;

		private void Awake()
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			_instance = this;
			EnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableMod", true, "Enable or disable the Beast of Burden mod");
			CarryWeightPerSkillLevel = ((BaseUnityPlugin)this).Config.Bind<float>("CarryWeight", "CarryWeightPerSkillLevel", 3f, "Additional carry weight per skill level (max level 100 = +300 weight at default)");
			SkillGainRate = ((BaseUnityPlugin)this).Config.Bind<float>("Skill", "SkillGainRate", 0.5f, "Rate at which Beast of Burden skill increases when carrying heavy loads (experience per second)");
			MinimumLoadPercentage = ((BaseUnityPlugin)this).Config.Bind<float>("Skill", "MinimumLoadPercentage", 0.9f, "Minimum percentage of carry capacity that must be filled to gain skill (0.9 = 90%)");
			if (!InitializeReflection())
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Failed to initialize reflection. Mod will not function.");
				return;
			}
			_harmony = new Harmony("com.laserflare.beastofburden");
			ApplyPatches();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Beast of Burden v1.0.9 loaded!");
		}

		private bool InitializeReflection()
		{
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					_playerType = assemblies[i].GetType("Player");
					if (_playerType != null)
					{
						break;
					}
				}
				if (_playerType == null)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"Could not find Player type");
					return false;
				}
				_localPlayerField = _playerType.GetField("m_localPlayer", BindingFlags.Static | BindingFlags.Public);
				_nviewField = _playerType.GetField("m_nview", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
				if (_nviewField == null)
				{
					Type type = _playerType;
					while (type != null && _nviewField == null)
					{
						_nviewField = type.GetField("m_nview", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						type = type.BaseType;
					}
				}
				assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					_znetViewType = assemblies[i].GetType("ZNetView");
					if (_znetViewType != null)
					{
						break;
					}
				}
				if (_znetViewType != null)
				{
					MethodInfo method = typeof(Component).GetMethod("GetComponent", Type.EmptyTypes);
					if (method != null)
					{
						_getComponentMethod = method.MakeGenericMethod(_znetViewType);
					}
				}
				_getInventoryMethod = _playerType.GetMethod("GetInventory");
				_getVelocityMethod = _playerType.GetMethod("GetVelocity");
				_getMaxCarryWeightMethod = _playerType.GetMethod("GetMaxCarryWeight");
				Type type2 = _getInventoryMethod?.ReturnType;
				if (type2 != null)
				{
					_getTotalWeightMethod = type2.GetMethod("GetTotalWeight");
				}
				if (_znetViewType != null)
				{
					_isValidMethod = _znetViewType.GetMethod("IsValid");
				}
				_customDataField = _playerType.GetField("m_customData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (_customDataField == null)
				{
					Type type3 = _playerType;
					while (type3 != null && _customDataField == null)
					{
						_customDataField = type3.GetField("m_customData", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						type3 = type3.BaseType;
					}
				}
				_messageMethod = _playerType.GetMethod("Message");
				return true;
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Reflection initialization failed: {arg}");
				return false;
			}
		}

		private void ApplyPatches()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			try
			{
				MethodInfo method = _playerType.GetMethod("GetMaxCarryWeight");
				if (method != null)
				{
					MethodInfo method2 = typeof(BeastOfBurdenPlugin).GetMethod("GetMaxCarryWeight_Postfix", BindingFlags.Static | BindingFlags.NonPublic);
					_harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo method3 = _playerType.GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method3 != null)
				{
					MethodInfo method4 = typeof(BeastOfBurdenPlugin).GetMethod("FixedUpdate_Postfix", BindingFlags.Static | BindingFlags.NonPublic);
					_harmony.Patch((MethodBase)method3, (HarmonyMethod)null, new HarmonyMethod(method4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo method5 = _playerType.GetMethod("OnSpawned");
				if (method5 != null)
				{
					MethodInfo method6 = typeof(BeastOfBurdenPlugin).GetMethod("OnSpawned_Postfix", BindingFlags.Static | BindingFlags.NonPublic);
					_harmony.Patch((MethodBase)method5, (HarmonyMethod)null, new HarmonyMethod(method6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo method7 = _playerType.GetMethod("Save");
				if (method7 != null)
				{
					MethodInfo method8 = typeof(BeastOfBurdenPlugin).GetMethod("Save_Postfix", BindingFlags.Static | BindingFlags.NonPublic);
					_harmony.Patch((MethodBase)method7, (HarmonyMethod)null, new HarmonyMethod(method8), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Failed to apply patches: {arg}");
			}
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		public static float GetSkillLevel()
		{
			return _skillLevel;
		}

		public static void SetSkillLevel(float level)
		{
			_skillLevel = Mathf.Clamp(level, 0f, 100f);
		}

		public static void AddExperience(object player, float amount)
		{
			_skillExperience += amount;
			float num = 100f;
			float num2 = _skillExperience / num;
			num2 = Mathf.Clamp(num2, 0f, 100f);
			if (!(num2 > _skillLevel))
			{
				return;
			}
			float skillLevel = _skillLevel;
			SetSkillLevel(num2);
			if (Mathf.Floor(num2) > Mathf.Floor(skillLevel) && _messageMethod != null)
			{
				try
				{
					_messageMethod.Invoke(player, new object[4]
					{
						1,
						$"Beast of Burden: {Mathf.Floor(num2)}",
						0,
						null
					});
				}
				catch
				{
				}
				BeastOfBurdenPlugin instance = _instance;
				if (instance != null)
				{
					((BaseUnityPlugin)instance).Logger.LogInfo((object)$"Beast of Burden skill increased to {Mathf.Floor(num2)}");
				}
			}
		}

		public static float GetCarryWeightBonus()
		{
			if (!EnableMod.Value)
			{
				return 0f;
			}
			return _skillLevel * CarryWeightPerSkillLevel.Value;
		}

		public static void SaveSkillData(object player)
		{
			if (player == null || _customDataField == null)
			{
				return;
			}
			try
			{
				if (_customDataField.GetValue(player) is Dictionary<string, string> dictionary)
				{
					dictionary["beastofburden_skill"] = _skillLevel.ToString(CultureInfo.InvariantCulture);
					dictionary["beastofburden_exp"] = _skillExperience.ToString(CultureInfo.InvariantCulture);
				}
			}
			catch
			{
			}
		}

		public static void LoadSkillData(object player)
		{
			if (player == null || _customDataField == null)
			{
				return;
			}
			try
			{
				if (!(_customDataField.GetValue(player) is Dictionary<string, string> dictionary))
				{
					return;
				}
				if (dictionary.TryGetValue("beastofburden_skill", out var value))
				{
					float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out _skillLevel);
				}
				if (dictionary.TryGetValue("beastofburden_exp", out var value2))
				{
					float.TryParse(value2, NumberStyles.Float, CultureInfo.InvariantCulture, out _skillExperience);
				}
				if (_skillLevel > 0f)
				{
					BeastOfBurdenPlugin instance = _instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogInfo((object)$"Loaded Beast of Burden skill: {_skillLevel:F1}");
					}
				}
			}
			catch
			{
			}
		}

		private static void GetMaxCarryWeight_Postfix(ref float __result)
		{
			__result += GetCarryWeightBonus();
		}

		private static void FixedUpdate_Postfix(object __instance)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			if (!EnableMod.Value)
			{
				return;
			}
			try
			{
				object obj = _localPlayerField?.GetValue(null);
				if (obj == null || __instance != obj)
				{
					return;
				}
				object obj2 = _nviewField?.GetValue(__instance);
				if (obj2 == null && _getComponentMethod != null)
				{
					obj2 = _getComponentMethod.Invoke(__instance, null);
				}
				if (obj2 == null)
				{
					return;
				}
				object obj3 = _isValidMethod?.Invoke(obj2, null);
				if (obj3 == null || !(bool)obj3 || Time.time - _lastSkillGainTime < 1f)
				{
					return;
				}
				Vector3 val = (Vector3)(((??)(Vector3?)_getVelocityMethod?.Invoke(__instance, null)) ?? Vector3.zero);
				if (((Vector3)(ref val)).magnitude < 0.1f)
				{
					return;
				}
				object obj4 = _getInventoryMethod?.Invoke(__instance, null);
				if (obj4 != null)
				{
					float valueOrDefault = ((float?)_getTotalWeightMethod?.Invoke(obj4, null)).GetValueOrDefault();
					float num = ((float?)_getMaxCarryWeightMethod?.Invoke(__instance, null)) ?? 300f;
					if (valueOrDefault / num >= MinimumLoadPercentage.Value)
					{
						_lastSkillGainTime = Time.time;
						AddExperience(__instance, SkillGainRate.Value);
					}
				}
			}
			catch
			{
			}
		}

		private static void OnSpawned_Postfix(object __instance)
		{
			try
			{
				object obj = _localPlayerField?.GetValue(null);
				if (__instance == obj)
				{
					LoadSkillData(__instance);
				}
			}
			catch
			{
			}
		}

		private static void Save_Postfix(object __instance)
		{
			try
			{
				object obj = _localPlayerField?.GetValue(null);
				if (__instance == obj)
				{
					SaveSkillData(__instance);
				}
			}
			catch
			{
			}
		}
	}
}