using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using AIStudio.Wpf.DiagramDesigner.Models;
using static System.Net.Mime.MediaTypeNames;

namespace AIStudio.Wpf.DiagramDesigner
{
    public class BlockDesignerItemViewModel : DesignerItemViewModelBase
    {
        public BlockDesignerItemViewModel()
        {
        }

        public BlockDesignerItemViewModel(IDiagramViewModel root) : base(root)
        {
        }

        public BlockDesignerItemViewModel(IDiagramViewModel root, SelectableItemBase designer) : base(root, designer)
        {
        }

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

        protected override void InitNew()
        {
            ItemWidth = double.NaN;
            ItemHeight = double.NaN;
            AddConnector(new BlockConnectorInfo(this.Root, this, ConnectorOrientation.Top));
            AddConnector(new BlockConnectorInfo(this.Root, this, ConnectorOrientation.Bottom));
            IsReadOnlyText = true;
        }

        public void AddNext(BlockDesignerItemViewModel next)
        {
            if (this.Next == next)
            {
                AlignNext(next);
                return;
            }
            var oldnext = this.Next;
            RemoveNext();

            next.Left = this.Left;
            next.Top = this.Top + this.GetItemHeight();
            next.ParentId = this.Id;
            next.Parent = this;
            this.Next = next;
            if (next.Next != null)
            {
                next.AlignNext(next.Next);
            }
            if (oldnext != null)
            {
                System.Windows.Application.Current?.Dispatcher.BeginInvoke(new Action(async () => {
                    await Task.Delay(10);
                    GetLast().AddNext(oldnext);
                }));
               
            }
        }

        public void AlignNext(BlockDesignerItemViewModel next)
        {
            if (next != null && this.Next == next)
            {
                next.Left = this.Left;
                next.Top = this.Top + this.GetItemHeight();
                if (next.Next != null)
                {
                    next.AlignNext(next.Next);
                }
                return;
            }
        }

        public void RemoveNext()
        {
            var next = this.Next;
            if (next != null)
            {
                next.ParentId = new Guid();
                next.Parent = null;
                this.Next = null;
            }
        }

        public override void AddToSelection(bool selected, bool clearother)
        {
            if (clearother)
            {
                foreach (SelectableDesignerItemViewModelBase item in Root.SelectedItems.ToList())
                {
                    if (item != this)
                    {
                        item.RemoveFromSelection();
                    }
                }
            }

            IsSelected = selected;
        }

        public virtual void AddChild(BlockDesignerItemViewModel child, BlockItemsContainerInfo container)
        {
            child.RemoveFromSelection();
            this.GetRootContainItem.AddToSelection(true, true);

            System.Windows.Application.Current?.Dispatcher.BeginInvoke(new Action(async () => {
                await Task.Delay(10);
                AlignNext(this.Next);
            }));           
        }

        public virtual void RemoveChild(BlockDesignerItemViewModel child, BlockItemsContainerInfo container)
        {
            this.RemoveFromSelection();

            child.AddToSelection(true, true);

            System.Windows.Application.Current?.Dispatcher.BeginInvoke(new Action(async () => {
                await Task.Delay(10);
                AlignNext(this.Next);
            }));
        }

        public int BlockLevel
        {
            get
            {
                if (Prev == null)
                {
                    return 0;
                }
                else
                {
                    return Prev.BlockLevel + 1;
                }
            }
        }

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

        public BlockDesignerItemViewModel Next
        {
            get; set;
        }

        public bool CanContainTo
        {
            get; set;
        } = true;

        public BlockItemsContainerInfo ParentContainer
        {
            get; set;
        }

        public ObservableCollection<BlockItemsContainerInfo> Containers
        {
            get; set;
        } = new ObservableCollection<BlockItemsContainerInfo>();

        public BlockItemsContainerInfo FirstContainer
        {
            get
            {
                return Containers?.FirstOrDefault();
            }
        }

        public BlockItemsContainerInfo SecondContainer
        {
            get
            {
                return Containers?.Skip(1)?.FirstOrDefault();
            }
        }

        public BlockItemsContainerInfo ThirdContainer
        {
            get
            {
                return Containers?.Skip(2)?.FirstOrDefault();
            }
        }        

        public BlockDesignerItemViewModel GetFirst()
        {
            var parent = this.Next;
            if (parent != null)
            {
                while (parent.Parent != null)
                {
                    parent = parent.Parent as BlockDesignerItemViewModel;
                }
            }
            return parent;
        }

        public BlockDesignerItemViewModel GetLast()
        {
            var next = this;
            if (next != null)
            {
                while (next.Next != null)
                {
                    next = next.Next;
                }
            }
            return next;
        }

        public List<BlockItemsContainerInfo> GetAllContain()
        {
            return Containers.SelectMany(p => p.GetAllContain(p.Children, true)).ToList();
        }

        public BlockDesignerItemViewModel GetRootContainItem
        {
            get
            {
                if (ParentContainer == null)
                {
                    return this;
                }
                else
                {
                    return ParentContainer.DataItem.GetRootContainItem;
                }
            }
        }
    }
}