using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using SideLoader;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace RunicBladeLongerDuration;

[BepInPlugin("com.codex.outward.runicbladelongerduration", "Runic Blade Longer Duration", "1.3.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class RunicBladeLongerDurationPlugin : BaseUnityPlugin
{
	private class LegacyConfig
	{
		public bool HasDurationSeconds;

		public float DurationSeconds = 604800f;

		public bool HasRunicBladeCountsAsLexicon;

		public bool RunicBladeCountsAsLexicon = true;

		public bool HasRequireArcaneSyntaxForRunicBladeLexicon;

		public bool RequireArcaneSyntaxForRunicBladeLexicon;
	}

	private sealed class ConfigurationManagerAttributes
	{
		public Action<ConfigEntryBase> CustomDrawer { get; set; }

		public string DispName { get; set; }

		public int? Order { get; set; }
	}

	[HarmonyPatch(typeof(RunicBlade), "ActivateLocally")]
	private static class RunicBladeActivateLocallyPatch
	{
		private static void Prefix(RunicBlade __instance)
		{
			if ((Object)(object)__instance != (Object)null)
			{
				__instance.SummonLifeSpan = s_durationSeconds;
			}
		}
	}

	[HarmonyPatch(typeof(SummonedEquipment), "Activate")]
	private static class SummonedEquipmentActivatePatch
	{
		private static void Prefix(SummonedEquipment __instance, ref float _lifespan)
		{
			if (IsRunicSummonedEquipment(__instance) && _lifespan < s_durationSeconds)
			{
				_lifespan = s_durationSeconds;
			}
		}
	}

	[HarmonyPatch(typeof(SummonedEquipment), "RefreshLifespan")]
	private static class SummonedEquipmentRefreshLifespanPatch
	{
		private static void Prefix(SummonedEquipment __instance, ref float _lifeSpan)
		{
			if (IsRunicSummonedEquipment(__instance) && _lifeSpan < s_durationSeconds)
			{
				_lifeSpan = s_durationSeconds;
			}
		}
	}

	[HarmonyPatch(typeof(Item), "HasTag", new Type[] { typeof(Tag) })]
	private static class ItemHasTagPatch
	{
		private static void Postfix(Item __instance, Tag _tag, ref bool __result)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (IsRunicBlade(__instance) && IsLexiconTag(_tag))
			{
				if (!RunicBladeLexiconAllowed(__instance))
				{
					__result = false;
				}
				else if (!__result)
				{
					__result = true;
				}
			}
		}
	}

	[HarmonyPatch(typeof(Item), "HasTag", new Type[]
	{
		typeof(IList<Tag>),
		typeof(bool)
	})]
	private static class ItemHasTagListPatch
	{
		private static void Postfix(Item __instance, IList<Tag> _tags, bool _perfectMatch, ref bool __result)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!IsRunicBlade(__instance) || _tags == null)
			{
				return;
			}
			bool flag = false;
			for (int i = 0; i < _tags.Count; i++)
			{
				if (IsLexiconTag(_tags[i]))
				{
					flag = true;
					break;
				}
			}
			if (flag && (!_perfectMatch || _tags.Count == 1))
			{
				if (!RunicBladeLexiconAllowed(__instance))
				{
					__result = false;
				}
				else if (!__result)
				{
					__result = true;
				}
			}
		}
	}

	private const string PluginGuid = "com.codex.outward.runicbladelongerduration";

	private const string SideLoaderGuid = "com.sinai.SideLoader";

	private const string PluginName = "Runic Blade Longer Duration";

	private const string PluginVersion = "1.3.1";

	private const int RunicBladeItemId = 2000100;

	private const int GreatRunicBladeItemId = 2100999;

	private const int ArcaneSyntaxSkillId = 8205180;

	private const float VanillaDurationSeconds = 180f;

	private const float DefaultDurationSeconds = 604800f;

	private const bool DefaultRunicBladeCountsAsLexicon = true;

	private const bool DefaultRequireArcaneSyntaxForRunicBladeLexicon = false;

	private static readonly string[] LexiconTag = new string[1] { "Lexicon" };

	private static float s_durationSeconds = 604800f;

	private static bool s_runicBladeCountsAsLexicon = true;

	private static bool s_requireArcaneSyntaxForRunicBladeLexicon = false;

	private readonly HashSet<string> _extendedSummonUids = new HashSet<string>();

	private ConfigEntry<float> _durationSecondsConfig;

	private ConfigEntry<bool> _runicBladeCountsAsLexiconConfig;

	private ConfigEntry<bool> _requireArcaneSyntaxForRunicBladeLexiconConfig;

	private float _durationSeconds = 604800f;

	private bool _updatingConfig;

	private static string PluginDirectory
	{
		get
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (!string.IsNullOrEmpty(directoryName))
			{
				return directoryName;
			}
			return ".";
		}
	}

	private void Awake()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		BindConfig();
		RefreshConfigValues();
		new Harmony("com.codex.outward.runicbladelongerduration").PatchAll(typeof(RunicBladeLongerDurationPlugin).Assembly);
		SL_Item.AddOnInstanceStartListener(2000100, (Action<Item>)OnRunicBladeInstanceStart);
		PatchRunicBladeEffects();
		Debug.Log((object)("[Runic Blade Longer Duration] Duration set to " + _durationSeconds.ToString("0", CultureInfo.InvariantCulture) + " seconds. Runic Blade counts as Lexicon: " + s_runicBladeCountsAsLexicon + ". Require Arcane Syntax for Runic Blade Lexicon: " + s_requireArcaneSyntaxForRunicBladeLexicon + "."));
	}

	private void BindConfig()
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Expected O, but got Unknown
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Expected O, but got Unknown
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Expected O, but got Unknown
		LegacyConfig legacyConfig = LoadLegacyConfig();
		_durationSecondsConfig = ((BaseUnityPlugin)this).Config.Bind<float>("General", "DurationSeconds", legacyConfig.HasDurationSeconds ? legacyConfig.DurationSeconds : 604800f, new ConfigDescription("Duration for Runic Blade and Great Runic Blade summons, in seconds. The mod clamps this to at least the vanilla 180 seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(180f, 315360000f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				DispName = "Summon duration, seconds",
				Order = 30
			}
		}));
		_runicBladeCountsAsLexiconConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Runic Blade Lexicon", "RunicBladeCountsAsLexicon", !legacyConfig.HasRunicBladeCountsAsLexicon || legacyConfig.RunicBladeCountsAsLexicon, new ConfigDescription("If true, one-handed Runic Blade can count as a Lexicon for rune casting. If false, the mod only changes summon duration.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				DispName = "Runic Blade counts as Lexicon",
				Order = 20
			}
		}));
		_requireArcaneSyntaxForRunicBladeLexiconConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Runic Blade Lexicon", "RequireArcaneSyntaxForRunicBladeLexicon", legacyConfig.HasRequireArcaneSyntaxForRunicBladeLexicon && legacyConfig.RequireArcaneSyntaxForRunicBladeLexicon, new ConfigDescription("If true, one-handed Runic Blade counts as a Lexicon only when the owner knows Arcane Syntax. This setting is ignored while RunicBladeCountsAsLexicon is false.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				CustomDrawer = DrawRequireArcaneSyntaxConfig,
				DispName = "Require Arcane Syntax",
				Order = 10
			}
		}));
		_durationSecondsConfig.SettingChanged += OnConfigSettingChanged;
		_runicBladeCountsAsLexiconConfig.SettingChanged += OnConfigSettingChanged;
		_requireArcaneSyntaxForRunicBladeLexiconConfig.SettingChanged += OnConfigSettingChanged;
		((BaseUnityPlugin)this).Config.Save();
	}

	private void OnConfigSettingChanged(object sender, EventArgs e)
	{
		if (!_updatingConfig)
		{
			RefreshConfigValues(saveConfig: true);
			_extendedSummonUids.Clear();
			PatchRunicBladeEffects();
			ExtendAlreadySummonedRunicWeapons();
			Debug.Log((object)("[Runic Blade Longer Duration] Config changed. Duration set to " + _durationSeconds.ToString("0", CultureInfo.InvariantCulture) + " seconds. Runic Blade counts as Lexicon: " + s_runicBladeCountsAsLexicon + ". Require Arcane Syntax for Runic Blade Lexicon: " + s_requireArcaneSyntaxForRunicBladeLexicon + "."));
		}
	}

	private void RefreshConfigValues(bool saveConfig = false)
	{
		_durationSeconds = Math.Max(180f, _durationSecondsConfig.Value);
		s_durationSeconds = _durationSeconds;
		s_runicBladeCountsAsLexicon = _runicBladeCountsAsLexiconConfig.Value;
		if (!s_runicBladeCountsAsLexicon && _requireArcaneSyntaxForRunicBladeLexiconConfig.Value)
		{
			_updatingConfig = true;
			try
			{
				_requireArcaneSyntaxForRunicBladeLexiconConfig.Value = false;
			}
			finally
			{
				_updatingConfig = false;
			}
			if (saveConfig)
			{
				((BaseUnityPlugin)this).Config.Save();
			}
		}
		s_requireArcaneSyntaxForRunicBladeLexicon = s_runicBladeCountsAsLexicon && _requireArcaneSyntaxForRunicBladeLexiconConfig.Value;
	}

	private void DrawRequireArcaneSyntaxConfig(ConfigEntryBase entry)
	{
		bool flag = _runicBladeCountsAsLexiconConfig == null || _runicBladeCountsAsLexiconConfig.Value;
		bool flag2 = entry.BoxedValue is bool && (bool)entry.BoxedValue;
		if (!flag && flag2)
		{
			entry.BoxedValue = false;
			flag2 = false;
		}
		bool enabled = GUI.enabled;
		GUI.enabled = enabled && flag;
		bool flag3 = GUILayout.Toggle(flag2, GUIContent.none, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
		GUI.enabled = enabled;
		if (flag && flag3 != flag2)
		{
			entry.BoxedValue = flag3;
		}
	}

	private static LegacyConfig LoadLegacyConfig()
	{
		string path = Path.Combine(PluginDirectory, "RunicBladeLongerDuration.cfg");
		LegacyConfig legacyConfig = new LegacyConfig();
		if (!File.Exists(path))
		{
			return legacyConfig;
		}
		try
		{
			string[] array = File.ReadAllLines(path);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				int num = text.IndexOf('=');
				if (num < 0)
				{
					continue;
				}
				string text2 = text.Substring(0, num).Trim();
				string text3 = text.Substring(num + 1).Trim();
				bool result3;
				if (text2.Equals("DurationSeconds", StringComparison.OrdinalIgnoreCase))
				{
					if (float.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
					{
						legacyConfig.DurationSeconds = Math.Max(180f, result);
						legacyConfig.HasDurationSeconds = true;
					}
				}
				else if (text2.Equals("RunicBladeCountsAsLexicon", StringComparison.OrdinalIgnoreCase))
				{
					if (TryParseBool(text3, out var result2))
					{
						legacyConfig.RunicBladeCountsAsLexicon = result2;
						legacyConfig.HasRunicBladeCountsAsLexicon = true;
					}
				}
				else if (text2.Equals("RequireArcaneSyntaxForRunicBladeLexicon", StringComparison.OrdinalIgnoreCase) && TryParseBool(text3, out result3))
				{
					legacyConfig.RequireArcaneSyntaxForRunicBladeLexicon = result3;
					legacyConfig.HasRequireArcaneSyntaxForRunicBladeLexicon = true;
				}
			}
		}
		catch (Exception ex)
		{
			Debug.LogWarning((object)("[Runic Blade Longer Duration] Could not read legacy config: " + ex.Message));
		}
		return legacyConfig;
	}

	private static bool TryParseBool(string value, out bool result)
	{
		if (bool.TryParse(value, out result))
		{
			return true;
		}
		if (string.Equals(value, "1", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "yes", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "y", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "on", StringComparison.OrdinalIgnoreCase))
		{
			result = true;
			return true;
		}
		if (string.Equals(value, "0", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "no", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "n", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "off", StringComparison.OrdinalIgnoreCase))
		{
			result = false;
			return true;
		}
		result = false;
		return false;
	}

	private void PatchRunicBladeEffects()
	{
		RunicBlade[] array = Resources.FindObjectsOfTypeAll<RunicBlade>();
		foreach (RunicBlade val in array)
		{
			if (!((Object)(object)val == (Object)null) && !(Math.Abs(val.SummonLifeSpan - _durationSeconds) < 0.01f))
			{
				val.SummonLifeSpan = _durationSeconds;
			}
		}
	}

	private void ExtendAlreadySummonedRunicWeapons()
	{
		SummonedEquipment[] array = Resources.FindObjectsOfTypeAll<SummonedEquipment>();
		foreach (SummonedEquipment val in array)
		{
			if ((Object)(object)val == (Object)null || val.RemainingLifespan <= 0f)
			{
				continue;
			}
			Item component = ((Component)val).GetComponent<Item>();
			if (!((Object)(object)component == (Object)null) && (component.ItemID == 2000100 || component.ItemID == 2100999))
			{
				string uID = component.UID;
				if (!string.IsNullOrEmpty(uID) && _extendedSummonUids.Add(uID) && val.RemainingLifespan < _durationSeconds)
				{
					val.RefreshLifespan(_durationSeconds);
				}
			}
		}
	}

	private void OnRunicBladeInstanceStart(Item item)
	{
		if (!((Object)(object)item == (Object)null) && s_runicBladeCountsAsLexicon && !s_requireArcaneSyntaxForRunicBladeLexicon)
		{
			CustomTags.SetTagSource(((Component)item).gameObject, LexiconTag, false);
		}
	}

	private static bool IsRunicBlade(Item item)
	{
		if ((Object)(object)item != (Object)null)
		{
			return item.ItemID == 2000100;
		}
		return false;
	}

	private static bool IsRunicWeapon(Item item)
	{
		if ((Object)(object)item != (Object)null)
		{
			if (item.ItemID != 2000100)
			{
				return item.ItemID == 2100999;
			}
			return true;
		}
		return false;
	}

	private static bool IsRunicSummonedEquipment(SummonedEquipment summoned)
	{
		return IsRunicWeapon(((Object)(object)summoned == (Object)null) ? null : ((Component)summoned).GetComponent<Item>());
	}

	private static bool IsLexiconTag(Tag tag)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		return string.Equals(tag.TagName, "Lexicon", StringComparison.Ordinal);
	}

	private static bool RunicBladeLexiconAllowed(Item item)
	{
		if (!s_runicBladeCountsAsLexicon)
		{
			return false;
		}
		if (!s_requireArcaneSyntaxForRunicBladeLexicon)
		{
			return true;
		}
		Character val = (((Object)(object)item == (Object)null) ? null : ((EffectSynchronizer)item).OwnerCharacter);
		if ((Object)(object)val != (Object)null && (Object)(object)val.Inventory != (Object)null && (Object)(object)val.Inventory.SkillKnowledge != (Object)null)
		{
			return ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(8205180);
		}
		return false;
	}
}