using WebWindowComplex.Json;
using static WebWindowComplex.Json.WindowConst;

namespace WebWindowComplex.Models
{
    public class SplitDimension:AreaDimension
    {
        #region Public Constructors

        public SplitDimension(double dDimension, MeasureTypes MeasureType, bool bIsRelative, Split Parent, bool IsVertList):base(dDimension, MeasureType, Parent)
        {
            m_dDimension = dDimension;
            m_bIsRelative = bIsRelative;
            m_Parent = Parent;
            m_bIsVertListDim = IsVertList;
        }

        #endregion Public Constructors

        #region Public Properties

        public bool bIsRelative
        {
            get
            {
                return m_bIsRelative;
            }
        }

        public bool bIsVertListDim
        {
            get
            {
                return m_bIsVertListDim;
            }
        }

        public override double dDimension
        {
            get
            {
                return m_dDimension;
            }
            set
            {
                double dimensionTot = 0;
                List<SplitDimension> dimensions = new List<SplitDimension>();
                Frame frame = m_Parent.ParentWindow.AreaList.FirstOrDefault() ?? new Frame(null, Parent.ParentWindow);
                int subAreaVert = -1;
                int subAreaHoriz = -1;
                if (m_Parent.ElemDimVertList.Count > 0)
                    subAreaVert = m_Parent.ElemDimVertList.Min(x => x.nSubArea);
                if (m_Parent.ElemDimHorizList.Count > 0)
                    subAreaHoriz = m_Parent.ElemDimHorizList.Min(x => x.nSubArea);
                //double width = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                double width = Parent.CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                foreach (var item in m_Parent.ElemDimVertList.Where(x=>x.nSubArea == subAreaVert))
                {
                    width = width - item.dDimension;
                }
                double height = (Parent.CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
                //double height = (CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
                foreach (var item in m_Parent.ElemDimHorizList.Where(x => x.nSubArea == subAreaHoriz))
                {
                    height = height - item.dDimension;
                }
                if (bIsVertListDim)
                {
                    dimensions = m_Parent.SplitVertList;
                    dimensionTot = width;
                }
                else
                {
                    dimensions = m_Parent.SplitHorizList;
                    dimensionTot = height;
                    
                }
                double valMinAbsolute = 100;
                double valMaxAbsolute = dimensionTot - valMinAbsolute * (dimensions.Count - 1);
                bool valueAccept = false;
                switch (MeasureType)
                {
                    case MeasureTypes.ABSOLUTE:
                        {
                            valueAccept = (value < valMaxAbsolute && value > valMinAbsolute) ? true : false;
                            break;
                        }
                    case MeasureTypes.PROPORTIONAL:
                        {
                            valMaxAbsolute = 20;
                            valueAccept = (value >= 1) ? true : false;
                            break;
                        }
                    case MeasureTypes.PERCENTAGE:
                        {
                            valMaxAbsolute = valMaxAbsolute / dimensionTot * 100;
                            valMinAbsolute = valMinAbsolute / dimensionTot * 100;
                            valueAccept = (value < valMaxAbsolute && value > valMinAbsolute) ? true : false;
                            break;
                        }
                }
                if (valueAccept)
                {
                    List<double> absoluteValList = new List<double>();
                    AreaDimension ad = new AreaDimension(dDimension, SelMeasureType, Parent);
                    List<AreaDimension> adList = new List<AreaDimension>();
                    foreach (var it in dimensions)
                    {
                        adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
                    }
                    foreach (var item in dimensions)
                    {
                        absoluteValList.Add(item.CalculateAbsoluteValue(adList, dimensionTot));
                    }
                    int nIndex = dimensions.IndexOf(this);
                    int proportionalCount = dimensions.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).ToList().Count;
                    int percentageCount = dimensions.Where(x => x.MeasureType.Equals(MeasureTypes.PERCENTAGE)).ToList().Count;
                    // Le dimensioni sono solo in proporzionale
                    if (proportionalCount == absoluteValList.Count)
                    {
                        m_dDimension = value;
                    }
                    // Le dimensioni sono solo in percentuale
                    else if (percentageCount == dimensions.Count)
                    {
                        if (value < dDimension)
                        {
                            // L'anta modificata non è l'ultima
                            if (nIndex < dimensions.Count - 1)
                                dimensions[nIndex + 1].SetDimension(dimensions[nIndex + 1].dDimension + (m_dDimension - value));
                            else if (dimensions.Count > 1)
                                dimensions[nIndex - 1].SetDimension(dimensions[nIndex - 1].dDimension + (m_dDimension - value));
                            else
                            {
                                m_dDimension = 100;
                                return;
                            }
                        }
                        else
                        {
                            double dRes = value;
                            // se non ultima anta
                            if (nIndex < dimensions.Count - 1)
                            {
                                for (var nInd = 0; nInd <= nIndex - 1; nInd++)
                                    dRes += dimensions[nInd].dDimension;
                                dRes = (100 - dRes) / (dimensions.Count - nIndex - 1);
                                for (var Ind = nIndex + 1; Ind <= dimensions.Count - 1; Ind++)
                                    dimensions[Ind].SetDimension(dRes);
                            }
                            // se ultima anta
                            else if (dimensions.Count > 1)
                            {
                                if (dimensions.Count > 2)
                                {
                                    for (var Ind = 0; Ind <= nIndex - 2; Ind++)
                                        dRes += dimensions[Ind].dDimension;
                                }
                                dRes = (100 - dRes);
                                dimensions[nIndex - 1].SetDimension(dRes);
                            }
                            else
                            {
                                m_dDimension = 100;
                                return;
                            }
                        }
                        m_dDimension = value;
                    }
                    // Le dimensioni sono miste o solo in assoluto
                    else
                    {
                        double valueInAbsolute = 0;
                        switch (MeasureType)
                        {
                            case MeasureTypes.ABSOLUTE:
                                {
                                    valueInAbsolute = value;
                                    break;
                                }
                            case MeasureTypes.PROPORTIONAL:
                                {
                                    var pesi = value + dimensions
                                                                .Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL) && !x.Equals(this))
                                                                .Sum(x => x.m_dDimension);
                                    valueInAbsolute = dimensionTot / pesi * value;
                                    break;
                                }
                            case MeasureTypes.PERCENTAGE:
                                {
                                    valueInAbsolute = (value / 100) * dimensionTot;
                                    break;
                                }
                        }
                        if (value < dDimension)
                        {
                            // L'anta modificata non è l'ultima
                            if (nIndex < absoluteValList.Count - 1)
                            {
                                absoluteValList[nIndex + 1] = absoluteValList[nIndex + 1] + (absoluteValList[nIndex] - valueInAbsolute);
                                absoluteValList[nIndex] = valueInAbsolute;
                            }
                            // L'anta modificata è l'ultima
                            else if (dimensions.Count > 1)
                            {
                                absoluteValList[nIndex - 1] = absoluteValList[nIndex - 1] + (absoluteValList[nIndex] - valueInAbsolute);
                                absoluteValList[nIndex] = valueInAbsolute;
                            }
                        }
                        else
                        {
                            // L'anta modificata non è l'ultima
                            if (nIndex < absoluteValList.Count - 1)
                            {
                                absoluteValList[nIndex + 1] = absoluteValList[nIndex + 1] - (valueInAbsolute - absoluteValList[nIndex]);
                                absoluteValList[nIndex] = valueInAbsolute;
                            }
                            // L'anta modificata è l'ultima
                            else if (dimensions.Count > 1)
                            {
                                absoluteValList[nIndex - 1] = absoluteValList[nIndex - 1] - (valueInAbsolute - absoluteValList[nIndex]);
                                absoluteValList[nIndex] = valueInAbsolute;
                            }
                        }
                        if (MeasureType.Equals(MeasureTypes.PROPORTIONAL))
                            m_dDimension = value;
                        for (int i = 0; i < absoluteValList.Count; i++)
                        {
                            var item = dimensions.ElementAt(i);
                            item.SetDimension(ad.ConvertAbsoluteIn(adList, absoluteValList[i], (MeasureTypes)item.SelMeasureTypeIndex, dimensionTot));
                        }
                    }
                    for (int i = 0; i < m_Parent.AreaList.Count; i++)
                    {
                        if (m_Parent.SplitHorizList.Count > 0 && i < m_Parent.SplitHorizList.Count)
                        {
                            List<AreaDimension> dimList = new List<AreaDimension>();
                            foreach (var itemDim in m_Parent.SplitHorizList)
                                dimList.Add(new AreaDimension(itemDim.dDimension, itemDim.MeasureType, itemDim.Parent));
                            SplitDimension currSplitDim = m_Parent.SplitHorizList[i];
                            double dim = currSplitDim.dDimension;
                            if (!(currSplitDim.MeasureType.Equals(MeasureTypes.ABSOLUTE)))
                                dim = currSplitDim.ConvertDimension(dimList, currSplitDim.MeasureType, MeasureTypes.ABSOLUTE, height, -1);
                            m_Parent.AreaList.ElementAt(i).SearchAreaList(m_Parent.AreaList.ElementAt(i), dim, "Height");
                        }
                        if (m_Parent.SplitVertList.Count > 0 && i < m_Parent.SplitVertList.Count)
                        {
                            List<AreaDimension> dimList = new List<AreaDimension>();
                            foreach (var itemDim in m_Parent.SplitVertList)
                                dimList.Add(new AreaDimension(itemDim.dDimension, itemDim.MeasureType, itemDim.Parent));
                            SplitDimension currSplitDim = m_Parent.SplitVertList[i];
                            double dim = currSplitDim.dDimension;
                            if (!(currSplitDim.MeasureType.Equals(MeasureTypes.ABSOLUTE)))
                                dim = currSplitDim.ConvertDimension(dimList, currSplitDim.MeasureType, MeasureTypes.ABSOLUTE, width, -1);
                            m_Parent.AreaList.ElementAt(i).SearchAreaList(m_Parent.AreaList.ElementAt(i), dim, "Width");
                        }
                    }
                }
            }
        }

        public Split Parent
        {
            get
            {
                return m_Parent;
            }
            set
            {
                m_Parent = value;
            }
        }
        
        public override int SelMeasureTypeIndex
        {
            get
            {
                return (int)m_SelMeasureType;
            }
            set
            {
                if (m_SelMeasureType != (MeasureTypes)value)
                {
                    MeasureTypes newType = (MeasureTypes)value;
                    List<SplitDimension> splitList = new List<SplitDimension>();
                    List<SplitElementDimension> splitElemList = new List<SplitElementDimension>();
                    if(m_Parent.ParentWindow.AreaList.FirstOrDefault() != null)
                    {
                        Frame frame = m_Parent.ParentWindow.AreaList.FirstOrDefault()!;
                        double dimSplitGroup = 0;
                        if (bIsVertListDim)
                        {
                            splitList = m_Parent.SplitVertList;
                            if (Parent.bSplitStartVert)
                                splitElemList = m_Parent.ElemDimVertList;
                            else
                                splitElemList = m_Parent.ElemDimVertList.Where(x => x.nSubArea == 1).ToList();
                            //dimSplitGroup = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                            dimSplitGroup = Parent.CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                        }
                        else 
                        { 
                            splitList = m_Parent.SplitHorizList;
                            if (Parent.bSplitStartVert)
                                splitElemList = m_Parent.ElemDimHorizList.Where(x => x.nSubArea == 1).ToList();
                            else
                                splitElemList = m_Parent.ElemDimHorizList;
                            dimSplitGroup = (Parent.CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
                            //dimSplitGroup = (CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
                        }
                        AreaDimension ad = new AreaDimension(dDimension, SelMeasureType, Parent);
                        List<AreaDimension> adList = new List<AreaDimension>();
                        foreach (var it in splitList)
                        {
                            adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
                        }
                        foreach (var item in splitElemList)
                        {
                            dimSplitGroup = dimSplitGroup - item.dDimension;
                        }
                        if (newType is MeasureTypes.PROPORTIONAL)
                        {
                            adList = ad.RicalculatePropVal(adList, splitList.IndexOf(this), dimSplitGroup);
                            for (int i = 0; i < adList.Count; i++)
                                splitList.ElementAt(i).SetDimension(adList.ElementAt(i).dDimension);
                        }
                        else
                            m_dDimension = ad.ConvertDimension(adList, m_SelMeasureType, newType, dimSplitGroup, splitList.IndexOf(this));
                        m_SelMeasureType = (MeasureTypes)value;
                    }
                }
            }
        }

        #endregion Public Properties

        #region Public Methods

        public SplitDimension Copy()
        {
            SplitDimension newSplitDim = new SplitDimension(dDimension, MeasureType, bIsRelative, m_Parent, bIsVertListDim);
            return newSplitDim;
        }

        #endregion Public Methods

        #region Internal Methods

        ///// <summary>
        ///// Metodo per calcolare larghezza intero split group
        ///// </summary>
        ///// <param name="area"> area di partenza </param>
        ///// <param name="width"> larghezza di partenza </param>
        ///// <param name="res"> area di ritorno </param>
        ///// <returns></returns>
        //internal AreaFound CalculateWidthSplitGroup(Area area, double width, AreaFound res)
        //{
        //    for (int i = 0; i < area.AreaList.Count; i++)
        //    {
        //        if (area.Equals(m_Parent))
        //        {
        //            res.m_Dimension = width;
        //            res.m_Found = true;
        //            return res;
        //        }
        //        Area item = area.AreaList[i];
        //        if (area is Split split)
        //        {
        //            if(split.SplitVertList.Count > 0)
        //            {
        //                int index = i;
        //                double dim = width;
        //                foreach (var elem in split.ElemDimVertList)
        //                    dim = dim - elem.dDimension;
        //                if (split.SelSplitShape is SplitShapes.GRID)
        //                    index = i % split.SplitHorizList.Count;
        //                switch (split.SplitVertList.ElementAt(index).SelMeasureType)
        //                {
        //                    case MeasureTypes.ABSOLUTE:
        //                        {
        //                            res = CalculateWidthSplitGroup(item, split.SplitVertList.ElementAt(index).dDimension, res);
        //                            break;
        //                        }
        //                    case MeasureTypes.PROPORTIONAL:
        //                        {
        //                            AreaDimension ad = new AreaDimension(split.SplitVertList.ElementAt(index).dDimension, split.SplitVertList.ElementAt(index).SelMeasureType, split.SplitVertList.ElementAt(index).Parent);
        //                            List<AreaDimension> adList = new List<AreaDimension>();
        //                            foreach (var it in split.SplitVertList)
        //                            {
        //                                adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
        //                            }
        //                            res = CalculateWidthSplitGroup(item, ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, dim), res);
        //                            break;
        //                        }
        //                    case MeasureTypes.PERCENTAGE:
        //                        {
        //                            res = CalculateWidthSplitGroup(item, split.SplitVertList.ElementAt(index).dDimension * dim / 100, res);
        //                            break;
        //                        }
        //                }
        //                if (res.m_Dimension != -1 && res.m_Found)
        //                    return res;
        //            }
        //            else
        //            {
        //                res = CalculateWidthSplitGroup(item, width, res);
        //                if (res.m_Dimension != -1 && res.m_Found)
        //                    return res;
        //            }
        //        }
        //        else if (area is Sash sash)
        //        {
        //            double widthTot = width;
        //            double dim = 0;
        //            if (sash.ParentArea.ParentArea is Split)
        //                widthTot = widthTot + sash.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dOverlap
        //                                    + sash.SashList.ElementAt(i).ElementDimensionList.Last().dOverlap;
        //            if (sash.bIsDimensionLight)
        //            {
        //                widthTot = widthTot - sash.SashList.First().ElementDimensionList.ElementAt(1).dDimension
        //                                    - sash.SashList.First().ElementDimensionList.Last().dDimension;
        //                for (int anta = 1; anta < sash.SashList.Count; anta++)
        //                {
        //                    widthTot = widthTot - sash.SashList.ElementAt(anta).ElementDimensionList.ElementAt(1).dDimension
        //                                            - sash.SashList.ElementAt(anta).ElementDimensionList.Last().dDimension
        //                                            + sash.SashList.ElementAt(anta).ElementDimensionList.Last().dOverlap;
        //                }
        //            }
        //            else
        //            {
        //                for (int anta = 1; anta < sash.SashList.Count; anta++)
        //                {
        //                    widthTot = widthTot + sash.SashList.ElementAt(anta).ElementDimensionList.Last().dOverlap;
        //                }
        //            }
        //            switch (sash.SashList.ElementAt(i).SelMeasureType)
        //            {
        //                case MeasureTypes.ABSOLUTE:
        //                    {
        //                        dim = sash.SashList.ElementAt(i).dDimension;
        //                        break;
        //                    }
        //                case MeasureTypes.PROPORTIONAL:
        //                    {
        //                        AreaDimension ad = new AreaDimension(sash.SashList.ElementAt(i).dDimension, sash.SashList.ElementAt(i).SelMeasureType, sash.SashList.ElementAt(i).Parent);
        //                        List<AreaDimension> adList = new List<AreaDimension>();
        //                        foreach (var it in sash.SashList)
        //                            adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
        //                        dim = ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, widthTot);
        //                        break;
        //                    }
        //                case MeasureTypes.PERCENTAGE:
        //                    {
        //                        dim = sash.SashList.ElementAt(i).dDimension * widthTot / 100;
        //                        break;
        //                    }
        //            }
        //            if (!sash.bIsDimensionLight)
        //                dim = dim - sash.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
        //                          - sash.SashList.ElementAt(i).ElementDimensionList.Last().dDimension;
        //            res = CalculateWidthSplitGroup(item, dim, res);
        //            if (res.m_Dimension != -1 && res.m_Found)
        //                return res;
        //        }
        //        else
        //        {
        //            res = CalculateWidthSplitGroup(item, width, res);
        //            if (res.m_Dimension != -1 && res.m_Found)
        //                return res;
        //        }
        //    }
        //    return res;
        //}

        ///// <summary>
        ///// Metodo per calcolare altezza intero split group
        ///// </summary>
        ///// <param name="area"> area di partenza </param>
        ///// <param name="height"> altezza di partenza </param>
        ///// <param name="res"> area di ritorno </param>
        ///// <returns></returns>
        //internal AreaFound CalculateHeightSplitGroup(Area area, double height, AreaFound res)
        //{
        //    for (int i = 0; i < area.AreaList.Count; i++)
        //    {
        //        if (area.Equals(m_Parent))
        //        {
        //            res.m_Dimension = height;
        //            res.m_Found = true;
        //            return res;
        //        }
        //        Area item = area.AreaList[i];
        //        if (area is Split split)
        //        {
        //            if (split.SplitHorizList.Count > 0)
        //            {
        //                double dim = height;
        //                foreach (var elem in split.ElemDimHorizList)
        //                    dim = dim - elem.dDimension;
        //                int index = i;
        //                if (split.SelSplitShape is SplitShapes.GRID)
        //                    index = i % split.SplitHorizList.Count;
        //                switch (split.SplitHorizList.ElementAt(index).SelMeasureType)
        //                {
        //                    case MeasureTypes.ABSOLUTE:
        //                        {
        //                            dim = split.SplitHorizList.ElementAt(index).dDimension;
        //                            break;
        //                        }
        //                    case MeasureTypes.PROPORTIONAL:
        //                        {
        //                            AreaDimension ad = new AreaDimension(split.SplitHorizList.ElementAt(index).dDimension, split.SplitHorizList.ElementAt(index).SelMeasureType, split.SplitHorizList.ElementAt(index).Parent);
        //                            List<AreaDimension> adList = new List<AreaDimension>();
        //                            foreach (var it in split.SplitHorizList)
        //                                adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
        //                            dim = ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, dim);
        //                            break;
        //                        }
        //                    case MeasureTypes.PERCENTAGE:
        //                        {
        //                            dim = split.SplitHorizList.ElementAt(index).dDimension * dim / 100;
        //                            break;
        //                        }
        //                }
        //                res = CalculateHeightSplitGroup(item, dim, res);
        //                if (res.m_Dimension != -1 && res.m_Found)
        //                    return res;
        //            }
        //            else
        //            {
        //                double dim = height;
        //                res = CalculateHeightSplitGroup(item, dim, res);
        //                if (res.m_Dimension != -1 && res.m_Found)
        //                    return res;
        //            }
        //        }
        //        else if (area is Sash sash)
        //        {
        //            double bottomRail = 0;
        //            if(sash.SashBottomRailQty > 0)
        //            {
        //                foreach (var bottom in sash.BottomRailElemDimList)
        //                    bottomRail = bottomRail + bottom.dDimension
        //                                            - bottom.dOverlap;
        //            }
        //            double dim = height - sash.SashList.First().ElementDimensionList.First().dDimension
        //                                - sash.SashList.First().ElementDimensionList.ElementAt(sash.SashList.First().ElementDimensionList.Count - 2).dDimension
        //                                - bottomRail;   
        //            res = CalculateHeightSplitGroup(item, dim, res);
        //            if (res.m_Dimension != -1 && res.m_Found)
        //                return res;
        //        }
        //        else if (area is Splitted splitted)
        //        {
        //            double dim = height;
        //            if (splitted.ParentArea is Split sp && splitted.AreaList.First() is Sash sh)
        //            {
        //                if (sp.SplitHorizList.Count > 0)
        //                {
        //                    dim = dim + sh.SashList.First().ElementDimensionList.First().dOverlap
        //                              + sh.SashList.First().ElementDimensionList.ElementAt(sh.SashList.First().ElementDimensionList.Count - 2).dOverlap;
        //                }
        //            }
        //            res = CalculateHeightSplitGroup(item, dim, res);
        //            if (res.m_Dimension != -1 && res.m_Found)
        //                return res;
        //        }
        //        else
        //        {
        //            res = CalculateHeightSplitGroup(item, height, res);
        //            if (res.m_Dimension != -1 && res.m_Found)
        //                return res;
        //        }
        //    }
        //    return res;
        //}

        internal JsonSplitDimension Serialize()
        {
            JsonSplitDimension JsonSplitDimension = new JsonSplitDimension(m_bIsRelative, m_dDimension, MeasureType);
            return JsonSplitDimension;
        }

        internal void SetIsRelative(bool value)
        {
            m_bIsRelative = value;
        }

        internal void SetIsVertListDim(bool value)
        {
            m_bIsVertListDim = value;
        }

        internal void SetMeasureType(MeasureTypes value)
        {
            m_SelMeasureType = value;
        }

        internal void SetSelMeasureType(MeasureTypes value)
        {
            if (m_SelMeasureType != (MeasureTypes)value)
            {
                MeasureTypes newType = (MeasureTypes)value;
                List<SplitDimension> splitList = new List<SplitDimension>();
                List<SplitElementDimension> splitElemList = new List<SplitElementDimension>();
                if (m_Parent.ParentWindow.AreaList.FirstOrDefault() != null)
                {
                    Frame frame = m_Parent.ParentWindow.AreaList.FirstOrDefault()!;
                    double dimSplitGroup = 0;
                    if (bIsVertListDim)
                    {
                        splitList = m_Parent.SplitVertList;
                        if (Parent.bSplitStartVert)
                            splitElemList = m_Parent.ElemDimVertList;
                        else
                            splitElemList = m_Parent.ElemDimVertList.Where(x => x.nSubArea == 1).ToList();
                        //dimSplitGroup = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                        dimSplitGroup = Parent.CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                    }
                    else
                    {
                        splitList = m_Parent.SplitHorizList;
                        if (Parent.bSplitStartVert)
                            splitElemList = m_Parent.ElemDimHorizList.Where(x => x.nSubArea == 1).ToList();
                        else
                            splitElemList = m_Parent.ElemDimHorizList;
                        //dimSplitGroup = (CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
                        dimSplitGroup = (Parent.CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
                    }
                    AreaDimension ad = new AreaDimension(dDimension, SelMeasureType, Parent);
                    List<AreaDimension> adList = new List<AreaDimension>();
                    foreach (var it in splitList)
                    {
                        adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
                    }
                    foreach (var item in splitElemList)
                    {
                        dimSplitGroup = dimSplitGroup - item.dDimension;
                    }
                    if (newType is MeasureTypes.PROPORTIONAL)
                    {
                        adList = ad.RicalculatePropVal(adList, splitList.IndexOf(this), dimSplitGroup);
                        for (int i = 0; i < adList.Count; i++)
                            splitList.ElementAt(i).SetDimension(adList.ElementAt(i).dDimension);
                    }
                    else
                        m_dDimension = ad.ConvertDimension(adList, m_SelMeasureType, newType, dimSplitGroup, splitList.IndexOf(this));
                    m_SelMeasureType = (MeasureTypes)value;
                }
            }
        }

        #endregion Internal Methods

        #region Private Fields

        private bool m_bIsRelative = false;

        private bool m_bIsVertListDim = false;

        // reference
        private Split m_Parent;

        #endregion Private Fields
    }

    public class AreaFound
    {
        public AreaFound(double dimension, bool found)
        {
            m_Dimension = dimension;
            m_Found = found;
        }

        public double m_Dimension { get; set; } = -1;
        public bool m_Found { get; set; } = false;
    }
}