using System.ComponentModel.Design;
using WebWindowTest.Json;
using static WebWindowTest.Json.WindowConst;

namespace WebWindowTest.Models
{
    public abstract class Area
    {
        #region Public Constructors

        public Area(Area ParentArea, Window ParentWindow)
        {
            m_ParentWindow = ParentWindow;
            m_ParentArea = ParentArea;
        }

        #endregion Public Constructors

        #region Public Properties

        public static int nCounterGroup
        {
            get => m_CounterGroup;
            set => m_CounterGroup = value;
        }

        public List<Area> AreaList
        {
            get
            {
                return m_AreaList;
            }
            set
            {
                m_AreaList = value;
            }
        }

        public AreaTypes AreaType
        {
            get
            {
                return m_AreaType;
            }
            set
            {
                m_AreaType = value;
            }
        }

        public int GroupId
        {
            get
            {
                return m_GroupId;
            }

            set
            {
                m_GroupId = value;
            }
        }

        public int nAreaId
        {
            get
            {
                return m_nAreaId;
            }
            set
            {
                m_nAreaId = value;
            }
        }

        public Area ParentArea
        {
            get
            {
                return m_ParentArea;
            }
        }

        public Window ParentWindow
        {
            get
            {
                return m_ParentWindow;
            }
        }

        #endregion Public Properties

        #region Public Methods

        public static void AddCounterGroup()
        {
            m_CounterGroup++;
        }

        public void AddFirstSash()
        {
            // Salvo il parent
            Area ParentArea = AreaList[0].ParentArea;
            // Creo area sash di default
            Sash SashArea = Sash.CreateSash(ParentArea);
            // Inserisco famiglia hardware vuota
            SashArea.SetSelFamilyHardware("");
            // Inserisco hardware di default
            SashArea.SetSelHardwareFromId("000000");
            //if (ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.ARC ||
            //   ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.DOUBLEARC ||
            //   ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.ARC_FULL ||
            //   ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.THREECENTERARC)
            //    SashArea.SashArcElem = new SashArcElement(SashArea, ParentWindow, 10, true);
            //else
            //    SashArea.SashArcElem = null;
            // Salvo gli oggetti già presenti e li cancello da AreaList
            List <Area> ContentArea = new List<Area>();
            ContentArea.Add(AreaList[0]);
            AreaList.Remove(AreaList[0]);
            // Aggiungo area
            AreaList.Add(SashArea);
            // Inserisco il riempimento precedente
            AreaList[0].AreaList.Add(ContentArea[0]);
            AreaList[0].AreaList[0].SetParentArea(AreaList[0]);
        }

        public void AddSplit()
        {
            // Salvo il parent
            Area ParentArea = AreaList[0].ParentArea;
            List<Area> ContentArea = new List<Area>();
            // Salvo gli oggetti già presenti e li cancello da AreaList
            ContentArea.Add(AreaList[0]);
            AreaList.Remove(AreaList[0]);
            // Aggiungo Area split di default
            Split SplitArea = Split.CreateSplit(this, SplitShapes.HORIZONTAL);
            // imposto i parametri di default
            SplitArea.SetSplitQtyHoriz(1);
            SplitArea.SetSplitStartVert(false);
            // Aggiungo area
            AreaList.Add(SplitArea);
            // Creo le due aree Splitted
            List<Splitted> newSplittedList = new List<Splitted>();
            for (int i = 0; i < 2; i++)
                newSplittedList.Add(Splitted.CreateSplitted(SplitArea));
            // Inserisco nelle aree Splitted Fill e la struttura precedente (e setto ParentArea del fill)
            ContentArea[0].SetParentArea(newSplittedList[1]);
            newSplittedList[1].AreaList.Add(ContentArea[0]);
            if (ContentArea[0] is Fill)
            {
                Fill fill1 = (Fill)ContentArea[0];
                Fill fill2 = Fill.CreateFill(newSplittedList[0], fill1.FillType);
                newSplittedList[0].AreaList.Add(fill2);
            }
            else
            {
                Fill fill2 = Fill.CreateFill(newSplittedList[0], FillTypes.GLASS);
                newSplittedList[0].AreaList.Add(fill2);
            }
            // All'area Split aggiunto le due aree Splitted
            for (int i = 0; i < 2; i++)
                AreaList[0].AreaList.Add(newSplittedList[i]);
        }

