VitaNex_Services.cs

#region Header
//               _,-'/-'/
//   .      __,-; ,'( '/
//    \.    `-.__`-._`:_,-._       _ , . ``
//     `:-._,------' ` _,`--` -: `_ , ` ,' :
//        `---..__,,--'  (C) 2023  ` -'. -'
//        #  Vita-Nex [http://core.vita-nex.com]  #
//  {o)xxx|===============-   #   -===============|xxx(o}
//        #                                       #
#endregion

#region References
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;

using Server;

using VitaNex.IO;
using VitaNex.SuperGumps;
#endregion

namespace VitaNex
{
	public static partial class VitaNexCore
	{
		public static IEnumerable<CoreServiceInfo> Services
		{
			get
			{
				var idx = _Plugins.Count;

				while (--idx >= 0)
				{
					if (_Plugins.InBounds(idx) && _Plugins[idx] is CoreServiceInfo)
					{
						yield return (CoreServiceInfo)_Plugins[idx];
					}
				}
			}
		}

		public static int ServiceCount => Services.Count();

		public static Dictionary<Type, CoreServiceAttribute> ServiceTypeCache { get; private set; }
		public static Assembly[] ServiceAssemblies { get; private set; }

		public static event Action<CoreServiceInfo> OnServiceConfigured;
		public static event Action<CoreServiceInfo> OnServiceInvoked;
		public static event Action<CoreServiceInfo> OnServiceSaved;
		public static event Action<CoreServiceInfo> OnServiceLoaded;
		public static event Action<CoreServiceInfo> OnServiceDisposed;

		public static CoreServiceInfo GetService(Type t)
		{
			return Services.FirstOrDefault(csi => csi.TypeOf.IsEqualOrChildOf(t));
		}

		public static CoreServiceInfo[] GetServices(string name, bool ignoreCase = true)
		{
			return FindServices(name, ignoreCase).ToArray();
		}

		public static IEnumerable<CoreServiceInfo> FindServices(string name, bool ignoreCase = true)
		{
			var c = ignoreCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture;

			var idx = _Plugins.Count;

			while (--idx >= 0)
			{
				var cp = _Plugins[idx] as CoreServiceInfo;

				if (cp != null && String.Equals(cp.Name, name, c))
				{
					yield return cp;
				}
			}
		}

		private static void CompileServices()
		{
			if (Compiled)
			{
				return;
			}

			ToConsole("Compiling Services...");

			TryCatch(
				() =>
				{
					var files = ServicesDirectory.GetFiles("*.dll", SearchOption.AllDirectories);
					var asm = new List<Assembly>(files.Length);

					foreach (var file in files)
					{
						TryCatch(() => asm.Update(Assembly.LoadFrom(file.FullName)), ToConsole);
					}

					ServiceAssemblies = asm.ToArray();

					asm.AddRange(ScriptCompiler.Assemblies);
					asm.Prune();

					ScriptCompiler.Assemblies = asm.FreeToArray(true);
				},
				ToConsole);
		}

		public static void ConfigureServices()
		{
			ToConsole("Configuring Services...");

			var types = GetCoreServiceTypes();

			foreach (var csi in types.Select(kvp => new CoreServiceInfo(kvp.Key, kvp.Value)))
			{
				ConfigureService(csi);
			}
		}

		public static void ConfigureService(CoreServiceInfo csi)
		{
			if (csi == null)
			{
				return;
			}

			csi.ToConsole("Configuring...");

			if (!csi.Configured)
			{
				if (csi.ConfigSupported)
				{
					TryCatch(csi.GetConfigHandler(), csi.ToConsole);
				}

				TryCatch(csi.OnConfigured, csi.ToConsole);

				if (OnServiceConfigured != null)
				{
					TryCatch(() => OnServiceConfigured(csi), csi.ToConsole);
				}

				csi.ToConsole("Done.");
			}
			else
			{
				csi.ToConsole("Already configured, no action taken.");
			}
		}

