using System;
using System.Collections;
using System.Reflection;

namespace WPFluent.Extensions
{
    public static class VisualExtensions
    {
        public static T FindEqualElement<T>(DependencyObject source, DependencyObject element)
            where T : DependencyObject
        {
            for (var i = 0; i < VisualTreeHelper.GetChildrenCount(source); i++)
            {
                var child = VisualTreeHelper.GetChild(source, i);
                if (child != null && child is T t && child == element)
                {
                    return t;
                }
                else
                {
                    var childOfChild = FindVisualChild<T>(child);
                    if (childOfChild != null)
                    {
                        return childOfChild;
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 查找元素的父元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="i_dp"></param>
        /// <returns></returns>
        public static T FindParent<T>(this DependencyObject i_dp) where T : DependencyObject
        {
            var dobj = VisualTreeHelper.GetParent(i_dp);
            if (dobj != null)
            {
                if (dobj is T t)
                {
                    return t;
                }
                else
                {
                    dobj = FindParent<T>(dobj);
                    if (dobj is not null and T)
                    {
                        return (T)dobj;
                    }
                }
            }
            return null;
        }

        public static T FindParent<T>(this DependencyObject i_dp, string elementName) where T : DependencyObject
        {
            var dobj = VisualTreeHelper.GetParent(i_dp);
            if (dobj != null)
            {
                if (dobj is T && ((System.Windows.FrameworkElement)(dobj)).Name.Equals(elementName))
                {
                    return (T)dobj;
                }
                else
                {
                    dobj = FindParent<T>(dobj);
                    if (dobj is not null and T)
                    {
                        return (T)dobj;
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 查找元素的子元素
        /// </summary>
        /// <typeparam name="T">子元素类型</typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static T FindVisualChild<T>(this DependencyObject obj) where T : DependencyObject
        {
            for (var i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
            {
                var child = VisualTreeHelper.GetChild(obj, i);
                if (child is not null and T)
                    return (T)child;
                else
                {
                    var childOfChild = FindVisualChild<T>(child);
                    if (childOfChild != null)
                        return childOfChild;
                }
            }
            return null;
        }

        /// <summary>
        /// 得到指定元素的集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="depObj"></param>
        /// <returns></returns>
        public static IEnumerable<T> FindVisualChildren<T>(this DependencyObject depObj) where T : DependencyObject
        {
            if (depObj != null)
            {
                for (var i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++)
                {
                    var child = VisualTreeHelper.GetChild(depObj, i);
                    if (child is not null and T)
                    {
                        yield return (T)child;
                    }

                    foreach (var childOfChild in FindVisualChildren<T>(child))
                    {
                        yield return childOfChild;
                    }
                }
            }
        }

        /// <summary>
        /// 利用visualtreehelper寻找对象的子级对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static List<T> FindVisualChildrenEx<T>(this DependencyObject obj) where T : DependencyObject
        {
            try
            {
                List<T> TList = [];
                for (var i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
                {
                    var child = VisualTreeHelper.GetChild(obj, i);
                    if (child is not null and T)
                    {
                        TList.Add((T)child);
                        var childOfChildren = FindVisualChildrenEx<T>(child);
                        if (childOfChildren != null)
                        {
                            TList.AddRange(childOfChildren);
                        }
                    }
                    else
                    {
                        var childOfChildren = FindVisualChildrenEx<T>(child);
                        if (childOfChildren != null)
                        {
                            TList.AddRange(childOfChildren);
                        }
                    }
                }
                return TList;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 查找指定名称的元素
        /// </summary>
        /// <typeparam name="childItem">元素类型</typeparam>
        /// <param name="obj"></param>
        /// <param name="elementName">元素名称，及xaml中的Name</param>
        /// <returns></returns>
        public static childItem FindVisualElement<childItem>(this DependencyObject obj, string elementName)
            where childItem : DependencyObject
        {
            for (var i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
            {
                var child = VisualTreeHelper.GetChild(obj, i);
                if (child != null &&
                    child is childItem &&
                    ((System.Windows.FrameworkElement)(child)).Name.Equals(elementName))
                    return (childItem)child;
                else
                {
                    IEnumerator j = FindVisualChildren<childItem>(child).GetEnumerator();
                    while (j.MoveNext())
                    {
                        var childOfChild = (childItem)j.Current;

                        if (childOfChild != null && !(childOfChild as FrameworkElement).Name.Equals(elementName))
                        {
                            FindVisualElement<childItem>(childOfChild, elementName);
                        }
                        else
                        {
                            return childOfChild;
                        }
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// Gets the dependency property according to its name.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns></returns>
        public static DependencyProperty GetDependencyProperty(Type type, string propertyName)
        {
            DependencyProperty prop = null;

            if (type != null)
            {
                var fieldInfo = type.GetField($"{propertyName}Property", BindingFlags.Static | BindingFlags.Public);

                if (fieldInfo != null)
                {
                    prop = fieldInfo.GetValue(null) as DependencyProperty;
                }
            }

            return prop;
        }

        /// <summary>
        /// Retrieves a <see cref="DependencyProperty"/> using reflection.
        /// </summary>
        /// <param name="o"></param>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        public static DependencyProperty GetDependencyProperty(this DependencyObject o, string propertyName)
        {
            DependencyProperty prop = null;

            if (o != null)
            {
                prop = GetDependencyProperty(o.GetType(), propertyName);
            }

            return prop;
        }

        public static IntPtr GetHandle(this Visual visual)
        { return (PresentationSource.FromVisual(visual) as HwndSource)?.Handle ?? IntPtr.Zero; }

        /// <summary>
        /// 获取属性
        /// </summary>
        public static object GetPropertyValue(this object obj, string path)
        {
            if (obj == null)
                return string.Empty;

            var flag = !string.IsNullOrEmpty(path);
            object result;
            if (flag)
            {
                var property = obj.GetType().GetProperty(path);
                var flag2 = property != null;
                if (flag2)
                {
                    try
                    {
                        result = property.GetValue(obj, null);
                        return result;
                    }
                    catch
                    {
                        try
                        {
                            var type = obj.GetType();
                            var mInfo = type.GetMethod($"get_{path}");
                            if (mInfo != null)
                            {
                                result = mInfo.Invoke(obj, null);
                                return result;
                            }
                        }
                        catch
                        {
                        }
                    }
                }
            }
            result = obj;
            return result;
        }

        /// <summary>
        /// 命中测试。根据当前选中元素，查找视觉树父节点与子节点，看是否存在指定类型的元素
        /// </summary>
        /// <typeparam name="T">想命中的元素类型</typeparam>
        /// <param name="dp">当前选中元素</param>
        /// <returns>true：命中成功</returns>
        public static bool HitTest<T>(this DependencyObject dp) where T : DependencyObject
        { return FindParent<T>(dp) != null || FindVisualChild<T>(dp) != null; }

        /// <summary>
        /// 设置 <paramref name="property"/> 只有在没有明确设置的情况下才会使用。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="o">The object.</param>
        /// <param name="property">The property.</param>
        /// <param name="value">The value.</param>
        /// <returns></returns>
        public static bool SetIfDefault<T>(this DependencyObject o, DependencyProperty property, T value)
        {
            if (o == null)
                throw new ArgumentNullException(nameof(o), "DependencyObject cannot be null");
            if (property == null)
                throw new ArgumentNullException(nameof(property), "DependencyProperty cannot be null");

            if (!property.PropertyType.IsAssignableFrom(typeof(T)))
            {
                throw new ArgumentException(
                    $"Expected {property.Name} to be of type {typeof(T).Name} but was {property.PropertyType}");
            }

            if (DependencyPropertyHelper.GetValueSource(o, property).BaseValueSource == BaseValueSource.Default)
            {
                o.SetValue(property, value);

                return true;
            }

            return false;
        }
    }
}