        public abstract Area Copy(Area ParentArea);

        public void SetGroupId(int nGroupId)
        {
            m_GroupId = nGroupId;
        }

        public void SwapAree()
        {
            Area tempArea;
            if (this is Sash || this is Split)
            {
                tempArea = AreaList[0];
                AreaList[0] = AreaList[1];
                AreaList[1] = tempArea;
            }
            Frame frame = ParentWindow.AreaList.First();
            switch (frame.Shape)
            {
                case Shapes.RECTANGLE:
                case Shapes.ARC_FULL:
                case Shapes.TRIANGLE:
                    {
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Height")).First().dDimension, "Height");
                        break;
                    }

                case Shapes.RIGHTCHAMFER:
                    {
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Left Height")).First().dDimension, "Left Height");
                        break;
                    }

                case Shapes.LEFTCHAMFER:
                    {
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Right Height")).First().dDimension, "Right Height");
                        break;
                    }

                case Shapes.DOUBLECHAMFER:
                case Shapes.ARC:
                    {
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Full Height")).First().dDimension, "Full Height");
                        break;
                    }

                case Shapes.DOUBLEARC:
                    {
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Full Height")).First().dDimension, "Full Height");
                        break;
                    }

                case Shapes.THREECENTERARC:
                    {
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
                        SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Full Height")).First().dDimension, "Full Height");
                        break;
                    }
            }
        }

        /// <summary>
        /// Cerca nell'albero gli oggetti Sash e Split per associare la larghezza
        /// </summary>
        /// <param name="node"></param>
        public void SearchAreaList(Area node, double dim, string nameDim)
        {
            if (node != null)
            {
                if (node.AreaType.Equals(AreaTypes.SASH))
                    UpdateDimSubArea((Sash)node, dim, nameDim);
                else if (node.AreaType.Equals(AreaTypes.SPLIT))
                    UpdateDimSubArea((Split)node, dim, nameDim);
                for (int i = 0; i < node.AreaList.Count; i++)
                {
                    if (node.AreaType.Equals(AreaTypes.SASH))
                    {
                        Sash s = (Sash)node;
                        List<AreaDimension> dimList = new List<AreaDimension>();
                        foreach (var item in s.SashList)
                            dimList.Add(new AreaDimension(item.dDimension, item.MeasureType));
                        if(nameDim.Equals("Width"))
                            SearchAreaList(node.AreaList.ElementAt(i), s.SashList.ElementAt(i).CalculateAbsoluteValue(dimList, dim), nameDim);
                        else
                            SearchAreaList(node.AreaList.ElementAt(i), dim, nameDim);
                    }
                    else if (node.AreaType.Equals(AreaTypes.SPLIT))
                    {
                        Split s = (Split)node;
                        List<AreaDimension> dimList = new List<AreaDimension>();
                        if (s.SplitHorizList.Count > 0 && i < s.SplitHorizList.Count)
                        {
                            foreach (var item in s.SplitHorizList)
                                dimList.Add(new AreaDimension(item.dDimension, item.MeasureType));
                            if(nameDim.Equals("Width"))
                                SearchAreaList(node.AreaList.ElementAt(i), dim, nameDim);
                            else
                                SearchAreaList(node.AreaList.ElementAt(i), s.SplitHorizList.ElementAt(i).CalculateAbsoluteValue(dimList, dim), nameDim);
                        }
                        if (s.SplitVertList.Count > 0 && i < s.SplitVertList.Count)
                        {
                            foreach (var item in s.SplitVertList)
                                dimList.Add(new AreaDimension(item.dDimension, item.MeasureType));
                            if(nameDim.Equals("Width"))
                                SearchAreaList(node.AreaList.ElementAt(i), s.SplitVertList.ElementAt(i).CalculateAbsoluteValue(dimList, dim), nameDim);
                            else
                                SearchAreaList(node.AreaList.ElementAt(i), dim, nameDim);
                        }
                    }
                    else
                         SearchAreaList(node.AreaList.ElementAt(i), dim, nameDim);
                }
            }
        }