		public static void InvokeServices()
		{
			ToConsole("Invoking Services...");

			foreach (var csi in Services.OrderBy(csi => csi.Priority))
			{
				InvokeService(csi);
			}
		}

		public static void InvokeService(CoreServiceInfo csi)
		{
			if (csi == null)
			{
				return;
			}

			csi.ToConsole("Invoking...");

			if (!csi.Invoked)
			{
				if (csi.InvokeSupported)
				{
					TryCatch(csi.GetInvokeHandler(), csi.ToConsole);
				}

				TryCatch(csi.OnInvoked, csi.ToConsole);

				if (OnServiceInvoked != null)
				{
					TryCatch(() => OnServiceInvoked(csi), csi.ToConsole);
				}

				csi.ToConsole("Done.");
			}
			else
			{
				csi.ToConsole("Already invoked, no action taken.");
			}
		}

		public static void SaveServices()
		{
			ToConsole("Saving Services...");

			foreach (var csi in Services.OrderBy(csi => csi.Priority))
			{
				SaveService(csi);
			}
		}

		public static void SaveService(CoreServiceInfo csi)
		{
			if (csi == null)
			{
				return;
			}

			csi.ToConsole("Saving...");

			TryCatch(csi.SaveOptions, csi.ToConsole);

			if (csi.SaveSupported)
			{
				TryCatch(csi.GetSaveHandler(), csi.ToConsole);
			}

			TryCatch(csi.OnSaved, csi.ToConsole);

			if (OnServiceSaved != null)
			{
				TryCatch(() => OnServiceSaved(csi), csi.ToConsole);
			}

			csi.ToConsole("Done.");
		}

		public static void LoadServices()
		{
			ToConsole("Loading Services...");

			foreach (var csi in Services.OrderBy(csi => csi.Priority))
			{
				LoadService(csi);
			}
		}

		public static void LoadService(CoreServiceInfo csi)
		{
			if (csi == null)
			{
				return;
			}

			csi.ToConsole("Loading...");

			TryCatch(csi.LoadOptions, csi.ToConsole);

			if (csi.LoadSupported)
			{
				TryCatch(csi.GetLoadHandler(), csi.ToConsole);
			}

			TryCatch(csi.OnLoaded, csi.ToConsole);

			if (OnServiceLoaded != null)
			{
				TryCatch(() => OnServiceLoaded(csi), csi.ToConsole);
			}

			csi.ToConsole("Done.");
		}

		public static void DisposeServices()
		{
			ToConsole("Disposing Services...");

			foreach (var csi in Services.OrderByDescending(csi => csi.Priority))
			{
				DisposeService(csi);
			}
		}

		public static void DisposeService(CoreServiceInfo csi)
		{
			if (csi == null)
			{
				return;
			}

			csi.ToConsole("Disposing...");

			if (!csi.Disposed)
			{
				if (csi.DisposeSupported)
				{
					TryCatch(csi.GetDisposeHandler(), csi.ToConsole);
				}

				TryCatch(csi.OnDisposed, csi.ToConsole);

				if (OnServiceDisposed != null)
				{
					TryCatch(() => OnServiceDisposed(csi), csi.ToConsole);
				}

				csi.ToConsole("Done.");
			}
			else
			{
				csi.ToConsole("Already disposed, no action taken.");
			}
		}

		/// <summary>
		///     Gets a collection of [cached] Types representing all CoreServices in this assembly
		/// </summary>
		public static Dictionary<Type, CoreServiceAttribute> GetCoreServiceTypes()
		{
			if (ServiceTypeCache != null && ServiceTypeCache.Count > 0)
			{
				return ServiceTypeCache;
			}

			ServiceTypeCache = new Dictionary<Type, CoreServiceAttribute>();

			foreach (var kvp in ScriptCompiler.Assemblies.SelectMany(
				asm => GetCoreServiceTypes(asm).Where(kvp => !ServiceTypeCache.ContainsKey(kvp.Key))))
			{
				ServiceTypeCache.Add(kvp.Key, kvp.Value);
			}

			return ServiceTypeCache;
		}

