using HMI.Core.Entity;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Windows.Data;

namespace HMI.UI
{
    public class TreeItemData : NotifyBase
    {

        public event EventHandler<bool> IsExpandedChange;
        public event EventHandler<bool> VisibleChange;

        protected override void Set(string name)
        {
            base.Set(name);
            if (!name.Equals("IconType"))
            {
                IconType = GetIconType();
            }
        }

        #region 属性 IsExpanded
        private bool _IsExpanded = true;
        public bool IsExpanded
        {
            get => _IsExpanded;
            set
            {
                //if (_IsExpanded == value)
                //{
                //    return;
                //}
                _IsExpanded = value;
                Set("IsExpanded");
                SetItemsVisible(value);
                IsExpandedChange?.Invoke(this, value);
            }
        }
        #endregion

        #region 属性 IsVisible
        private bool _IsVisible = true;

        public bool IsVisible
        {
            get
            {
                return _IsVisible;
            }
            set
            {
                if (_IsVisible == value)
                {
                    return;
                }
                _IsVisible = value;
                Set("IsVisible");
                SetItemsVisible(value);
                VisibleChange?.Invoke(this, value);
            }
        }

        /// <summary>
        /// 用于展开的可见
        /// </summary>
        /// <param name="visible"></param>
        private void SetItemsVisible(bool visible)
        {
            if (IsExpanded == false || visible == false)
            {
                Items.ForEach(p => p.IsVisible = false);
            }
            else
            {
                Items.ForEach(p => p.IsVisible = true);
            }
        }

        /// <summary>
        /// 设置筛选是否可见，比如筛选name1,则包含name1的数据和其父节点都可见
        /// </summary>
        public bool SelectVisible
        {
            get
            {
                return _IsVisible;
            }
            set
            {
                if (_IsVisible == value)
                {
                    return;
                }
                _IsVisible = value;
                Set("IsVisible");
                SetItemsVisible(value);
            }
        }

        /// <summary>
        /// 用于筛选的可见
        /// </summary>
        /// <param name="visible"></param>
        private void SetSelectVisible(bool visible)
        {
            if (visible)
            {
                ParentItem.SelectVisible = visible;
            }
            Items.ForEach(p => p.IsVisible = visible);
        }
        #endregion

        public void NotifyUI()
        {
            IsExpanded = _IsExpanded;
        }

        #region 属性 Level
        private int _Level = 0;
        public int Level
        {
            get
            {
                return _Level;
            }
            set
            {
                _Level = value;
                Set("Level");
            }
        }
        #endregion

        #region 属性 IsFirstItem
        private bool _IsFirstItem = true;
        public bool IsFirstItem
        {
            get
            {
                return _IsFirstItem;
            }
            set
            {
                _IsFirstItem = value;
                Set("IsFirstItem");
            }
        }
        #endregion

        #region 属性 IsLastItem
        private bool _IsLastItem = false;
        public bool IsLastItem
        {
            get
            {
                return _IsLastItem;
            }
            set
            {
                _IsLastItem = value;
                Set("IsLastItem");
            }
        }
        #endregion

        #region 属性 Data
        private object _Data = null;
        public object Data
        {
            get
            {
                return _Data;
            }
            set
            {
                _Data = value;
                Set("Data");
            }
        }
        #endregion

        /// <summary>
        /// 所有子项数量
        /// </summary>
        private int allSubCount;

        public int AllSubCount
        {
            get { return allSubCount; }
            set { allSubCount = value; }
        }


        #region 属性 ParentItem
        private TreeItemData _ParentItem = null;
        public TreeItemData ParentItem
        {
            get
            {
                return _ParentItem;
            }
            set
            {
                _ParentItem = value;
                Set("ParentItem");
            }
        }
        #endregion

        #region 属性 ParentItems
        private List<TreeItemData> _ParentItems = null;
        public List<TreeItemData> ParentItems
        {
            get
            {
                if (_ParentItems == null)
                {
                    _ParentItems = new List<TreeItemData>();
                }
                return _ParentItems;
            }
            set
            {
                _ParentItems = value;
                Set("ParentItems");
            }
        }
        #endregion

