using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WebWindowTest.Json;
using static WebWindowTest.Json.WindowConst;

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

        public Split(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
        {
        }

        #endregion Public Constructors

        #region Public Properties

        //public bool bIsPercentage
        //{
        //    get
        //    {
        //        return m_bIsPercentage;
        //    }
        //}

        public bool bSplitStartVert
        {
            get
            {
                return m_bSplitStartVert;
            }
            set
            {
                m_bSplitStartVert = value;
            }
        }

        public int nSplitQtyHoriz
        {
            get
            {
                return m_SplitHorizList.Count > 0 ? m_SplitHorizList.Count - 1 : 0;
            }
            set
            {
                if(value >= 0 && value < 6)
                {
                    if (value == 0)
                    {
                        for (var SplitIndex = m_SplitHorizList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                            m_SplitHorizList.RemoveAt(SplitIndex);
                        if (nSplitQtyVert == 0)
                        {
                            ParentArea.AreaList.Remove(this);
                            Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
                            newFill.SetAreaType(AreaTypes.FILL);
                            ParentArea.AreaList.Add(newFill);
                        }
                        else
                            SetSplitShape(SplitShapes.VERTICAL);
                    }
                    else
                    {
                        double heightTot = CalculateHeightArea(ParentWindow.AreaList.First(), HeightFrame());
                        // Ricalcolo dimensioni aggiungendo split
                        if (value > m_SplitHorizList.Count - 1)
                        {
                            // recupero larghezza ultimo
                            double dLastDimension = heightTot;
                            double dNewDimension = heightTot;
                            if (m_SplitHorizList.Count > 0)
                            {
                                dLastDimension = m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension;
                                dNewDimension = dLastDimension / (value + 1 - nSplitQtyHoriz);
                                if (m_SplitHorizList[m_SplitHorizList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
                                    dNewDimension = 1;
                                m_SplitHorizList[m_SplitHorizList.Count - 1].SetDimension(dNewDimension);
                            }
                            else
                                dNewDimension = dLastDimension / (value + 1 - nSplitQtyHoriz);
                            // aggiungo area Split di default
                            for (var SplitIndex = m_SplitHorizList.Count; SplitIndex <= value; SplitIndex++)
                                m_SplitHorizList.Add(new SplitDimension(dNewDimension, m_SplitHorizList[m_SplitHorizList.Count - 1].MeasureType, true, this, false));
                        }
                        // Ricalcolo dimensioni rimuovendo split
                        else
                        {
                            double dLastDimension = 0;
                            for (var SplitIndex = m_SplitHorizList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
                            {
                                dLastDimension += m_SplitHorizList[SplitIndex].dDimension;
                                m_SplitHorizList.RemoveAt(SplitIndex);
                            }
                            dLastDimension += m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension;
                            m_SplitHorizList[m_SplitHorizList.Count - 1].SetDimension(dLastDimension);
                        }
                        // Controllo quanti split verticali ci sono
                        int nVert = m_SplitVertList.Count > 0 ? m_SplitVertList.Count : 1;
                        // Se aggiungo split devo aggiungere vetro nell'area splitted aggiunta
                        for (var SplitIndex = AreaList.Count; SplitIndex <= (m_SplitHorizList.Count * nVert) - 1; SplitIndex++)
                        {
                            AreaList.Add(Splitted.CreateSplitted(this));
                            Fill newFill = Fill.CreateFill(AreaList[SplitIndex], FillTypes.GLASS);
                            newFill.SetAreaType(AreaTypes.FILL);
                            AreaList[AreaList.Count - 1].AreaList.Add(newFill);
                        }
                        // Se ho più di uno split, elimino l'ultimo
                        if (AreaList.Count > 2)
                        {
                            int nAreaList = AreaList.Count - 1;
                            for (var SplitIndex = (m_SplitHorizList.Count * nVert); SplitIndex <= nAreaList; SplitIndex++)
                            {
                                AreaList.Remove(AreaList[AreaList.Count - 1]);
                            }
                        }
                        // Se elimino l'unico split presente
                        else
                        {
                            Splitted s = (Splitted)AreaList[0];
                            s.SetParentArea(ParentArea);
                            ParentArea.AreaList.Add(s);
                            ParentArea.AreaList.Remove(this);
                        }
                    }
                }
            }
        }

        public int nSplitQtyVert
        {
            get
            {
                return m_SplitVertList.Count > 0 ? m_SplitVertList.Count - 1 : 0;
            }
            set
            {
                if (value >= 0 && value < 6)
                {
                    if (value == 0)
                    {
                        for (var SplitIndex = m_SplitVertList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                            m_SplitVertList.RemoveAt(SplitIndex);
                        if (nSplitQtyHoriz == 0)
                        {
                            ParentArea.AreaList.Remove(this);
                            Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
                            newFill.SetAreaType(AreaTypes.FILL);
                            ParentArea.AreaList.Add(newFill);
                        }
                        else
                            SetSplitShape(SplitShapes.HORIZONTAL);
                    }
                    else
                    {
                        double widthTot = CalculateWidthArea(ParentWindow.AreaList.First(), ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Width").First().dDimension);
                        // Ricalcolo dimensioni aggiungendo split
                        if (value > m_SplitVertList.Count - 1)
                        {
                            // recupero larghezza ultimo
                            double dLastDimension = widthTot;
                            double dNewDimension = widthTot;
                            if (m_SplitVertList.Count > 0)
                            {
                                dLastDimension = m_SplitVertList[m_SplitVertList.Count - 1].dDimension;
                                dNewDimension = dLastDimension / (value + 1 - nSplitQtyVert);
                                if (m_SplitVertList[m_SplitVertList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
                                    dNewDimension = 1;
                                m_SplitVertList[m_SplitVertList.Count - 1].SetDimension(dNewDimension);
                            }
                            else
                                dNewDimension = dLastDimension / (value + 1 - nSplitQtyVert);
                            // aggiungo area Split di default
                            for (var SplitIndex = m_SplitVertList.Count; SplitIndex <= value; SplitIndex++)
                                m_SplitVertList.Add(new SplitDimension(dNewDimension, m_SplitVertList[m_SplitVertList.Count - 1].MeasureType, true, this, true));
                        }
                        else if (value == 0)
                        {
                            m_SplitVertList.RemoveAt(1);
                            m_SplitVertList.RemoveAt(0);
                        }
                        // Ricalcolo dimensioni rimuovendo split
                        else
                        {
                            int countProportional = m_SplitVertList.Count(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL));
                            if(m_SplitVertList.Last().MeasureType.Equals(MeasureTypes.PROPORTIONAL) && countProportional - 1 == 1)
                            {
                                m_SplitVertList.RemoveAt(m_SplitVertList.Count() - 1);
                                m_SplitVertList.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).FirstOrDefault().SetDimension(1);
                            }
                            else
                            {
                                double dLastDimension = 0;
                                for (var SplitIndex = m_SplitVertList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
                                {
                                    dLastDimension += m_SplitVertList[SplitIndex].dDimension;
                                    m_SplitVertList.RemoveAt(SplitIndex);
                                }
                                dLastDimension += m_SplitVertList[m_SplitVertList.Count - 1].dDimension;
                                m_SplitVertList[m_SplitVertList.Count - 1].SetDimension(dLastDimension);
                            }
                        }
                        // Controllo quanti split orizzontali ci sono
                        int nHoriz = m_SplitHorizList.Count > 0 ? m_SplitHorizList.Count : 1;
                        // Se aggiungo split devo aggiungere vetro nell'area splitted aggiunta
                        for (var SplitIndex = AreaList.Count; SplitIndex <= (m_SplitVertList.Count * nHoriz) - 1; SplitIndex++)
                        {
                            AreaList.Add(Splitted.CreateSplitted(this));
                            Fill newFill = Fill.CreateFill(AreaList[SplitIndex], FillTypes.GLASS);
                            newFill.SetAreaType(AreaTypes.FILL);
                            AreaList[AreaList.Count - 1].AreaList.Add(newFill);
                        }
                        // Se ho più di uno split, elimino l'ultimo
                        if (AreaList.Count > 2)
                        {
                            int nAreaList = AreaList.Count - 1;
                            for (var SplitIndex = (m_SplitVertList.Count * nHoriz); SplitIndex <= nAreaList; SplitIndex++)
                            {
                                AreaList.Remove(AreaList[AreaList.Count - 1]);
                            }
                        }
                        // Se elimino l'unico split presente
                        else
                        {
                            Splitted s = (Splitted)AreaList[0];
                            s.SetParentArea(ParentArea);
                            ParentArea.AreaList.Add(s);
                            ParentArea.AreaList.Remove(this);
                        }
                    }
                    if(SplitHorizList.Count > 0)
                    {
                        for (int i = 0; i < AreaList.Count; i++)
                        {
                            if(i < SplitHorizList.Count)
                                AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), SplitHorizList.ElementAt(i).dDimension, "Width");
                        }
                    }
                    if (SplitVertList.Count > 0)
                    {
                        for (int i = 0; i < AreaList.Count; i++)
                        {
                            if(i < SplitVertList.Count)
                                AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), SplitVertList.ElementAt(i).dDimension, "Height");
                        }
                    }
                }
            }
        }

        public int SelSplitShapeIndex
        {
            get
            {
                return (int)m_SelSplitShape;
            }
            set
            {
                SplitShapes OldSelShapeSplit = m_SelSplitShape;
                m_SelSplitShape = (SplitShapes)value;
                // Azzero quantità orizzontale e verticale
                SetSplitQtyVert(0);
                SetSplitQtyHoriz(0);
                if (m_SelSplitShape == SplitShapes.VERTICAL)
                {
                    // Inserisco valori di default
                    SetSplitQtyVert(1);
                    SetSplitStartVert(true);
                }
                else if (m_SelSplitShape == SplitShapes.HORIZONTAL)
                {
                    // Inserisco valori di default
                    SetSplitQtyHoriz(1);
                    SetSplitStartVert(false);
                }
                else
                {
                    // Inserisco valori di default
                    SetSplitQtyVert(1);
                    SetSplitQtyHoriz(1);
                    SetSplitStartVert(true);
                }
                if(OldSelShapeSplit == SplitShapes.GRID || m_SelSplitShape == SplitShapes.GRID)
                {
                    // Cancello vecchio contenuto dello split
                    AreaList.Clear();
                    // Aggiungo area Splitted e vetro
                    int nVert = m_SplitVertList.Count > 0 ? m_SplitVertList.Count : 1;
                    int nHoriz = m_SplitHorizList.Count > 0 ? m_SplitHorizList.Count : 1;
                    for (var SplitIndex = 0; SplitIndex <= (nVert * nHoriz) - 1; SplitIndex++)
                    {
                        AreaList.Add(Splitted.CreateSplitted(this));
                        Fill newFill = Fill.CreateFill(AreaList[SplitIndex], FillTypes.GLASS);
                        newFill.SetAreaType(AreaTypes.FILL);
                        AreaList[SplitIndex].AreaList.Add(newFill);
                    }
                }
            }
        }

        public List<SplitDimension> SplitHorizList
        {
            get
            {
                return m_SplitHorizList;
            }
            set
            {
                m_SplitHorizList = value;
            }
        }

        public List<SplitDimension> SplitPositionList
        {
            get
            {
                return m_SplitPositionList;
            }
            set
            {
                m_SplitPositionList = value;
            }
        }

        public List<IdNameStruct> SplitShapeList
        {
            get
            {
                return m_SplitShapeList;
            }
        }

        public List<SplitDimension> SplitVertList
        {
            get
            {
                return m_SplitVertList;
            }
            set
            {
                m_SplitVertList = value;
            }
        }

        #endregion Public Properties

        #region Public Methods

        public override Split Copy(Area newParentArea)
        {
            Split newSplit = new Split(newParentArea, ParentWindow);
            AddCounterGroup();
            newSplit.SetGroupId(nCounterGroup);
            newSplit.SetSplitStartVert(bSplitStartVert);
            for (int i = 0; i < SplitVertList.Count; i++)
                newSplit.SplitVertList.Add(SplitVertList[i].Copy());
            for (int i = 0; i < SplitHorizList.Count; i++)
                newSplit.SplitHorizList.Add(SplitHorizList[i].Copy());
            //newSplit.SetSplitQtyVert(nSplitQtyVert);
            //for (int i = 0; i < SplitVertList.Count; i++)
            //    newSplit.SplitVertList.ElementAt(i).SetDimension(SplitVertList.ElementAt(i).dDimension);
            //newSplit.SetSplitQtyHoriz(nSplitQtyHoriz);
            //for (int i = 0; i < SplitHorizList.Count; i++)
            //    newSplit.SplitHorizList.ElementAt(i).SetDimension(SplitHorizList.ElementAt(i).dDimension);
            newSplit.SetSplitShape(SelSplitShape);
            newSplit.SetAreaType(AreaType);
            foreach (var item in AreaList)
            {
                Area a = item.Copy(newSplit);
                newSplit.AreaList.Add(a);
            }
            return newSplit;
        }

        public void Remove()
        {
            ParentArea.AreaList.Remove(this);
            Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
            newFill.SetAreaType(AreaTypes.FILL);
            ParentArea.AreaList.Add(newFill);
            //m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
        }

        #endregion Public Methods

        #region Internal Properties

        internal SplitShapes SelSplitShape
        {
            get
            {
                return m_SelSplitShape;
            }
        }

        #endregion Internal Properties

        #region Internal Methods

        internal static Split CreateSplit(Area Area, SplitShapes SplitShape)
        {
            Split Split = new Split(Area, Area.ParentWindow);
            AddCounterGroup();
            Split.SetGroupId(nCounterGroup);
            Split.SetAreaType(AreaTypes.SPLIT);
            Split.SetSplitShape(SplitShape);
            return Split;
        }

        internal override JsonArea Serialize(bool hideHw)
        {
            if (nCounterGroup < GroupId)
                Area.nCounterGroup = GroupId;
            JsonSplit JsonSplit = new JsonSplit(m_SelSplitShape, GroupId);
            //foreach (var SplitPosition in m_SplitPositionList)
            //    JsonSplit.SplitPositionList.Add(SplitPosition.Serialize());
            JsonSplit.SplitStartVert = bSplitStartVert;
            foreach (var SplitVert in m_SplitVertList)
                JsonSplit.SplitVertList.Add(SplitVert.Serialize());
            foreach (var SplitHoriz in m_SplitHorizList)
                JsonSplit.SplitHorizList.Add(SplitHoriz.Serialize());
            foreach (var Area in AreaList)
                JsonSplit.AreaList.Add(Area.Serialize(hideHw));
            return JsonSplit;
        }

        internal void SetSplitQtyHoriz(int QtyHoriz)
        {
            if (QtyHoriz > m_SplitHorizList.Count)
            {
                // recupero larghezza ultimo
                double dLastDimension = 100;
                double dNewDimension = 100;
                if (m_SplitHorizList.Count > 0)
                {
                    dLastDimension = m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension;
                    dNewDimension = dLastDimension / (QtyHoriz + 1 - nSplitQtyHoriz);
                    m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension = dNewDimension;
                }
                else
                    dNewDimension = dLastDimension / (QtyHoriz + 1 - nSplitQtyHoriz);
                // aggiungo area Split di default
                for (var SplitIndex = m_SplitHorizList.Count; SplitIndex <= QtyHoriz; SplitIndex++)
                    m_SplitHorizList.Add(new SplitDimension(dNewDimension, MeasureTypes.PERCENTAGE, true, this, false));
            }
            else if (QtyHoriz < m_SplitHorizList.Count)
            {
                for (var SplitIndex = m_SplitHorizList.Count - 1; SplitIndex >= QtyHoriz; SplitIndex += -1)
                    m_SplitHorizList.RemoveAt(SplitIndex);
            }
        }

        internal void SetSplitQtyVert(int QtyVert)
        {
            if (QtyVert > m_SplitVertList.Count)
            {
                // recupero larghezza ultimo
                double dLastDimension = 100;
                double dNewDimension = 100;
                if (m_SplitVertList.Count > 0)
                {
                    dLastDimension = m_SplitVertList[m_SplitVertList.Count - 1].dDimension;
                    dNewDimension = dLastDimension / (QtyVert + 1 - nSplitQtyVert);
                    m_SplitVertList[m_SplitVertList.Count - 1].dDimension = dNewDimension;
                }
                else
                    dNewDimension = dLastDimension / (QtyVert + 1 - nSplitQtyVert);
                // aggiungo area Split di default
                for (var SplitIndex = m_SplitVertList.Count; SplitIndex <= QtyVert; SplitIndex++)
                    m_SplitVertList.Add(new SplitDimension(dNewDimension, MeasureTypes.PERCENTAGE, true, this, true));
            }
            else if (QtyVert < m_SplitVertList.Count)
            {
                for (var SplitIndex = m_SplitVertList.Count - 1; SplitIndex >= QtyVert; SplitIndex += -1)
                    m_SplitVertList.RemoveAt(SplitIndex);
            }
        }

        internal void SetSplitShape(SplitShapes Value)
        {
            m_SelSplitShape = Value;
        }

        internal void SetSplitStartVert(bool SplitStartVert)
        {
            m_bSplitStartVert = SplitStartVert;
        }

        internal double HeightFrame()
        {
            switch (ParentWindow.AreaList.First().SelShapeIndex)
            {
                case (int)Shapes.RECTANGLE:
                case (int)Shapes.TRIANGLE:
                case (int)Shapes.ARC_FULL:
                    {
                        return ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Height").First().dDimension;
                    }
                case (int)Shapes.RIGHTCHAMFER:
                    {
                        return ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Left Height").First().dDimension;
                    }
                case (int)Shapes.LEFTCHAMFER:
                    {
                        return ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Right Height").First().dDimension;
                    }
                default:
                    {
                        return ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Full Height").First().dDimension;
                    }
            }
        }

        #endregion Internal Methods

        #region Private Fields

        private bool m_bIsPercentage = true;
        private bool m_bSplitStartVert = true;
        private SplitShapes m_SelSplitShape;

        private List<SplitDimension> m_SplitHorizList = new List<SplitDimension>();

        private List<SplitDimension> m_SplitPositionList = new List<SplitDimension>();

        private List<IdNameStruct> m_SplitShapeList = new List<IdNameStruct>
        {
            new IdNameStruct((int)SplitShapes.VERTICAL, "Vertical"),
            new IdNameStruct((int)SplitShapes.HORIZONTAL, "Horizontal"),
            new IdNameStruct((int)SplitShapes.GRID, "Grid"),
            new IdNameStruct((int)SplitShapes.CUSTOM, "Custom")
        };

        private List<SplitDimension> m_SplitVertList = new List<SplitDimension>();

        //private double m_Width = 0;

        #endregion Private Fields
    }
}