		private static IEnumerable<KeyValuePair<Type, CoreServiceAttribute>> GetCoreServiceTypes(Assembly asm)
		{
			CoreServiceAttribute[] attrs;

			foreach (var typeOf in asm.GetTypes().Where(t => t != null && t.IsClass && t.IsAbstract && t.IsSealed))
			{
				attrs = typeOf.GetCustomAttributes<CoreServiceAttribute>(false);

				if (attrs != null && attrs.Length > 0)
				{
					yield return new KeyValuePair<Type, CoreServiceAttribute>(typeOf, attrs[0]);
				}
			}
		}
	}

	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public sealed class CoreServiceAttribute : Attribute
	{
		public string Name { get; set; }
		public string Version { get; set; }
		public int Priority { get; set; }
		public bool Debug { get; set; }
		public bool Quiet { get; set; }

		public CoreServiceAttribute(
			string name,
			string version,
			int priority = TaskPriority.Medium,
			bool debug = false,
			bool quiet = true)
		{
			Name = name;
			Version = version;
			Priority = priority;
			Debug = debug;
			Quiet = quiet;
		}
	}

	[PropertyObject]
	public sealed class CoreServiceInfo : ICorePluginInfo
	{
		private const BindingFlags SearchFlags =
			BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;

		private readonly PropertyInfo _OptionsProperty;
		private readonly MethodInfo _ConfigMethod;
		private readonly MethodInfo _InvokeMethod;
		private readonly MethodInfo _LoadMethod;
		private readonly MethodInfo _SaveMethod;
		private readonly MethodInfo _DisposeMethod;

		private readonly Type _TypeOf;

		private readonly int _Priority;

		private string _Name;

		private bool _Debug;
		private bool _Quiet;

		private Action _ConfigHandler;
		private Action _InvokeHandler;
		private Action _LoadHandler;
		private Action _SaveHandler;
		private Action _DisposeHandler;

		private CoreServiceOptions _Options;
		private VersionInfo _Version;

		public bool OptionsSupported => _OptionsProperty != null;
		public bool ConfigSupported => _ConfigMethod != null;
		public bool InvokeSupported => _InvokeMethod != null;
		public bool LoadSupported => _LoadMethod != null;
		public bool SaveSupported => _SaveMethod != null;
		public bool DisposeSupported => _DisposeMethod != null;

		public bool Active { get => !Disposed; set { } }

		public bool Configured { get; private set; }
		public bool Invoked { get; private set; }
		public bool Disposed { get; private set; }

		public Assembly DynamicAssembly { get; private set; }
		public FileInfo DynamicAssemblyFile { get; private set; }

		[CommandProperty(VitaNexCore.Access)]
		public bool Dynamic => (DynamicAssembly != null && DynamicAssemblyFile != null);

		[CommandProperty(VitaNexCore.Access)]
		public int Priority => _Priority;

		[CommandProperty(VitaNexCore.Access)]
		public Type TypeOf => _TypeOf;

		[CommandProperty(VitaNexCore.Access)]
		public VersionInfo Version => _Version ?? (_Version = new VersionInfo());

		[CommandProperty(VitaNexCore.Access)]
		public string Name => _Name ?? (_Name = _TypeOf.Name);

		[CommandProperty(VitaNexCore.Access)]
		public string FullName => String.Format("{0}/{1}", Name, Version);

		[CommandProperty(VitaNexCore.Access)]
		public bool Debug
		{
			get => _Debug;
			set
			{
				_Debug = value;
				SaveState();
			}
		}

		[CommandProperty(VitaNexCore.Access)]
		public bool Quiet
		{
			get => _Quiet;
			set
			{
				_Quiet = value;
				SaveState();
			}
		}