        #region 属性 Items
        private List<TreeItemData> _Items = null;
        public List<TreeItemData> Items
        {
            get
            {
                if (_Items == null)
                {
                    _Items = new List<TreeItemData>();
                }
                return _Items;
            }
            set
            {
                _Items = value;
                Set("Items");
            }
        }
        #endregion

        #region 属性 HasItems
        public bool HasItems
        {
            get
            {
                return Items.Count > 0;
            }
        }
        #endregion

        #region 属性 IconType
        /// <summary>
        /// 他是控制树前的按钮的，有事找他
        /// </summary>
        private int _IconType = 0;
        public int IconType
        {
            get
            {
                return _IconType;
            }
            set
            {
                if (_IconType == value)
                {
                    return;
                }

                _IconType = value;
                Set("IconType");
            }
        }
        #endregion

        int GetIconType()
        {
            if (HasItems)
            {
                if (IsFirstItem && IsLastItem && Level == 0)
                {
                    return IsExpanded ? 5 : 1;
                }

                if (Level == 0 && IsFirstItem)
                {
                    return IsExpanded ? 5 : 2;
                }

                if (IsLastItem)
                {
                    return IsExpanded ? 7 : 0;
                }

                return IsExpanded ? 7 : 0;
            }
            if (IsLastItem)
            {
                return 9;
            }
            else
            {
                return 8;
            }
        }
    }

    public class TreeItemDataCollection : ObservableCollection<TreeItemData>
    {
        IEnumerable _SourceItems = null;

        string _ItemsPath = "";

        List<TreeItemData> _RootItems = new List<TreeItemData>();
        List<TreeItemData> levelOneItems = new List<TreeItemData>();

        private PropertyInfo subDataProperty;

        #region 属性 UseTree
        private bool _UseTree = true;
        public bool UseTree
        {
            get
            {
                return _UseTree;
            }
            set
            {
                _UseTree = value;
            }
        }

        public List<TreeItemData> RootItems
        {
            get => _RootItems;
        }

        #endregion

        public TreeItemDataCollection()
        {

        }

        public TreeItemDataCollection(IEnumerable sourceItems, string itemsPath, bool useTree = false)
        {
            _SourceItems = sourceItems;
            _ItemsPath = itemsPath;
            if (_SourceItems is INotifyCollectionChanged list)
            {
                list.CollectionChanged += List_CollectionChanged;
            }
            UseTree = useTree;
            ResetItems();
            //subDataProperty = typeof(T).GetProperty(itemsPath);
        }

        protected override void MoveItem(int oldIndex, int newIndex)
        {
            CheckReentrancy();
            TreeItemData source = base[oldIndex];
            TreeItemData target = base[newIndex];
            newIndex += target.AllSubCount;
            if (newIndex == oldIndex - 1)
            {
                return;
            }
            target = base[newIndex];
            int times = source.AllSubCount;

            if (oldIndex < newIndex)
            {
                base.RemoveItem(oldIndex);
                base.InsertItem(newIndex, source);
                OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
                /// 从上往下拉
                for (int i = 0; i < times; i++)
                {
                    CheckReentrancy();
                    source = base[oldIndex];
                    target = base[newIndex];
                    base.RemoveItem(oldIndex);
                    base.InsertItem(newIndex, source);
                    OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
                }
            }
            else if (oldIndex > newIndex)
            {
                /// 从下往上拉
                base.RemoveItem(oldIndex);
                base.InsertItem(++newIndex, source);
                OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
                //MessageBox.Show($"source: {source.Data} {oldIndex}; target: {target.Data} {newIndex}");
                for (int i = 0; i < times; i++)
                {
                    oldIndex++;
                    newIndex++;
                    CheckReentrancy();
                    source = base[oldIndex];
                    target = base[newIndex];
                    //MessageBox.Show($"source: {source.Data} {oldIndex}; target: {target.Data} {newIndex}");
                    base.RemoveItem(oldIndex);
                    base.InsertItem(newIndex, source);
                    OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
                }
            }
        }

