using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using AIStudio.Wpf.DiagramDesigner.Geometrys;
using AIStudio.Wpf.DiagramDesigner.Models;

namespace AIStudio.Wpf.DiagramDesigner
{
    public class BlockItemsContainerInfo : SelectableViewModelBase
    {
        public BlockItemsContainerInfo(BlockDesignerItemViewModel dataItem) : this(null, dataItem)
        {

        }

        public BlockItemsContainerInfo(IDiagramViewModel root, BlockDesignerItemViewModel dataItem) : base(root)
        {
            this.Parent = dataItem;
        }

        public BlockItemsContainerInfo(IDiagramViewModel root, SelectableItemBase designer) : base(root, designer)
        {

        }

        public BlockItemsContainerInfo(IDiagramViewModel root, SerializableItem serializableItem, string serializableType) : base(root, serializableItem, serializableType)
        {

        }

        //public override SelectableItemBase GetSerializableObject()
        //{
        //    return new ConnectorInfoItemBase(this);
        //}

        protected override void Init(IDiagramViewModel root, bool initNew)
        {
            base.Init(root, initNew);
        }

        protected override void InitNew()
        {
            ColorViewModel = new ColorViewModel()
            {
                LineWidth = 1,
                LineColor = new ColorObject() { Color = Color.FromArgb(0xAA, 0x00, 0x00, 0x80) },
                FillColor = new ColorObject() { Color = Colors.Transparent },
            };
        }

        protected override void LoadDesignerItemViewModel(SelectableItemBase designerbase)
        {
            base.LoadDesignerItemViewModel(designerbase);

            //if (designerbase is ConnectorInfoItemBase designer)
            //{
            //    PhysicalConnectorWidth = designer.PhysicalConnectorWidth;
            //    PhysicalConnectorHeight = designer.PhysicalConnectorHeight;
            //    Orientation = designer.Orientation;
            //}
        }

        #region 属性   
        private double _itemWidth = double.NaN;
        public double ItemWidth
        {
            get
            {
                return _itemWidth;
            }
            set
            {
                if (value <= 0) return;
                SetProperty(ref _itemWidth, value);
            }
        }

        private double _itemHeight = double.NaN;
        public double ItemHeight
        {
            get
            {
                return _itemHeight;
            }
            set
            {
                if (value <= 0) return;
                SetProperty(ref _itemHeight, value);
            }
        }

        private double _actualItemWidth;
        public double ActualItemWidth
        {
            get
            {
                return _actualItemWidth;
            }
            set
            {
                SetProperty(ref _actualItemWidth, value);
            }
        }

        private double _actualItemHeight;
        public double ActualItemHeight
        {
            get
            {
                return _actualItemHeight;
            }
            set
            {
                SetProperty(ref _actualItemHeight, value);
            }
        }

        public RectangleBase GetBounds()
        {
            var offset = GetOffSetFunc?.Invoke() ?? new Point(0, 0);

            return new RectangleBase(DataItem.Left + offset.X, DataItem.Top + offset.Y, GetItemWidth(), GetItemHeight());
        }

        public BlockDesignerItemViewModel DataItem
        {
            get
            {
                return Parent as BlockDesignerItemViewModel;
            }
        }

        public ObservableCollection<BlockDesignerItemViewModel> Children
        {
            get; set;
        } = new ObservableCollection<BlockDesignerItemViewModel>();

        public List<BlockItemsContainerInfo> ChildrenContain
        {
            get
            {
                return Children?.SelectMany(p => p.Contains)?.ToList();
            }
        }

        public int ContainLevel
        {
            get
            {
                if (DataItem.ParentContain == null)
                {
                    return 0;
                }
                else
                {
                    return DataItem.ParentContain.ContainLevel + 1;
                }
            }
        }

        private Func<Point> _getOffSetFunc;
        public Func<Point> GetOffSetFunc
        {
            get
            {
                return _getOffSetFunc;
            }
            set
            {
                SetProperty(ref _getOffSetFunc, value);
            }
        }

        private bool _beAttachTo;
        public bool BeAttachTo
        {
            get
            {
                return _beAttachTo;
            }
            set
            {
                SetProperty(ref _beAttachTo, value);
            }
        }

        private bool _disableAttachTo;
        public bool DisableAttachTo
        {
            get
            {
                return _disableAttachTo;
            }
            set
            {
                SetProperty(ref _disableAttachTo, value);
            }
        }

        public virtual bool CanAttachTo(DesignerItemViewModelBase item)
            => item != null && item != this.DataItem && !item.IsReadOnly && item is BlockDesignerItemViewModel;
        #endregion

        public double GetItemWidth()
        {
            return double.IsNaN(ItemWidth) ? ActualItemWidth : ItemWidth;
        }

        public double GetItemHeight()
        {
            return double.IsNaN(ItemHeight) ? ActualItemHeight : ItemHeight;
        }

        public void AddChild(BlockDesignerItemViewModel child)
        {
            child.ParentContain = this;
            Children.Add(child);
        }

        public void RemoveChild(BlockDesignerItemViewModel child)
        {
            child.ParentContain = null;
            Children.Remove(child);
        }

        public List<BlockItemsContainerInfo> GetAllContain(ObservableCollection<BlockDesignerItemViewModel> children, bool self)
        {
            List <BlockItemsContainerInfo> itemsContainers= new List <BlockItemsContainerInfo>();
            if (self)
            {
                itemsContainers.Add(this);
            }
            if (children != null)
            {
                foreach (var item in children)
                {
                    if (item.Contains != null)
                    {
                        foreach (var contain in item.Contains)
                        {
                            itemsContainers.Add(contain);
                            itemsContainers.AddRange(contain.GetAllContain(contain.Children, false));
                        }
                    }
                }
            }
            return itemsContainers;
        }
    }
}