		[CommandProperty(VitaNexCore.Access)]
		public CoreServiceOptions Options
		{
			get => OptionsSupported && _OptionsProperty.CanRead
					? (CoreServiceOptions)_OptionsProperty.GetValue(_TypeOf, null)
					: (_Options ?? (_Options = new CoreServiceOptions(_TypeOf)));
			set
			{
				if (OptionsSupported && _OptionsProperty.CanWrite)
				{
					_OptionsProperty.SetValue(_TypeOf, value, null);
				}
				else
				{
					_Options = (value ?? new CoreServiceOptions(_TypeOf));
				}
			}
		}

		public CoreServiceInfo(Type t, CoreServiceAttribute attr)
			: this(t, attr.Version, attr.Name, attr.Priority, attr.Debug, attr.Quiet)
		{ }

		public CoreServiceInfo(Type t, string version, string name, int priority, bool debug, bool quiet)
		{
			_TypeOf = t;
			_Name = name;
			_Version = version;
			_Priority = priority;
			_Debug = debug;
			_Quiet = quiet;

			if (VitaNexCore.ServiceAssemblies.Contains(_TypeOf.Assembly))
			{
				DynamicAssembly = _TypeOf.Assembly;
				DynamicAssemblyFile = new FileInfo(DynamicAssembly.Location);
				_Version = DynamicAssembly.GetName().Version.ToString();
			}

			_OptionsProperty = _TypeOf.GetProperty("CSOptions", SearchFlags);
			_ConfigMethod = _TypeOf.GetMethod("CSConfig", SearchFlags);
			_InvokeMethod = _TypeOf.GetMethod("CSInvoke", SearchFlags);
			_DisposeMethod = _TypeOf.GetMethod("CSDispose", SearchFlags);
			_LoadMethod = _TypeOf.GetMethod("CSLoad", SearchFlags);
			_SaveMethod = _TypeOf.GetMethod("CSSave", SearchFlags);

			VitaNexCore.RegisterPlugin(this);
		}

		public void OnRegistered()
		{
			LoadState();
		}

		public void OnConfigured()
		{
			Configured = true;
		}

		public void OnInvoked()
		{
			Invoked = true;
		}

		public void OnDisposed()
		{
			Disposed = true;
		}

		public void OnSaved()
		{ }

		public void OnLoaded()
		{ }

		public void SaveState()
		{
			IOUtility.EnsureFile(VitaNexCore.CacheDirectory + "/States/" + _TypeOf.FullName + ".state", true)
					 .Serialize(
						 writer =>
						 {
							 var version = writer.SetVersion(0);

							 switch (version)
							 {
								 case 0:
								 {
									 writer.Write(_Name);
									 writer.Write(_Debug);
									 writer.Write(_Quiet);
								 }
								 break;
							 }
						 });
		}

		public void LoadState()
		{
			IOUtility.EnsureFile(VitaNexCore.CacheDirectory + "/States/" + _TypeOf.FullName + ".state")
					 .Deserialize(
						 reader =>
						 {
							 if (reader.End())
							 {
								 return;
							 }

							 var version = reader.GetVersion();

							 switch (version)
							 {
								 case 0:
								 {
									 _Name = reader.ReadString();
									 _Debug = reader.ReadBool();
									 _Quiet = reader.ReadBool();
								 }
								 break;
							 }
						 });
		}

		public void SaveOptions()
		{
			IOUtility.EnsureFile(VitaNexCore.CacheDirectory + "/Options/" + _TypeOf.FullName + ".opt", true)
					 .Serialize(
						 writer =>
						 {
							 var version = writer.SetVersion(0);

							 switch (version)
							 {
								 case 0:
								 {
									 writer.WriteType(
										 Options,
										 t =>
										 {
											 if (t != null)
											 {
												 Options.Serialize(writer);
											 }
										 });
								 }
								 break;
							 }
						 });
		}

