// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
/*++                                                                    
    Description:
       Abstract class that provides a common base class for all semantic containers            
--*/
 
namespace System.Windows.Documents
{
    internal abstract class FixedSOMContainer :FixedSOMSemanticBox, IComparable
    {
        //--------------------------------------------------------------------
        //
        // Constructors
        //
        //---------------------------------------------------------------------
        
        #region Constructors
        protected FixedSOMContainer()
        {
            _semanticBoxes = new List<FixedSOMSemanticBox>();
        }
        #endregion Constructors        
 
        int IComparable.CompareTo(object comparedObj)
        {
            int result = Int32.MinValue;
 
            FixedSOMPageElement compared = comparedObj as FixedSOMPageElement;
            FixedSOMPageElement This = this as FixedSOMPageElement;
            
            Debug.Assert(compared != null);
            Debug.Assert(This != null);
            if (compared == null)
            {
                throw new ArgumentException(SR.Format(SR.UnexpectedParameterType, comparedObj.GetType(), typeof(FixedSOMContainer)), nameof(comparedObj));
            }
            SpatialComparison compareHor = base._CompareHorizontal(compared, false);
            SpatialComparison compareVer = base._CompareVertical(compared);
 
            Debug.Assert(compareHor != SpatialComparison.None);
            Debug.Assert(compareVer != SpatialComparison.None);
 
            switch (compareHor)
            {
            case SpatialComparison.Before:
                if (compareVer != SpatialComparison.After)
                {
                    result = -1;
                }
                break;
 
            case SpatialComparison.After:
                if (compareVer != SpatialComparison.Before)
                {
                    result = 1;
                }
                break;
 
            case SpatialComparison.OverlapBefore:
                if (compareVer == SpatialComparison.Before)
                {
                    result =  -1;
                }
                else if (compareVer == SpatialComparison.After)
                {
                    result = 1;
                }
                break;
 
            case SpatialComparison.OverlapAfter:
                if (compareVer == SpatialComparison.After)
                {
                    result = 1;
                }
                else if (compareVer == SpatialComparison.Before)
                {
                    result = -1;
                }
                break;
 
            case SpatialComparison.Equal:
                switch (compareVer)
                {
                case SpatialComparison.After:
                case SpatialComparison.OverlapAfter:
                    result = 1;
                    break;
                case SpatialComparison.Before:
                case SpatialComparison.OverlapBefore:
                    result = -1;
                    break;
                case SpatialComparison.Equal:
                    result = 0;
                    break;
                default:
                    Debug.Assert(false);
                    break;
                }
                break;
 
            default:
                //Shouldn't happen
                Debug.Assert(false);
                break;
            }
 
            if (result == Int32.MinValue)
            {
                //Indecisive. Does markup order help?
 
                if (This.FixedNodes.Count == 0 || compared.FixedNodes.Count == 0)
                {
                    result = 0;
                }
                else
                {
                    FixedNode thisObjFirstNode = This.FixedNodes[0];
                    FixedNode thisObjLastNode = This.FixedNodes[This.FixedNodes.Count - 1];
 
                    FixedNode otherObjFirstNode = compared.FixedNodes[0];
                    FixedNode otherObjLastNode = compared.FixedNodes[compared.FixedNodes.Count - 1];
 
                    if (This.FixedSOMPage.MarkupOrder.IndexOf(otherObjFirstNode) - This.FixedSOMPage.MarkupOrder.IndexOf(thisObjLastNode) == 1)
                    {
                        result = -1;
                    }
                    else if (This.FixedSOMPage.MarkupOrder.IndexOf(otherObjLastNode) - This.FixedSOMPage.MarkupOrder.IndexOf(thisObjFirstNode) == 1)
                    {
                        result =  1;
                    }
                    else
                    {
                        //Indecisive. Whichever is below comes after; if same whichever is on the right comes after
                        int absVerComparison = _SpatialToAbsoluteComparison(compareVer);
                        result = absVerComparison != 0 ? absVerComparison : _SpatialToAbsoluteComparison(compareHor);
                    }
                }
            }
                
            return result;
        }
        #region Protected Methods
 
        protected void AddSorted(FixedSOMSemanticBox box)
        {
            int i=_semanticBoxes.Count-1;
            for (; i>=0; i--)
            {
                if (box.CompareTo(_semanticBoxes[i]) == 1)
                {
                    break;
                }
            }
            _semanticBoxes.Insert(i+1, box);
 
            _UpdateBoundingRect(box.BoundingRect);
        }
 
        protected void Add(FixedSOMSemanticBox box)
        {
            _semanticBoxes.Add(box);
            _UpdateBoundingRect(box.BoundingRect);
        }
        #endregion
 
        #region public Properties
 
        internal virtual FixedElement.ElementType[] ElementTypes
        {
            get
            {
                return Array.Empty<FixedElement.ElementType>();
            }
        }
 
        public List<FixedSOMSemanticBox> SemanticBoxes
        {
            get
            {
                return _semanticBoxes;
            }
            set
            {
                _semanticBoxes = value;
            }
        }
 
        public List<FixedNode> FixedNodes
        {
            get
            {
                if (_fixedNodes == null)
                {
                    _ConstructFixedNodes();
                }
                return _fixedNodes;
            }
        }
 
        #endregion
 
        #region Private methods
 
        private void _ConstructFixedNodes()
        {
            _fixedNodes = new List<FixedNode>();
            foreach (FixedSOMSemanticBox box in _semanticBoxes)
            {
                FixedSOMElement element = box as FixedSOMElement;
                if (element != null)
                {
                    _fixedNodes.Add(element.FixedNode);
                }
                else
                {
                    FixedSOMContainer container = box as FixedSOMContainer;
                    Debug.Assert(container != null);
                    List<FixedNode> nodes = container.FixedNodes;
                    foreach (FixedNode node in nodes)
                    {
                        _fixedNodes.Add(node);
                    }
                }
            }
        }
 
        private void _UpdateBoundingRect(Rect rect)
        {
            if (_boundingRect.IsEmpty)
            {
                _boundingRect = rect;
            }
            else
            {
                _boundingRect.Union(rect);
            }
        }
 
 
        #endregion Private methods
 
        //--------------------------------------------------------------------
        //
        // Protected Fields
        //
        //---------------------------------------------------------------------
 
        #region Protected Fields
        protected List<FixedSOMSemanticBox> _semanticBoxes;
        protected List<FixedNode> _fixedNodes;
        #endregion Protected Fields
        
    }
}