        private void List_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            //ResetItems();
        }

        public void ResetItems()
        {
            CheckReentrancy();
            if (_SourceItems is null)
            {
                ClearAllItems();
                return;
            }

            var items = new List<TreeItemData>();
            _RootItems.Clear();

            Dictionary<dynamic, TreeItemData> list = this.Items.
                ToLookup(t => t.Data, t => t).ToDictionary(t => t.Key, t => t.First());
            foreach (var item in _SourceItems)
            {
                if (list.TryGetValue(item, out var treeItem))
                {
                    list.Remove(item);
                }
                else
                {
                    treeItem = new TreeItemData { Data = item };
                }

                treeItem.ParentItems.Clear();
                treeItem.Level = 0;
                items.Add(treeItem);
                _RootItems.Add(treeItem);
                var subItems = GetSubItems(treeItem, _ItemsPath, list);
                treeItem.AllSubCount = subItems.Count();
                foreach (var sitem in subItems)
                {
                    items.Add(sitem);
                }
            }

            ResetSubItems(_RootItems);

            this.Items.Clear();
            items.ForEach(t => this.Items.Add(t));
            //if (UseTree)
            //{
            //    _RootItems.ForEach(t => this.Items.Add(t));
            //}
            //else
            //{
            //    items.ForEach(t => this.Items.Add(t));
            //}
            OnPropertyChanged(new PropertyChangedEventArgs("Count"));
            OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
        }

        public static void ResetSubItems(IList<TreeItemData> items)
        {
            for (int i = 0; i < items.Count; i++)
            {
                var item = items[i];
                item.IsFirstItem = i == 0;
                item.IsLastItem = i == items.Count - 1;
            }
        }

        private IEnumerable<TreeItemData> GetSubItems(TreeItemData treeItem, string itemsPath, Dictionary<object, TreeItemData> list)
        {
            var data = treeItem.Data;
            var p = data.GetType().GetProperty(itemsPath);
            var pvalue = p.GetValue(data, null);

            if (pvalue is INotifyCollectionChanged inc)
            {
                //inc.CollectionChanged -= List_CollectionChanged;
                //inc.CollectionChanged += List_CollectionChanged;
            }

            treeItem.Items.Clear();
            if (pvalue is IEnumerable subItems)
            {
                foreach (var item in subItems)
                {
                    if (list.TryGetValue(item, out var subitem))
                    {
                        list.Remove(item);
                    }
                    else
                    {
                        subitem = new TreeItemData { Data = item };
                    }

                    subitem.ParentItem = treeItem;
                    subitem.Level = treeItem.Level + 1;

                    subitem.ParentItems.Clear();
                    foreach (var pitem in treeItem.ParentItems)
                    {
                        subitem.ParentItems.Add(pitem);
                    }
                    subitem.ParentItems.Add(treeItem);

                    treeItem.Items.Add(subitem);
                    yield return subitem;
                    var subSub = GetSubItems(subitem, itemsPath, list);
                    subitem.AllSubCount = subSub.Count();
                    foreach (var sitem in subSub)
                    {
                        yield return sitem;
                    }
                }
                if (treeItem.Items.Count > 0)
                {
                    ResetSubItems(treeItem.Items);
                }
            }
        }

        private void ClearAllItems()
        {
            this.Items.Clear();
        }
    }

    public class TreeItemDataConverter : IValueConverter
    {
        #region 属性 UseTree
        private bool _UseTree = false;
        public bool UseTree
        {
            get
            {
                return _UseTree;
            }
            set
            {
                _UseTree = value;
            }
        }
        #endregion

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value == null || parameter == null)
            {
                return value;
            }
            if (value is IEnumerable items)
            {
                return new TreeItemDataCollection(items, parameter.ToString(), UseTree);
            }
            return value;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return value;
        }
    }
}