		public void LoadOptions()
		{
			IOUtility.EnsureFile(VitaNexCore.CacheDirectory + "/Options/" + _TypeOf.FullName + ".opt")
					 .Deserialize(
						 reader =>
						 {
							 if (reader.End())
							 {
								 return;
							 }

							 var version = reader.GetVersion();

							 switch (version)
							 {
								 case 0:
								 {
									 if (reader.ReadType() != null)
									 {
										 Options.Deserialize(reader);
									 }
								 }
								 break;
							 }
						 });
		}

		public Action GetConfigHandler(bool throwException = false)
		{
			if (_ConfigHandler != null)
			{
				return _ConfigHandler;
			}

			if (ConfigSupported)
			{
				return (_ConfigHandler = () => _ConfigMethod.Invoke(_TypeOf, null));
			}

			if (throwException)
			{
				throw new NotSupportedException(
					"The 'CSConfig' method of '" + _TypeOf.FullName + "' does not exist or can not be accessed");
			}

			return null;
		}

		public Action GetInvokeHandler(bool throwException = false)
		{
			if (_InvokeHandler != null)
			{
				return _InvokeHandler;
			}

			if (InvokeSupported)
			{
				return (_InvokeHandler = () => _InvokeMethod.Invoke(_TypeOf, null));
			}

			if (throwException)
			{
				throw new NotSupportedException(
					"The 'CSInvoke' method of '" + _TypeOf.FullName + "' does not exist or can not be accessed");
			}

			return null;
		}

		public Action GetDisposeHandler(bool throwException = false)
		{
			if (_DisposeHandler != null)
			{
				return _DisposeHandler;
			}

			if (DisposeSupported)
			{
				return (_DisposeHandler = () => _DisposeMethod.Invoke(_TypeOf, null));
			}

			if (throwException)
			{
				throw new NotSupportedException(
					"The 'CSDispose' method of '" + _TypeOf.FullName + "' does not exist or can not be accessed");
			}

			return null;
		}

		public Action GetLoadHandler(bool throwException = false)
		{
			if (_LoadHandler != null)
			{
				return _LoadHandler;
			}

			if (LoadSupported)
			{
				return (_LoadHandler = () => _LoadMethod.Invoke(_TypeOf, null));
			}

			if (throwException)
			{
				throw new NotSupportedException(
					"The 'CSLoad' method of '" + _TypeOf.FullName + "' does not exist or can not be accessed");
			}

			return null;
		}

		public Action GetSaveHandler(bool throwException = false)
		{
			if (_SaveHandler != null)
			{
				return _SaveHandler;
			}

			if (SaveSupported)
			{
				return (_SaveHandler = () => _SaveMethod.Invoke(_TypeOf, null));
			}

			if (throwException)
			{
				throw new NotSupportedException(
					"The 'CSSave' method of '" + _TypeOf.FullName + "' does not exist or can not be accessed");
			}

			return null;
		}

		public void ToConsole(string[] lines)
		{
			if (Quiet || lines == null || lines.Length == 0)
			{
				return;
			}

			foreach (var line in lines)
			{
				ToConsole(line);
			}
		}

		public void ToConsole(string format, params object[] args)
		{
			if (Quiet)
			{
				return;
			}

			lock (VitaNexCore.ConsoleLock)
			{
				Console.Write('[');
				Utility.PushColor(ConsoleColor.Cyan);
				Console.Write(Name);
				Utility.PopColor();
				Console.Write("]: ");
				Utility.PushColor(ConsoleColor.DarkCyan);
				Console.WriteLine(format, args);
				Utility.PopColor();
			}
		}

		public void ToConsole(Exception[] errors)
		{
			if (errors == null || errors.Length == 0)
			{
				return;
			}

			foreach (var e in errors)
			{
				ToConsole(e);
			}
		}

