using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace axXez.TS3.Bot
{
    /// <summary>Metadata descriptor for a module type — name, display name, description, namespace, and the CLR type itself.</summary>
    public class ModuleType
    {
        /// <summary>Short name of the module (class name).</summary>
        public string Name => Type.Name;
        /// <summary>Fully qualified name of the module (namespace + class name), e.g. <c>"axXez.Greetings"</c>.</summary>
        public string FullName => $"{Namespace}.{Name}";
        /// <summary>Human-readable display name. Returns <see cref="ModuleAttribute.DisplayName"/> if set, otherwise falls back to <see cref="Name"/>.</summary>
        public string DisplayName => Attribute != null && !string.IsNullOrWhiteSpace(Attribute.DisplayName) ? Attribute.DisplayName : Name;
        /// <summary>Short description of the module. Returns <see cref="ModuleAttribute.Description"/> if set, otherwise empty.</summary>
        public string Description => Attribute != null && !string.IsNullOrWhiteSpace(Attribute.Description) ? Attribute.Description : string.Empty;
        /// <summary>Namespace prefix. Returns <see cref="ModuleAttribute.Namespace"/> if set, otherwise the type's CLR namespace.</summary>
        public string Namespace => Attribute != null && !string.IsNullOrWhiteSpace(Attribute.Namespace) ? Attribute.Namespace : Type.Namespace;
        /// <summary>The underlying CLR type of the module.</summary>
        public Type Type { get; private set; }

        /// <summary>The <see cref="ModuleAttribute"/> applied to the module class, or <c>null</c> if none is present.</summary>
        public ModuleAttribute Attribute { get; private set; }

        /// <summary>Returns <c>true</c> if this module is compatible with the given server version.</summary>
        public bool IsCompatibleWith(ServerVersion version)
        {
            var compat = Attribute?.Compatibility ?? ModuleCompatibility.Any;
            return version switch
            {
                ServerVersion.TS3 => compat.HasFlag(ModuleCompatibility.TS3),
                ServerVersion.TS6 => compat.HasFlag(ModuleCompatibility.TS6),
                _ => compat.HasFlag(ModuleCompatibility.Unknown)
            };
        }

        internal IReadOnlyList<(MethodInfo Method, CommandAttribute Attr)> CommandMethods { get; private set; }

        private ModuleType(Type type)
        {
            Type = type;
            Attribute = type.GetCustomAttribute<ModuleAttribute>(false);
            CommandMethods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)
                .Select(m => (Method: m, Attr: m.GetCustomAttribute<CommandAttribute>()))
                .Where(x => x.Attr != null)
                .ToList();
        }

        internal static ModuleType FromType(Type type) => new ModuleType(type);
        internal static ModuleType FromType<T>() where T : Module => new ModuleType(typeof(T));


        internal static IEnumerable<ModuleType> FromAssembly(Assembly assembly)
            => assembly.GetTypes().Where(x => typeof(Module).IsAssignableFrom(x) && x.IsAbstract == false).Select(FromType);

        /// <inheritdoc/>
        public override string ToString() => $"{Name} ({Type.FullName})";
        /// <inheritdoc/>
        public override int GetHashCode() => Type.GUID.GetHashCode();
        /// <inheritdoc/>
        public override bool Equals(object obj)
            => typeof(ModuleType).IsAssignableFrom(obj.GetType()) && (obj as ModuleType).Type.GUID.Equals(Type.GUID);
    }
}