using System;
using System.Collections;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;

namespace WpfCustomContainer
{
    public class ConstraintStackPanel : StackPanel
    {
        internal List<GridLength> _gridLengths;
        internal GridLengthConstraintCollection _gridConstraintCollection;

        public GridLengthConstraintCollection GridConstraints
        {
            get
            {
                if (_gridConstraintCollection == null)
                {
                    _gridLengths = new List<GridLength>();
                    _gridConstraintCollection = new GridLengthConstraintCollection(this);
                }
                return _gridConstraintCollection;
            }
        }

        public ConstraintStackPanel()
        { 
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            var desiredSize = new Size();
            var vertical = this.Orientation == Orientation.Vertical;
            var postponedIndex = new List<int>();
            double totalStars = 0.0;
            int index = 0;
            foreach (UIElement element in this.InternalChildren)
            {
                var gl = _gridLengths != null && index < _gridLengths.Count ? _gridLengths[index] : GridLength.Auto;
                if (gl.IsStar)
                {
                    postponedIndex.Add(index++);
                    totalStars += gl.Value;
                    continue;
                }
                Size constraint;
                if (gl.IsAuto)
                {
                    constraint = vertical
                        ? new Size(availableSize.Width, double.PositiveInfinity)
                        : new Size(double.PositiveInfinity, availableSize.Height);
                }
                else
                {
                    constraint = vertical
                        ? new Size(availableSize.Width, gl.Value)
                        : new Size(gl.Value, availableSize.Height);
                }
                element.Measure(constraint);
                var size = element.DesiredSize;
                if (vertical)
                {
                    desiredSize.Width = Math.Max(desiredSize.Width, size.Width);
                    desiredSize.Height += size.Height;
                }
                else
                {
                    desiredSize.Width += size.Width;
                    desiredSize.Height = Math.Max(desiredSize.Height, size.Height);
                }
                index +=1;
            }
            // Measure stared elements
            var readjust = true;
            while (readjust)
            {
                readjust = false;
                for (index = postponedIndex.Count; --index >= 0;)
                {
                    var element = this.InternalChildren[postponedIndex[index]];
                    var g = _gridLengths[postponedIndex[index]].Value;

                    var constraint = vertical
                        ? new Size(availableSize.Width, g * (availableSize.Height - desiredSize.Height) / totalStars)
                        : new Size(g * (availableSize.Width - desiredSize.Width) / totalStars, availableSize.Height);
                    if (constraint.Width <= 0.0 || constraint.Height <= 0)
                        break;
                    element.Measure(constraint);
                    var size = element.DesiredSize;
                    if (vertical && size.Height < constraint.Height)
                    {
                        desiredSize.Width = Math.Max(desiredSize.Width, size.Width);
                        desiredSize.Height += size.Height;
                        totalStars -= g;
                        postponedIndex.RemoveAt(index);
                        readjust = true;
                    }
                    else if (!vertical && size.Width < constraint.Width)
                    {
                        desiredSize.Width += size.Width;
                        desiredSize.Height = Math.Max(desiredSize.Height, size.Height);
                        totalStars -= g;
                        postponedIndex.RemoveAt(index);
                        readjust = true;
                    }
                }
            }
            if (index >= 0)
            {
                // finally just allow remaining stared elements to take whole place
                foreach (var idx in postponedIndex)
                {
                    var element = this.InternalChildren[idx];
                    var constraint = vertical
                            ? new Size(availableSize.Width, double.PositiveInfinity)
                            : new Size(double.PositiveInfinity, availableSize.Height);
                    element.Measure(constraint);
                    var size = element.DesiredSize;
                    if (vertical)
                    {
                        desiredSize.Width = Math.Max(desiredSize.Width, size.Width);
                        desiredSize.Height += size.Height;
                    }
                    else
                    {
                        desiredSize.Width += size.Width;
                        desiredSize.Height = Math.Max(desiredSize.Height, size.Height);
                    }
                }
            }
            return desiredSize;
        }
    }

    public class GridLengthConstraintCollection : IList<GridLength>, ICollection<GridLength>, IEnumerable<GridLength>, IEnumerable, IList, ICollection
    {
        ConstraintStackPanel _panel;

        internal GridLengthConstraintCollection(ConstraintStackPanel panel)
        {
            _panel = panel;
        }

        public GridLength this[int index] { get => _panel._gridLengths[index]; set => _panel._gridLengths[index] = value; }
        object IList.this[int index] { get => ((IList)_panel._gridLengths)[index]; set => ((IList) _panel._gridLengths)[index] = value; }

        public int Count => _panel._gridLengths.Count;

        public bool IsReadOnly => false;

        public bool IsFixedSize => false;

        public object SyncRoot => _panel._gridLengths;

        public bool IsSynchronized => false;

        public void Add(GridLength item)
        {
            _panel._gridLengths.Add(item);
        }

        public int Add(object value) => ((IList) _panel._gridLengths).Add(value);

        public void Clear()
        {
            _panel._gridLengths.Clear();
        }

        public bool Contains(GridLength item) => _panel._gridLengths.Contains(item);

        public bool Contains(object value) => ((IList) _panel._gridLengths).Contains(value);

        public void CopyTo(GridLength[] array, int arrayIndex) => _panel._gridLengths.CopyTo(array, arrayIndex);

        public void CopyTo(Array array, int index)
        {
            ((IList) _panel._gridLengths).CopyTo(array, index);
        }

        public IEnumerator<GridLength> GetEnumerator() => _panel._gridLengths.GetEnumerator();

        public int IndexOf(GridLength item) => _panel._gridLengths.IndexOf(item);

        public int IndexOf(object value) => ((IList) _panel._gridLengths).IndexOf(value);

        public void Insert(int index, GridLength item)
        {
            _panel._gridLengths.Insert(index, item);
        }

        public void Insert(int index, object value)
        {
            ((IList) _panel._gridLengths).Insert(index, value);
        }

        public bool Remove(GridLength item) => _panel._gridLengths.Remove(item);

        public void Remove(object value)
        {
            ((IList) _panel._gridLengths).Remove(value);
        }

        public void RemoveAt(int index)
        {
            _panel._gridLengths.RemoveAt(index);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable) _panel._gridLengths).GetEnumerator();
        }
    }
}