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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Bounce.Localization;
using JetBrains.Annotations;
using ModdingTales;
using PluginUtilities;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Set Injection Flag Plugin")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Set Injection Flag Plugin")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4e4deb5e-97f9-4901-bf67-6748a9c1229a")]
[assembly: AssemblyFileVersion("3.4.1.0")]
[assembly: AssemblyInformationalVersion("3.4.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("3.4.1.0")]
namespace ModdingTales
{
	public static class ModdingUtils
	{
		private static readonly HashSet<BaseUnityPlugin> ParentPlugins = new HashSet<BaseUnityPlugin>();

		private static readonly ManualLogSource Logger = SetInjectionFlag.PluginLogger;

		private static UiText GetUITextByName(string name)
		{
			UiText[] array = Object.FindObjectsOfType<UiText>();
			for (int i = 0; i < array.Length; i++)
			{
				if (((Object)array[i]).name == name)
				{
					return array[i];
				}
			}
			return null;
		}

		[Obsolete("This automatically gets called for plugins that inherit DependencyUnityPlugin on Awake")]
		public static void AddPluginToMenuList(DependencyUnityPlugin parentPlugin)
		{
			AddPluginToMenuList(parentPlugin, string.Empty);
		}

		[Obsolete("This automatically gets called for plugins that inherit DependencyUnityPlugin on Awake")]
		public static void AddPluginToMenuList(DependencyUnityPlugin parentPlugin, string author)
		{
			if (!ParentPlugins.Contains((BaseUnityPlugin)(object)parentPlugin))
			{
				ParentPlugins.Add((BaseUnityPlugin)(object)parentPlugin);
				RefreshUIList();
				DependencyUnityPlugin dependencyUnityPlugin = parentPlugin;
				dependencyUnityPlugin.Destroyed = (Action)Delegate.Combine(dependencyUnityPlugin.Destroyed, (Action)delegate
				{
					RemovePluginFromMenuList((BaseUnityPlugin)(object)parentPlugin);
				});
			}
		}

		[Obsolete("This automatically gets called for plugins that inherit DependencyUnityPlugin on Awake")]
		public static void AddPluginToMenuList(BaseUnityPlugin parentPlugin)
		{
			ParentPlugins.Add(parentPlugin);
			RefreshUIList();
		}

		[Obsolete("This automatically gets called for plugins that inherit DependencyUnityPlugin on Awake")]
		public static void AddPluginToMenuList(BaseUnityPlugin parentPlugin, string author)
		{
			AddPluginToMenuList(parentPlugin);
		}

		[Obsolete("This automatically gets called for plugins that inherit DependencyUnityPlugin on Destroy")]
		public static void RemovePluginFromMenuList(BaseUnityPlugin parentPlugin)
		{
			ParentPlugins.Remove(parentPlugin);
			RefreshUIList();
		}

		[Obsolete("This automatically gets called for plugins that inherit DependencyUnityPlugin on Destroy")]
		public static void RemovePluginFromMenuList(BaseUnityPlugin parentPlugin, string author)
		{
			RemovePluginFromMenuList(parentPlugin);
		}

		[Obsolete("See AddPluginToMenuList")]
		public static void Initialize(BaseUnityPlugin parentPlugin, ManualLogSource logger, string author, bool startSocket = false)
		{
			AddPluginToMenuList(parentPlugin, author);
		}

		[Obsolete("See AddPluginToMenuList")]
		public static void Initialize(BaseUnityPlugin parentPlugin, ManualLogSource logger, bool startSocket = false)
		{
			AddPluginToMenuList(parentPlugin, "");
		}

		internal static void OnSceneUnloaded(Scene scene)
		{
			if (!(((Scene)(ref scene)).name != "Login"))
			{
				SetInjectionFlag.modListText = null;
				SetInjectionFlag.originalText = null;
			}
		}

		internal static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (!(((Scene)(ref scene)).name != "Login"))
			{
				UiText val = (SetInjectionFlag.modListText = GetUITextByName("Copyright Text"));
				if (Object.op_Implicit((Object)(object)val))
				{
					Logger.LogDebug((object)("Found TextMeshProUGUI in Scene: " + ((Scene)(ref scene)).name));
					SetInjectionFlag.originalText = ((TMP_Text)val).text;
					RefreshUIList();
				}
			}
		}

		internal static void RefreshUIList()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			if ((Object)(object)SetInjectionFlag.modListText == (Object)null)
			{
				return;
			}
			((TMP_Text)SetInjectionFlag.modListText).text = SetInjectionFlag.originalText;
			if (((TMP_Text)SetInjectionFlag.modListText).text.EndsWith("</size>"))
			{
				UiText modListText = SetInjectionFlag.modListText;
				((TMP_Text)modListText).text = ((TMP_Text)modListText).text + "\n\nInstalled Mods:";
			}
			foreach (BaseUnityPlugin parentPlugin in ParentPlugins)
			{
				try
				{
					BepInPlugin val = (BepInPlugin)Attribute.GetCustomAttribute(((object)parentPlugin).GetType(), typeof(BepInPlugin));
					UiText modListText2 = SetInjectionFlag.modListText;
					((TMP_Text)modListText2).text = ((TMP_Text)modListText2).text + $"\n<indent=5%>{val.Name} - {val.Version}</indent>";
					Logger.LogDebug((object)("Added Mod to List: " + val.Name));
				}
				catch (Exception ex)
				{
					Logger.LogError((object)("Error adding mod to list: " + ex.Message));
				}
			}
		}
	}
}
namespace PluginUtilities
{
	public sealed class ConfigurationAttributes
	{
		public bool? Browsable;