		public void ToConsole(Exception e)
		{
			if (e == null)
			{
				return;
			}

			lock (VitaNexCore.ConsoleLock)
			{
				Console.Write('[');
				Utility.PushColor(ConsoleColor.Cyan);
				Console.Write(Name);
				Utility.PopColor();
				Console.Write("]: ");
				Utility.PushColor(ConsoleColor.Red);
				Console.WriteLine((Quiet && !Debug) ? e.Message : e.ToString());
				Utility.PopColor();
			}

			if (Debug)
			{
				e.Log(IOUtility.EnsureFile(VitaNexCore.LogsDirectory + "/Debug/" + TypeOf.FullName + ".log"));
			}
		}

		public void CompileControlPanel(SuperGump g, int x, int y, int w, int h)
		{
			if (Options != null)
			{
				Options.CompileControlPanel(g, x, y, w, h);
			}
		}

		public override int GetHashCode()
		{
			return _TypeOf.GetHashCode();
		}

		public override bool Equals(object obj)
		{
			return obj is ICorePluginInfo && Equals((ICorePluginInfo)obj);
		}

		public bool Equals(ICorePluginInfo cp)
		{
			return !ReferenceEquals(cp, null) && (ReferenceEquals(cp, this) || cp.TypeOf == _TypeOf);
		}

		public int CompareTo(ICorePluginInfo cp)
		{
			return cp == null || cp.Disposed ? -1 : _Priority.CompareTo(cp.Priority);
		}

		public override string ToString()
		{
			return FullName;
		}
	}

	public class CoreServiceOptions : PropertyObject
	{
		private CoreServiceInfo _Service;
		private Type _ServiceType;

		[CommandProperty(VitaNexCore.Access)]
		public CoreServiceInfo Service => _Service ?? (_Service = VitaNexCore.GetService(_ServiceType));

		[CommandProperty(VitaNexCore.Access)]
		public Type ServiceType => _ServiceType;

		[CommandProperty(VitaNexCore.Access)]
		public string ServiceName => Service.Name;

		[CommandProperty(VitaNexCore.Access)]
		public string ServiceVersion => Service.Version;

		[CommandProperty(VitaNexCore.Access)]
		public bool ServiceDebug { get => Service.Debug; set => Service.Debug = value; }

		[CommandProperty(VitaNexCore.Access)]
		public bool ServiceQuiet { get => Service.Quiet; set => Service.Quiet = value; }

		public CoreServiceOptions(Type serviceType)
		{
			_ServiceType = serviceType;
		}

		public CoreServiceOptions(GenericReader reader)
			: base(reader)
		{ }

		public override void Clear()
		{
			ServiceDebug = false;
			ServiceQuiet = false;
		}

		public override void Reset()
		{
			ServiceDebug = false;
			ServiceQuiet = false;
		}

		public virtual void ToConsole(string[] lines)
		{
			Service.ToConsole(lines);
		}

		public virtual void ToConsole(string format, params object[] args)
		{
			Service.ToConsole(format, args);
		}

		public virtual void ToConsole(Exception[] errors)
		{
			Service.ToConsole(errors);
		}

		public virtual void ToConsole(Exception e)
		{
			Service.ToConsole(e);
		}

		public virtual void CompileControlPanel(SuperGump g, int x, int y, int w, int h)
		{ }

		public override string ToString()
		{
			return "Service Options";
		}

		public override void Serialize(GenericWriter writer)
		{
			writer.Write(VitaNexCore.Version);

			base.Serialize(writer);

			var version = writer.SetVersion(0);

			switch (version)
			{
				case 0:
					writer.WriteType(_ServiceType);
					break;
			}
		}

		public override void Deserialize(GenericReader reader)
		{
			/*string vncVersion = reader.ReadString();*/
			reader.ReadString();

			base.Deserialize(reader);

			var version = reader.GetVersion();

			switch (version)
			{
				case 0:
					_ServiceType = reader.ReadType();
					break;
			}
		}
	}
}