        public void UpdateDimSubArea(Area area, double dim, string nameDim)
        {
            if (area is Sash && nameDim.Equals("Width"))
            {
                Sash sash = (Sash)area;
                int countAbsolute = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.ABSOLUTE)).Count();
                int countProportional = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).Count();
                int countPercentage = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.PERCENTAGE)).Count();
                List<AreaDimension> dimList = new List<AreaDimension>();
                Split split = new Split(null, null);
                if (sash.ParentArea.ParentArea is Split)
                    split = (Split)sash.ParentArea.ParentArea;
                if (sash.ParentArea is Frame || (sash.ParentArea.ParentArea is Split && split.SplitHorizList.Count > 0))
                {
                    Frame frame = new Frame(null, null);
                    if(split.SplitHorizList.Count > 0)
                        frame = (Frame)sash.ParentArea.ParentArea.ParentArea;
                    else
                        frame = (Frame)sash.ParentArea;
                    foreach (var i in frame.DimensionList)
                        dimList.Add(new AreaDimension(i.dDimension, i.SelMeasureType));
                }
                else
                {
                    //Split s = (Split)sash.ParentArea.ParentArea;
                    foreach (var i in split.SplitVertList)
                        dimList.Add(new AreaDimension(i.dDimension, i.SelMeasureType));
                }   
                if (countAbsolute == sash.SashList.Count)
                {
                    double sum = sash.SashList.Sum(x => x.dDimension);
                    double res = dim - sum;
                    if (res > 0)
                    {
                        foreach (var sashDim in sash.SashList)
                        {
                            sashDim.SetDimension(sashDim.dDimension + res / countAbsolute);
                        }
                    }
                    else
                    {
                        foreach (var sashDim in sash.SashList)
                        {
                            // Sommo perchè res è negativo
                            sashDim.SetDimension(sashDim.dDimension + res / countAbsolute);
                        }
                    }
                }
                else if (countAbsolute < sash.SashList.Count && countPercentage != sash.SashList.Count && countProportional != sash.SashList.Count)
                {
                    if (countPercentage > 0 && countPercentage <= sash.SashList.Count && countProportional == 0)
                    {
                        double sumAbsolute = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.ABSOLUTE)).Sum(x => x.dDimension);
                        var percentageList = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.PERCENTAGE)).ToList();
                        foreach (var i in percentageList)
                        {
                            i.SetDimension(i.ConvertIn(dimList, (dim - sumAbsolute) / countPercentage, i.MeasureType, dim));
                        }
                    }
                }
            }
            else if (area is Split)
            {
                Split split = (Split)area;
                List<SplitDimension> splitList = new List<SplitDimension>();
                if (nameDim.Equals("Width"))
                    splitList = split.SplitVertList;
                else
                    splitList = split.SplitHorizList;
                int countAbsolute = splitList.Where(x => x.MeasureType.Equals(MeasureTypes.ABSOLUTE)).Count();
                if (countAbsolute != 0 && countAbsolute == splitList.Count)
                {
                    double sum = splitList.Sum(x => x.dDimension);
                    double res = 0;
                    res = dim - sum;
                    if (res > 0)
                    {
                        foreach (var item in splitList)
                        {
                            item.SetDimension(item.dDimension + res / countAbsolute);
                        }
                    }
                    else
                    {
                        foreach (var item in splitList)
                        {
                            // Sommo perchè res è negativo
                            item.SetDimension(item.dDimension + res / countAbsolute);
                        }
                    }
                }
            }
        }

        #endregion Public Methods

        #region Internal Methods

        internal abstract JsonArea Serialize(bool hideHw);

        internal void SetAreaType(AreaTypes AreaType)
        {
            m_AreaType = AreaType;
        }

        internal void SetParentArea(Area ParentArea)
        {
            m_ParentArea = ParentArea;
        }

        /// <summary>
        /// Metodo per convertire da misura proporzionale a misura assoluta o percentuale
        /// </summary>
        /// <param name="newType"></param>
        /// <returns></returns>
        internal double ConvertFromPropVal(Sash sashGroup, double sashDim, MeasureTypes newType, double widthTot)
        {
            double tot = widthTot;
            List<AreaDimension> adList = new List<AreaDimension>();
            foreach (var it in sashGroup.SashList)
            {
                adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType));
            }
            //Somma misura non proporzionali
            double sumNotProp = sashGroup.SashList
                                                .Where(m => m.MeasureType != MeasureTypes.PROPORTIONAL && !m.Equals(this))
                                                .Sum(m => m.CalculateAbsoluteValue(adList, tot));
            //Calcolo residuo 
            double res = tot - sumNotProp;
            if (res < 0) res = 0;
            //Misure proporzionali
            var proportionalList = sashGroup.SashList
                                                .Where(m => m.SelMeasureType == MeasureTypes.PROPORTIONAL)
                                                .ToList();

            double sumPesi = proportionalList.Sum(p => p.dDimension);
            if (sumPesi == 0) sumPesi = 1;
            if (newType.Equals(MeasureTypes.ABSOLUTE))
            {
                return res / sumPesi * sashDim;
            }
            else
            {
                return (res / sumPesi * sashDim) / tot * 100;
            }
        }

        /// <summary>
        /// Metodo per convertire da misura proporzionale a misura assoluta o percentuale
        /// </summary>
        /// <param name="newType"></param>
        /// <returns></returns>
        internal double ConvertFromPropVal(List<SplitDimension> splitList, double splitDim, MeasureTypes newType, double widthTot)
        {
            double tot = widthTot;
            List<AreaDimension> adList = new List<AreaDimension>();
            foreach (var it in splitList)
            {
                adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType));
            }
            //Somma misura non proporzionali
            double sumNotProp = splitList
                                        .Where(m => m.MeasureType != MeasureTypes.PROPORTIONAL && !m.Equals(this))
                                        .Sum(m => m.CalculateAbsoluteValue(adList, tot));
            //Calcolo residuo 
            double res = tot - sumNotProp;
            if (res < 0) res = 0;
            //Misure proporzionali
            var proportionalList = splitList
                                           .Where(m => m.SelMeasureType == MeasureTypes.PROPORTIONAL)
                                           .ToList();

            double sumPesi = proportionalList.Sum(p => p.dDimension);
            if (sumPesi == 0)
                sumPesi = 1;
            return res / sumPesi * splitDim;
        }

        /// <summary>
        /// Metodo per calcolare larghezza area
        /// </summary>
        /// <param name="area"> area di partenza </param>
        /// <param name="width"> larghezza di partenza </param>
        /// <returns></returns>
        public double CalculateWidthArea(Area area, double width)
        {
            for (int i = 0; i < area.AreaList.Count; i++)
            {
                double risultato = -1;
                if (area.Equals(this))
                    return width;
                Area item = area.AreaList[i];
                if (area is Split)
                {
                    Split split = (Split)area;
                    if (split.SplitVertList.Count > 0)
                    {
                        switch (split.SplitVertList.ElementAt(i).SelMeasureType)
                        {
                            case MeasureTypes.ABSOLUTE:
                                {
                                    risultato = CalculateWidthArea(item, split.SplitVertList.ElementAt(i).dDimension);
                                    break;
                                }
                            case MeasureTypes.PROPORTIONAL:
                                {
                                    risultato = CalculateWidthArea(item, ConvertFromPropVal(split.SplitVertList, split.SplitVertList.ElementAt(i).dDimension, MeasureTypes.ABSOLUTE, width));
                                    break;
                                }
                            case MeasureTypes.PERCENTAGE:
                                {
                                    risultato = CalculateWidthArea(item, split.SplitVertList.ElementAt(i).dDimension * width / 100);
                                    break;
                                }
                        }
                    }
                    else
                    {
                        risultato = CalculateWidthArea(item, width);
                    }
                    if (risultato != -1)
                        return risultato;
                }
                else if (area is Sash)
                {
                    Sash sash = (Sash)area;
                    switch (sash.SashList.ElementAt(i).SelMeasureType)
                    {
                        case MeasureTypes.ABSOLUTE:
                            {
                                risultato = CalculateWidthArea(item, sash.SashList.ElementAt(i).dDimension);
                                break;
                            }
                        case MeasureTypes.PROPORTIONAL:
                            {
                                risultato = CalculateWidthArea(item, ConvertFromPropVal(sash, sash.SashList.ElementAt(i).dDimension, MeasureTypes.ABSOLUTE, width));
                                break;
                            }
                        case MeasureTypes.PERCENTAGE:
                            {
                                risultato = CalculateWidthArea(item, sash.SashList.ElementAt(i).dDimension * width / 100);
                                break;
                            }
                    }
                    if (risultato != -1)
                        return risultato;
                }
                else
                {
                    risultato = CalculateWidthArea(item, width);
                    if (risultato != -1)
                        return risultato;
                }
            }
            return width;
        }

        /// <summary>
        /// Metodo per calcolare larghezza area
        /// </summary>
        /// <param name="area"> area di partenza </param>
        /// <param name="height"> altezza di partenza </param>
        /// <returns></returns>
        public double CalculateHeightArea(Area area, double height)
        {
            for (int i = 0; i < area.AreaList.Count; i++)
            {
                double risultato = -1;
                if (area.Equals(this))
                    return height;
                Area item = area.AreaList[i];
                if (area is Split)
                {
                    Split split = (Split)area;
                    if (split.SplitHorizList.Count > 0)
                    {
                        switch (split.SplitHorizList.ElementAt(i).SelMeasureType)
                        {
                            case MeasureTypes.ABSOLUTE:
                                {
                                    risultato = CalculateHeightArea(item, split.SplitHorizList.ElementAt(i).dDimension);
                                    break;
                                }
                            case MeasureTypes.PROPORTIONAL:
                                {
                                    risultato = CalculateHeightArea(item, ConvertFromPropVal(split.SplitHorizList, split.SplitHorizList.ElementAt(i).dDimension, MeasureTypes.ABSOLUTE, height) );
                                    break;
                                }
                            case MeasureTypes.PERCENTAGE:
                                {
                                    risultato = CalculateHeightArea(item, split.SplitHorizList.ElementAt(i).dDimension * height / 100);
                                    break;
                                }
                        }
                    }
                    else
                    {
                        risultato = CalculateHeightArea(item, height);
                    }
                    if (risultato != -1)
                        return risultato;
                }
                else if (area is Sash)
                {
                    Sash sash = (Sash)area;
                    switch (sash.SashList.ElementAt(i).SelMeasureType)
                    {
                        case MeasureTypes.ABSOLUTE:
                            {
                                risultato = CalculateHeightArea(item, sash.SashList.ElementAt(i).dDimension);
                                break;
                            }
                        case MeasureTypes.PROPORTIONAL:
                            {
                                risultato = CalculateHeightArea(item, ConvertFromPropVal(sash, sash.SashList.ElementAt(i).dDimension, MeasureTypes.ABSOLUTE, height));
                                break;
                            }
                        case MeasureTypes.PERCENTAGE:
                            {
                                risultato = CalculateHeightArea(item, sash.SashList.ElementAt(i).dDimension * height / 100);
                                break;
                            }
                    }
                    if (risultato != -1)
                        return risultato;
                }
                else
                {
                    risultato = CalculateHeightArea(item, height);
                    if (risultato != -1)
                        return risultato;
                }
            }
            return height;
        }

        #endregion Internal Methods

        #region Protected Fields

        protected int m_nAreaId = -1;

        protected Window m_ParentWindow;

        #endregion Protected Fields

        #region Private Fields

        // Conteggio dei macro elementi
        private static int m_CounterGroup = 0;

        private List<Area> m_AreaList = new List<Area>();
        private AreaTypes m_AreaType;
        private int m_GroupId;
        private Area m_ParentArea;

        #endregion Private Fields


    }
}