		public Action<object> CallbackAction;

		public string Category;

		public Func<ConfigEntryBase, GameObject> CustomDrawer;

		public object DefaultValue;

		public string Description;

		public string DispName;

		public bool? HideDefaultButton;

		public bool? HideSettingName;

		public bool? IsAdvanced;

		public bool? IsJSON;

		public Func<object, string> ObjToStr;

		public int? Order;

		public bool? ReadOnly;

		public bool? ShowRangeAsPercent;

		public Func<string, object> StrToObj;
	}
	public abstract class DependencyUnityPlugin<T> : DependencyUnityPlugin, IDependencyUnityPlugin where T : DependencyUnityPlugin<T>
	{
		internal static ConfigEntry<bool> PluginEnabled;

		private static Type[] RequiredPlugins;

		private static readonly HashSet<Type> DependantPlugins = new HashSet<Type>();

		public static bool Enabled => PluginEnabled.Value;

		private static GameObject PluginGameObject { get; set; }

		private static void EnabledChanged(object _)
		{
			if (Enabled)
			{
				Enable();
			}
			else
			{
				Disable();
			}
		}

		protected static void Enable()
		{
			if ((Object)(object)PluginGameObject.GetComponent<T>() == (Object)null)
			{
				PluginEnabled.Value = true;
				Type[] requiredPlugins = RequiredPlugins;
				for (int i = 0; i < requiredPlugins.Length; i++)
				{
					requiredPlugins[i].GetMethod("Enable", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)?.Invoke(null, null);
				}
				PluginGameObject.AddComponent<T>();
			}
		}

		protected static void Disable()
		{
			if (!((Object)(object)PluginGameObject.GetComponent<T>() != (Object)null))
			{
				return;
			}
			PluginEnabled.Value = false;
			foreach (Type dependantPlugin in DependantPlugins)
			{
				dependantPlugin.GetMethod("Disable", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)?.Invoke(null, null);
			}
			PluginGameObject.GetComponent<T>()?.DestroyAndUnbind();
		}

