//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using OpenTap.Translation;

namespace OpenTap
{
    /// <summary> Helpers for work with ITypeInfo objects. </summary>
    public static class ReflectionDataExtensions
    {
        /// <summary>
        /// Creates an instance of this type using the default constructor.
        /// </summary>
        public static object CreateInstance(this ITypeData type)
        {
            return type?.CreateInstance(Array.Empty<object>());
        }

        /// <summary> returns true if 'type' is a descendant of 'basetype'. </summary>
        /// <param name="type"></param>
        /// <param name="basetype"></param>
        /// <returns></returns>
        public static bool DescendsTo(this ITypeData type, ITypeData basetype)
        {
            if (basetype is TypeData basetype2)
            {
                return DescendsTo(type, basetype2.Type);
            }
            while (type != null)
            {    
                if (object.Equals(type, basetype))
                    return true;
                type = type.BaseType;
            }
            return false;
        }
        /// <summary> returns tru if 'type' is a descendant of 'basetype'. </summary>
        /// <param name="type"></param>
        /// <param name="basetype"></param>
        /// <returns></returns>
        public static bool DescendsTo(this ITypeData type, Type basetype)
        {
            while (type != null)
            {
                if (type is TypeData cst)
                {
                    return cst.Type.DescendsTo(basetype);
                }

                type = type.BaseType;
            }
            return false;
        }

        internal static bool HasAttributeInherited<T>(this IReflectionData mem) where T : class
        {
            if (mem is ITypeData td)
            {
                while (td != null)
                {
                    if (td.HasAttribute<T>()) return true;
                    td = td.BaseType;
                }

                return false;
            }

            throw new ArgumentException("Inherited attributes can only be read from type data instances.");
        }
        
        internal static IEnumerable<T> GetAttributesInherited<T>(this IReflectionData mem) where T : class
        {
            if (mem is ITypeData td)
            {
                IEnumerable<T> result = null;
                while (td != null)
                {
                    var r = td.Attributes?.OfType<T>();
                    if (r?.Any() == true)
                    {
                        if(result != null)
                            result = result.Concat(r);
                        else result = r;
                    }

                    td = td.BaseType;
                }

                return result ?? Array.Empty<T>();
            }

            throw new ArgumentException("Inherited attributes can only be read from type data instances.");
        }

        /// <summary>
        /// Returns true if a reflection ifno has an attribute of type T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="mem"></param>
        /// <returns></returns>
        static public bool HasAttribute<T>(this IReflectionData mem) where T: class
        {
            return mem.GetAttribute<T>() != null;
        }

        /// <summary> Gets the attribute of type T from mem. </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="mem"></param>
        /// <returns></returns>
        public static T GetAttribute<T>(this IReflectionData mem)
        {
            if (mem is TypeData td)
            {
                if(typeof(T) == typeof(DisplayAttribute))
                {
                    return (T)(object)td.Display;
                }
                if (typeof(T) == typeof(HelpLinkAttribute))
                {
                    return (T)(object)td.HelpLink;
                }
            }

            var attributes = mem.Attributes;
            if (attributes is object[] array)
            {
                // performance optimization: faster iterations if we know its an array.
                foreach (var thing in array)
                    if (thing is T x)
                        return x;
            }
            else
            {
                foreach (var thing in attributes)
                    if (thing is T x)
                        return x;
            }

            return default;
        }

        internal static bool IsBrowsable(this IReflectionData mem)
        {
            if (mem is TypeData td)
            {
                return td.IsBrowsable;
            }
            var attr = mem.GetAttribute<BrowsableAttribute>();
            if (attr is null)
                return true;
            return attr.Browsable;
        }

        /// <summary> Gets all the attributes of type T.</summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="mem"></param>
        /// <returns></returns>
        public static IEnumerable<T> GetAttributes<T>(this IReflectionData mem)
        {
            var attrs = mem.Attributes;
            bool once = false;
            T first = default;
            if (attrs is object[] attrsArray)
            {
                // performance optimization: faster iterations if we know its an array.
                foreach (var elem in attrsArray)
                {
                    if (elem is T x)
                    {
                        if (once) // multiple instances of T, lets just use OfType.
                            return attrsArray.OfType<T>();
                        once = true;
                        first = x;
                    }
                }
            }
            else
            {
                foreach (var elem in attrs)
                {
                    if (elem is T x)
                    {
                        if (once) // multiple instances of T, lets just use OfType. 
                            return attrs.OfType<T>();
                        once = true;
                        first = x;
                    }
                }
            }

            if (once) return new [] { first };
            return Array.Empty<T>();
        }

        /// <summary> Gets a display attribute of mem in the selected language, if available. Otherwise the default display attribute is returned. </summary>
        /// <param name="mem">The member to translate</param>
        /// <param name="language">The desired language of the translation. If not specified, the language from EngineSettings is used.</param>
        /// <returns></returns>
        public static DisplayAttribute GetTranslatedDisplayAttribute(this IReflectionData mem, CultureInfo language = null)
        {
            return TranslationManager.TranslateMember(mem, language);
        }

        /// <summary> Gets the display attribute of mem. </summary>
        /// <param name="mem">The member to translate</param>
        /// <returns></returns>
        public static DisplayAttribute GetDisplayAttribute(this IReflectionData mem)
        {
            DisplayAttribute attr;
            if (mem is TypeData td)
                attr = td.Display;
            else
                attr = mem.GetAttribute<DisplayAttribute>();
            if (attr != null) return attr;
            // auto-generate a display attribute.
            return new DefaultDisplayAttribute(mem);
        }

        /// <summary>Gets the help link of 'member'</summary>
        /// <param name="member"></param>
        /// <returns></returns>
        internal static HelpLinkAttribute GetHelpLink(this IReflectionData member)
        {
            var attr = member.GetAttribute<HelpLinkAttribute>();
            if (attr != null)
                return attr;
            if (member is IMemberData meminfo)// Recursively look for class level help.
                return meminfo.DeclaringType.GetHelpLink();
            return null;
        }
    }
}