using System;
using System.Collections.Generic;
using System.Diagnostics;
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.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using ComfyLib;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("DyeHard")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("DyeHard")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7c3156d5-b19a-467c-bf87-d37aeaccbc56")]
[assembly: AssemblyFileVersion("1.6.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.6.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 DyeHard
{
	public static class PluginConfig
	{
		public static ConfigFile CurrentConfig { get; private set; }

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

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

		public static ConfigEntry<Color> PlayerHairColor { get; private set; }

		public static ConfigEntry<string> PlayerHairColorHex { get; private set; }

		public static ConfigEntry<float> PlayerHairGlow { get; private set; }

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

		public static ConfigEntry<string> PlayerHairItem { get; private set; }

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

		public static ConfigEntry<string> PlayerBeardItem { get; private set; }

		public static ConfigEntry<Vector3> OffsetCharacterPreviewPosition { get; private set; }

		public static void BindConfig(ConfigFile config)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			CurrentConfig = config;
			IsModEnabled = config.BindInOrder("_Global", "isModEnabled", defaultValue: true, "Globally enable or disable this mod.");
			OverridePlayerHairColor = config.BindInOrder("HairColor", "overridePlayerHairColor", defaultValue: false, "Enable/disable overriding your player's hair color.");
			PlayerHairColor = config.BindInOrder<Color>("HairColor", "playerHairColor", Color.white, "Sets the color for your player's hair.");
			PlayerHairColorHex = config.BindInOrder("HairColor", "playerHairColorHex", "#FFFFFF", "Sets the color of player hair, in HTML hex form (alpha unsupported).");
			PlayerHairGlow = config.BindInOrder("HairColor", "playerHairGlow", 1f, "Hair glow multiplier for the hair color. Zero removes all color.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f));
			OffsetCharacterPreviewPosition = config.BindInOrder<Vector3>("Preview", "offsetCharacterPreviewPosition", new Vector3(1f, 0f, 1f), "Offsets the position of the character preview.");
			IsModEnabled.OnSettingChanged<bool>(DyeManager.SetPlayerZDOHairColor);
			OverridePlayerHairColor.OnSettingChanged<bool>(DyeManager.SetPlayerZDOHairColor);
			PlayerHairColor.OnSettingChanged<Color>(UpdatePlayerHairColorHexValue);
			PlayerHairColorHex.OnSettingChanged<string>(UpdatePlayerHairColorValue);
			PlayerHairGlow.OnSettingChanged<float>(DyeManager.SetPlayerZDOHairColor);
			IsModEnabled.OnSettingChanged<bool>(DyeManager.SetCharacterPreviewPosition);
			OffsetCharacterPreviewPosition.OnSettingChanged<Vector3>(DyeManager.SetCharacterPreviewPosition);
		}

		private static void UpdatePlayerHairColorHexValue()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			Color value = PlayerHairColor.Value;
			value.a = 1f;
			PlayerHairColorHex.Value = "#" + ColorUtility.ToHtmlStringRGB(value);
			PlayerHairColor.Value = value;
			DyeManager.SetPlayerZDOHairColor();
		}

		private static void UpdatePlayerHairColorValue()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Color value = default(Color);
			if (ColorUtility.TryParseHtmlString(PlayerHairColorHex.Value, ref value))
			{
				value.a = 1f;
				PlayerHairColor.Value = value;
				DyeManager.SetPlayerZDOHairColor();
			}
		}

		public static void BindCustomizationConfig(ObjectDB objectDb, PlayerCustomizaton customization)
		{
			if (OverridePlayerHairItem == null && OverridePlayerBeardItem == null)
			{
				string[] array = (from item in objectDb.GetAllItems((ItemType)10, "Hair")
					select ((Object)item).name).AlphanumericSort().ToArray();
				OverridePlayerHairItem = CurrentConfig.BindInOrder("Hair", "overridePlayerHairItem", defaultValue: false, "Enable/disable overriding your player's hair.");
				PlayerHairItem = CurrentConfig.BindInOrder("Hair", "playerHairItem", ((Object)customization.m_noHair).name, "If non-empty, sets/overrides the player's hair (if any).", (AcceptableValueBase)(object)new AcceptableValueList<string>(array));
				IsModEnabled.OnSettingChanged<bool>(DyeManager.SetPlayerHairItem);
				OverridePlayerHairItem.OnSettingChanged<bool>(DyeManager.SetPlayerHairItem);
				PlayerHairItem.OnSettingChanged<string>(DyeManager.SetPlayerHairItem);
				string[] array2 = (from item in objectDb.GetAllItems((ItemType)10, "Beard")
					select ((Object)item).name).AlphanumericSort().ToArray();
				OverridePlayerBeardItem = CurrentConfig.BindInOrder("Beard", "overridePlayerBeardItem", defaultValue: false, "Enable/disable overriding your player's beard.");
				PlayerBeardItem = CurrentConfig.BindInOrder("Beard", "playerBeardItem", ((Object)customization.m_noBeard).name, "If non-empty, sets/overrides the player's beard (if any).", (AcceptableValueBase)(object)new AcceptableValueList<string>(array2));
				IsModEnabled.OnSettingChanged<bool>(DyeManager.SetPlayerBeardItem);
				OverridePlayerBeardItem.OnSettingChanged<bool>(DyeManager.SetPlayerBeardItem);
				PlayerBeardItem.OnSettingChanged<string>(DyeManager.SetPlayerBeardItem);
			}
		}

		public static IEnumerable<string> AlphanumericSort(this IEnumerable<string> text)
		{
			return text.OrderBy((string x) => Regex.Replace(x, "\\d+", (Match m) => m.Value.PadLeft(50, '0')));
		}
	}
	public static class DyeManager
	{
		public static Player LocalPlayer { get; private set; }

		public static VisEquipment LocalVisEquipment { get; private set; }

		public static void SetLocalPlayer(Player player)
		{
			LocalPlayer = player;
			LocalVisEquipment = (Object.op_Implicit((Object)(object)player) ? ((Humanoid)player).m_visEquipment : null);
		}

		public static Vector3 GetPlayerHairColorVector()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Utils.ColorToVec3(PluginConfig.PlayerHairColor.Value);
			if (val != Vector3.zero)
			{
				val *= PluginConfig.PlayerHairGlow.Value / ((Vector3)(ref val)).magnitude;
			}
			return val;
		}

		public static void SetPlayerBeardItem()
		{
			if (Object.op_Implicit((Object)(object)LocalPlayer) && Object.op_Implicit((Object)(object)((Humanoid)LocalPlayer).m_visEquipment))
			{
				string beardItem = ((PluginConfig.IsModEnabled.Value && PluginConfig.OverridePlayerBeardItem.Value) ? PluginConfig.PlayerBeardItem.Value : ((Humanoid)LocalPlayer).m_beardItem);
				if (Object.op_Implicit((Object)(object)((Character)LocalPlayer).m_nview))
				{
					((Humanoid)LocalPlayer).m_visEquipment.SetBeardItem(beardItem);
				}
				((Humanoid)LocalPlayer).m_visEquipment.m_beardItem = beardItem;
			}
		}

		public static void SetPlayerHairItem()
		{
			if (Object.op_Implicit((Object)(object)LocalPlayer) && Object.op_Implicit((Object)(object)((Humanoid)LocalPlayer).m_visEquipment))
			{
				string hairItem = ((PluginConfig.IsModEnabled.Value && PluginConfig.OverridePlayerHairItem.Value) ? PluginConfig.PlayerHairItem.Value : ((Humanoid)LocalPlayer).m_hairItem);
				if (Object.op_Implicit((Object)(object)((Character)LocalPlayer).m_nview))
				{
					((Humanoid)LocalPlayer).m_visEquipment.SetHairItem(hairItem);
				}
				((Humanoid)LocalPlayer).m_visEquipment.m_hairItem = hairItem;
			}
		}

		public static void SetPlayerZDOHairColor()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)LocalPlayer) && Object.op_Implicit((Object)(object)((Humanoid)LocalPlayer).m_visEquipment))
			{
				Vector3 val = ((PluginConfig.IsModEnabled.Value && PluginConfig.OverridePlayerHairColor.Value) ? GetPlayerHairColorVector() : LocalPlayer.m_hairColor);
				((Humanoid)LocalPlayer).m_visEquipment.m_hairColor = val;
				if (Object.op_Implicit((Object)(object)((Character)LocalPlayer).m_nview) && ((Character)LocalPlayer).m_nview.IsValid() && (!((Character)LocalPlayer).m_nview.m_zdo.TryGetVector3(ZDOVars.s_hairColor, out var value) || value != val))
				{
					((Character)LocalPlayer).m_nview.m_zdo.Set(ZDOVars.s_hairColor, val);
				}
			}
		}

		public static void SetCharacterPreviewPosition()
		{
			SetCharacterPreviewPosition(FejdStartup.m_instance);
		}

		private static void SetCharacterPreviewPosition(FejdStartup fejdStartup)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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 (Object.op_Implicit((Object)(object)fejdStartup) && Object.op_Implicit((Object)(object)fejdStartup.m_playerInstance))
			{
				Vector3 val = fejdStartup.m_characterPreviewPoint.position;
				if (PluginConfig.IsModEnabled.Value)
				{
					val += PluginConfig.OffsetCharacterPreviewPosition.Value;
				}
				fejdStartup.m_playerInstance.transform.position = val;
			}
		}
	}
	[BepInPlugin("redseiko.valheim.dyehard", "DyeHard", "1.6.0")]
	public sealed class DyeHard : BaseUnityPlugin
	{
		public const string PluginGUID = "redseiko.valheim.dyehard";

		public const string PluginName = "DyeHard";

		public const string PluginVersion = "1.6.0";

		private void Awake()
		{
			PluginConfig.BindConfig(((BaseUnityPlugin)this).Config);
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "redseiko.valheim.dyehard");
		}
	}
	[HarmonyPatch(typeof(FejdStartup))]
	internal static class FejdStartupPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetupObjectDB")]
		private static void SetupObjectDbPostfix(FejdStartup __instance)
		{
			PluginConfig.BindCustomizationConfig(((Component)__instance).GetComponent<ObjectDB>(), __instance.m_newCharacterPanel.GetComponent<PlayerCustomizaton>());
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetupCharacterPreview")]
		private static void SetupCharacterPreviewPostfix(FejdStartup __instance)
		{
			DyeManager.SetLocalPlayer(__instance.m_playerInstance.GetComponent<Player>());
			if (PluginConfig.IsModEnabled.Value)
			{
				DyeManager.SetPlayerZDOHairColor();
				DyeManager.SetPlayerHairItem();
				DyeManager.SetPlayerBeardItem();
				DyeManager.SetCharacterPreviewPosition();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("ShowCharacterSelection")]
		private static void ShowCharacterSelectionPostfix()
		{
			DyeManager.SetCharacterPreviewPosition();
		}
	}
	[HarmonyPatch(typeof(Player))]
	internal static class PlayerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetLocalPlayer")]
		private static void SetLocalPlayerPostfix(Player __instance)
		{
			DyeManager.SetLocalPlayer(__instance);
			DyeManager.SetPlayerZDOHairColor();
			DyeManager.SetPlayerHairItem();
			DyeManager.SetPlayerBeardItem();
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnSpawned")]
		private static void OnSpawnedPostfix(Player __instance)
		{
			DyeManager.SetLocalPlayer(__instance);
			DyeManager.SetPlayerZDOHairColor();
			DyeManager.SetPlayerHairItem();
			DyeManager.SetPlayerBeardItem();
		}
	}
	[HarmonyPatch(typeof(VisEquipment))]
	internal static class VisEquipmentPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("SetHairColor")]
		private static void SetHairColorPrefix(VisEquipment __instance, ref Vector3 color)
		{
			//IL_0026: 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)
			if (PluginConfig.IsModEnabled.Value && PluginConfig.OverridePlayerHairColor.Value && (Object)(object)__instance == (Object)(object)DyeManager.LocalVisEquipment)
			{
				color = DyeManager.GetPlayerHairColorVector();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetHairItem")]
		private static void SetHairItemPrefix(VisEquipment __instance, ref string name)
		{
			if (PluginConfig.IsModEnabled.Value && PluginConfig.OverridePlayerHairItem.Value && (Object)(object)__instance == (Object)(object)DyeManager.LocalVisEquipment)
			{
				name = PluginConfig.PlayerHairItem.Value;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetBeardItem")]
		private static void SetBeardItemPrefix(VisEquipment __instance, ref string name)
		{
			if (PluginConfig.IsModEnabled.Value && PluginConfig.OverridePlayerBeardItem.Value && (Object)(object)__instance == (Object)(object)DyeManager.LocalVisEquipment)
			{
				name = PluginConfig.PlayerBeardItem.Value;
			}
		}
	}
}
namespace ComfyLib
{
	public static class ConfigFileExtensions
	{
		internal sealed class ConfigurationManagerAttributes
		{
			public Action<ConfigEntryBase> CustomDrawer;

			public bool? Browsable;

			public bool? HideDefaultButton;

			public bool? HideSettingName;

			public bool? IsAdvanced;

			public int? Order;

			public bool? ReadOnly;
		}

		private static readonly Dictionary<string, int> _sectionToSettingOrder = new Dictionary<string, int>();

		private static int GetSettingOrder(string section)
		{
			if (!_sectionToSettingOrder.TryGetValue(section, out var value))
			{
				value = 0;
			}
			_sectionToSettingOrder[section] = value - 1;
			return value;
		}

		public static ConfigEntry<T> BindInOrder<T>(this ConfigFile config, string section, string key, T defaultValue, string description, AcceptableValueBase acceptableValues, bool browsable = true, bool hideDefaultButton = false, bool hideSettingName = false, bool isAdvanced = false, bool readOnly = false)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			return config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, acceptableValues, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = browsable,
					CustomDrawer = null,
					HideDefaultButton = hideDefaultButton,
					HideSettingName = hideSettingName,
					IsAdvanced = isAdvanced,
					Order = GetSettingOrder(section),
					ReadOnly = readOnly
				}
			}));
		}

		public static ConfigEntry<T> BindInOrder<T>(this ConfigFile config, string section, string key, T defaultValue, string description, Action<ConfigEntryBase> customDrawer = null, bool browsable = true, bool hideDefaultButton = false, bool hideSettingName = false, bool isAdvanced = false, bool readOnly = false)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			return config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = browsable,
					CustomDrawer = customDrawer,
					HideDefaultButton = hideDefaultButton,
					HideSettingName = hideSettingName,
					IsAdvanced = isAdvanced,
					Order = GetSettingOrder(section),
					ReadOnly = readOnly
				}
			}));
		}

		public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action settingChangedHandler)
		{
			configEntry.SettingChanged += delegate
			{
				settingChangedHandler();
			};
		}

		public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action<T> settingChangedHandler)
		{
			configEntry.SettingChanged += delegate(object _, EventArgs eventArgs)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				settingChangedHandler((T)((SettingChangedEventArgs)eventArgs).ChangedSetting.BoxedValue);
			};
		}

		public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action<ConfigEntry<T>> settingChangedHandler)
		{
			configEntry.SettingChanged += delegate(object _, EventArgs eventArgs)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				settingChangedHandler((ConfigEntry<T>)((SettingChangedEventArgs)eventArgs).ChangedSetting.BoxedValue);
			};
		}
	}
	public static class ObjectExtensions
	{
		public static T Ref<T>(this T unityObject) where T : Object
		{
			if (!Object.op_Implicit((Object)(object)unityObject))
			{
				return default(T);
			}
			return unityObject;
		}
	}
	public static class ZDOExtensions
	{
		public static bool TryGetVector3(this ZDO zdo, int hash, out Vector3 value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOExtraData.s_vec3.TryGetValue(zdo.m_uid, out var value2) && value2.TryGetValue(hash, ref value))
			{
				return true;
			}
			value = default(Vector3);
			return false;
		}
	}
}