		internal override bool EnabledConfig()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			PluginGameObject = ((Component)this).gameObject;
			ConfigurationAttributes configurationAttributes = new ConfigurationAttributes
			{
				CallbackAction = EnabledChanged
			};
			ConfigDescription val = new ConfigDescription("", (AcceptableValueBase)null, new object[1] { configurationAttributes });
			PluginEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, val);
			IEnumerable<DependencyUnityPlugin> source = from d in DependencyUnityPlugin.GetPluginsForDependencies(((object)this).GetType())
				where d is IDependencyUnityPlugin
				select d;
			RequiredPlugins = source.Select((DependencyUnityPlugin s) => ((object)s).GetType()).ToArray();
			Type[] requiredPlugins = RequiredPlugins;
			foreach (Type type in requiredPlugins)
			{
				((BaseUnityPlugin)this).Logger.LogDebug((object)("Adding required plugin " + type.FullName + " to " + typeof(T).FullName));
			}
			foreach (IDependencyUnityPlugin item in source.Cast<IDependencyUnityPlugin>())
			{
				item.AddDep(this);
			}
			return PluginEnabled.Value;
		}

		void IDependencyUnityPlugin.AddDep(IDependencyUnityPlugin dep)
		{
			Type type = dep.GetType();
			if (!DependantPlugins.Contains(type))
			{
				((BaseUnityPlugin)this).Logger.LogDebug((object)("Adding dependant plugin " + type.FullName + " to " + typeof(T).FullName));
				DependantPlugins.Add(type);
			}
		}

		public void OnValueChanged(object _)
		{
			throw new NotImplementedException();
		}
	}
	public interface IDependencyUnityPlugin
	{
		void AddDep(IDependencyUnityPlugin dep);
	}
	public abstract class DependencyUnityPlugin : BaseUnityPlugin
	{
		public Action Destroyed;

		internal virtual bool EnabledConfig()
		{
			return true;
		}

		public static DependencyUnityPlugin[] GetPluginsForDependencies(Type type)
		{
			return (from BepInDependency d in type.GetCustomAttributes(typeof(BepInDependency), inherit: true)
				where Chainloader.PluginInfos.ContainsKey(d.DependencyGUID)
				select Chainloader.PluginInfos[d.DependencyGUID].Instance).OfType<DependencyUnityPlugin>().ToArray();
		}

		[UsedImplicitly]
		protected void Awake()
		{
			OnSetupConfig(((BaseUnityPlugin)this).Config);
			if (EnabledConfig())
			{
				DependencyUnityPlugin[] pluginsForDependencies = GetPluginsForDependencies(((object)this).GetType());
				foreach (DependencyUnityPlugin obj in pluginsForDependencies)
				{
					obj.Destroyed = (Action)Delegate.Combine(obj.Destroyed, new Action(DestroyAndUnbind));
				}
				OnAwake();
				ModdingUtils.AddPluginToMenuList(this);
			}
			else
			{
				DestroyAndUnbind();
			}
		}

		internal void DestroyAndUnbind()
		{
			DependencyUnityPlugin[] pluginsForDependencies = GetPluginsForDependencies(((object)this).GetType());
			foreach (DependencyUnityPlugin obj in pluginsForDependencies)
			{
				obj.Destroyed = (Action)Delegate.Remove(obj.Destroyed, new Action(DestroyAndUnbind));
			}
			Object.Destroy((Object)(object)this);
		}

		protected virtual void OnSetupConfig(ConfigFile config)
		{
		}

		protected virtual void OnAwake()
		{
		}

		[UsedImplicitly]
		protected void OnDestroy()
		{
			Destroyed?.Invoke();
			OnDestroyed();
		}

		protected virtual void OnDestroyed()
		{
		}
	}
	[BepInPlugin("org.generic.plugins.setinjectionflag", "Set Injection Flag Plugin", "3.4.1.0")]
	public class SetInjectionFlag : DependencyUnityPlugin<SetInjectionFlag>
	{
		public const string Guid = "org.generic.plugins.setinjectionflag";

		public const string Name = "Set Injection Flag Plugin";

		public const string Version = "3.4.1.0";

		internal static ManualLogSource PluginLogger;

		internal static UiText modListText;

		internal static string originalText;

		protected override void OnSetupConfig(ConfigFile config)
		{
			if (!EnabledConfig())
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Overriding disabled state to enabled for modding purposes");
				DependencyUnityPlugin<SetInjectionFlag>.PluginEnabled.Value = true;
				config.Save();
			}
		}

		[UsedImplicitly]
		protected override void OnAwake()
		{
			((BaseUnityPlugin)this).Logger.LogDebug((object)"Awake Triggered");
			PluginLogger = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded, You're now good to start modding!");
			AppStateManager.UsingCodeInjection = true;
			SceneManager.sceneLoaded += ModdingUtils.OnSceneLoaded;
			SceneManager.sceneUnloaded += ModdingUtils.OnSceneUnloaded;
		}

		[UsedImplicitly]
		protected override void OnDestroyed()
		{
			if ((Object)(object)modListText != (Object)null)
			{
				((TMP_Text)modListText).text = originalText;
			}
			SceneManager.sceneLoaded -= ModdingUtils.OnSceneLoaded;
			SceneManager.sceneUnloaded -= ModdingUtils.OnSceneUnloaded;
			if (!DependencyUnityPlugin<SetInjectionFlag>.Enabled)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"You Disabled this Plugin when you shouldn't have");
				DependencyUnityPlugin<SetInjectionFlag>.PluginEnabled.Value = true;
			}
		}
	}
}