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

namespace WebWindowComplex.Models
{
    public class Inglesina : Split
    {
        public Inglesina(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
        {
        }

        public int SelSideIndex
        {
            get
            {
                return (int)m_SelSide;
            }
            set
            {
                m_SelSide = (SideInglesina)value;
            }
        }
        internal override JsonArea Serialize(bool hideHw)
        {
            if (nCounterGroup < GroupId)
                Area.nCounterGroup = GroupId;
            JsonInglesina JsonInglesina = new JsonInglesina(m_SelSide, SelSplitShape, GroupId);
            JsonInglesina.SplitStartVert = bSplitStartVert;
            foreach (var SplitVert in SplitVertList)
                JsonInglesina.SplitVertList.Add(SplitVert.Serialize());
            foreach (var SplitHoriz in SplitHorizList)
                JsonInglesina.SplitHorizList.Add(SplitHoriz.Serialize());
            if (ElemDimHorizList != null && ElemDimHorizList.Count > 0)
            {
                int subAreaMinHoriz = ElemDimHorizList.Min(x => x.nSubArea);
                List<SplitElementDimension> horizList = ElemDimHorizList.Where(x => x.nSubArea == subAreaMinHoriz).ToList();
                foreach (var Elem in horizList)
                    JsonInglesina.ElementDimHorizList.Add(Elem.Serialize());
            }
            if (ElemDimVertList != null && ElemDimVertList.Count > 0)
            {
                int subAreaMinVert = ElemDimVertList.Min(x => x.nSubArea);
                List<SplitElementDimension> vertList = ElemDimVertList.Where(x => x.nSubArea == subAreaMinVert).ToList();
                foreach (var Elem in vertList.ToList())
                    JsonInglesina.ElementDimVertList.Add(Elem.Serialize());
            }
            foreach (var Area in AreaList)
                JsonInglesina.AreaList.Add(Area.Serialize(hideHw));
            return JsonInglesina;
        }
        internal static Inglesina CreateInglesina(Area Area, SplitShapes SplitShape)
        {
            Inglesina inglesina = new Inglesina(Area, Area.ParentWindow);
            AddCounterGroup();
            inglesina.SetGroupId(nCounterGroup);
            inglesina.SetAreaType(AreaTypes.INGLESINA);
            inglesina.SetSplitShape(SplitShape);
            inglesina.SetSelSide(SideInglesina.BOTH);
            return inglesina;
        }

        public override Inglesina Copy(Area newParentArea)
        {
            Inglesina newInglesina = new Inglesina(newParentArea, m_ParentWindow);
            AddCounterGroup();
            newInglesina.SetGroupId(nCounterGroup);
            newInglesina.SetSelSide(m_SelSide);
            newInglesina.SetSplitStartVert(bSplitStartVert);
            for (int i = 0; i < SplitVertList.Count; i++)
                newInglesina.SplitVertList.Add(SplitVertList[i].Copy());
            for (int i = 0; i < SplitHorizList.Count; i++)
                newInglesina.SplitHorizList.Add(SplitHorizList[i].Copy());
            newInglesina.SetSplitShape(SelSplitShape);
            newInglesina.SetAreaType(AreaType);
            foreach (var item in ElemDimHorizList)
            {
                SplitElementDimension newElementDimension = item.Copy();
                newInglesina.ElemDimHorizList.Add(newElementDimension);
            }
            foreach (var item in ElemDimVertList)
            {
                SplitElementDimension newElementDimension = item.Copy();
                newInglesina.ElemDimVertList.Add(newElementDimension);
            }
            if (AreaList != null && AreaList.Count > 0)
            {
                foreach (var item in AreaList)
                {
                    Area a = item.Copy(newInglesina);
                    newInglesina.AreaList.Add(a);
                }
            }
            return newInglesina;
        }

        internal void SetSelSide(SideInglesina side)
        {
            m_SelSide = side;
        }
        public List<IdNameStruct> SideList
        {
            get
            {
                return m_SideList;
            }
        }

        public override int nSplitQtyHoriz
        {
            get
            {
                return SplitHorizList.Count > 0 ? SplitHorizList.Count - 1 : 0;
            }
            set
            {
                if (value >= 0 && value < 6)
                {
                    if (value == 0)
                    {
                        for (var SplitIndex = SplitHorizList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                            SplitHorizList.RemoveAt(SplitIndex);
                        if (nSplitQtyVert == 0)
                        {
                            ParentArea.AreaList.Remove(this);
                        }
                        else
                        {
                            ElemDimHorizList.Clear();
                            SetSplitShape(SplitShapes.VERTICAL);
                            SetSplitStartVert(true);
                            // Controllo quanti split orizzontali ci sono
                            int nVert = SplitVertList.Count > 0 ? SplitVertList.Count : 1;
                            // Cancello aree di troppo
                            for (var SplitIndex = nVert; SplitIndex <= AreaList.Count; SplitIndex++)
                                AreaList.RemoveAt(AreaList.Count - 1);
                        }
                    }
                    else
                    {
                        Frame? frame = ParentWindow.AreaList.FirstOrDefault();
                        if (frame != null)
                        {
                            double heightTot = CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false)).m_Dimension;
                            // Ricalcolo dimensioni aggiungendo split
                            if (value > SplitHorizList.Count - 1)
                            {
                                // recupero larghezza ultimo
                                double dLastDimension = heightTot;
                                double dNewDimension = heightTot;
                                if (SplitHorizList.Count > 0)
                                {
                                    dLastDimension = SplitHorizList[SplitHorizList.Count - 1].dDimension;
                                    if (SplitHorizList.Last().MeasureType is MeasureTypes.ABSOLUTE)
                                        dNewDimension = (dLastDimension - ElemDimHorizList.Last().dDimension) / (value + 1 - nSplitQtyHoriz);
                                    else
                                        dNewDimension = dLastDimension / (value + 1 - nSplitQtyHoriz);
                                    if (SplitHorizList[SplitHorizList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
                                        dNewDimension = 1;
                                    SplitHorizList[SplitHorizList.Count - 1].SetDimension(dNewDimension);
                                }
                                else
                                    dNewDimension = dLastDimension / (value + 1 - nSplitQtyHoriz);
                                // aggiungo area Split di default
                                for (var SplitIndex = SplitHorizList.Count; SplitIndex <= value; SplitIndex++)
                                    SplitHorizList.Add(new SplitDimension(dNewDimension, SplitHorizList[SplitHorizList.Count - 1].MeasureType, true, this, false));
                                double thickness = SetThickness();
                                if (!bSplitStartVert)
                                {
                                    //Aggiungo un elemento alla sottoarea principale
                                    SplitElementDimension newElemDim = ElemDimHorizList.First().Copy();
                                    newElemDim.SetElement(ElemDimHorizList.Max(x => x.nIndex) + 1, thickness, 0);
                                    ElemDimHorizList.Add(newElemDim);
                                    if (nSplitQtyVert > 0)
                                    {
                                        // Aggiungo a tutte le sottoaree degli element
                                        int subArea = ElemDimVertList.Max(x => x.nSubArea) + 1;
                                        for (int i = 1; i <= ElemDimVertList.Max(x => x.nIndex); i++)
                                        {
                                            newElemDim = ElemDimVertList.First().Copy();
                                            newElemDim.SetElement(i, thickness, subArea);
                                            ElemDimVertList.Add(newElemDim);
                                        }
                                    }
                                }
                                else
                                {
                                    // Aggiungo a tutte le sottoaree degli element
                                    for (int i = 1; i <= ElemDimHorizList.Max(x => x.nSubArea); i++)
                                    {
                                        int index = ElemDimHorizList.Where(x => x.nSubArea == i).Max(x => x.nIndex);
                                        SplitElementDimension newElemDim = ElemDimVertList.First().Copy();
                                        newElemDim.SetElement(index + 1, thickness, i);
                                        ElemDimHorizList.Insert(index * i + (i - 1), newElemDim);
                                    }
                                }
                            }
                            // Ricalcolo dimensioni rimuovendo split
                            else
                            {
                                int countProportional = SplitHorizList.Count(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL));
                                if (SplitHorizList.Last().MeasureType.Equals(MeasureTypes.PROPORTIONAL) && countProportional - 1 == 1)
                                {
                                    SplitHorizList.RemoveAt(SplitVertList.Count() - 1);
                                    SplitHorizList.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).FirstOrDefault()?.SetDimension(1);
                                }
                                else
                                {
                                    double dLastDimension = 0;
                                    for (var SplitIndex = SplitHorizList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
                                    {
                                        dLastDimension += SplitHorizList[SplitIndex].dDimension;
                                        if (SplitHorizList.Last().MeasureType.Equals(MeasureTypes.ABSOLUTE))
                                            dLastDimension += ElemDimHorizList[SplitIndex - 1].dDimension;
                                        SplitHorizList.RemoveAt(SplitIndex);
                                    }
                                    dLastDimension += SplitHorizList[SplitHorizList.Count - 1].dDimension;
                                    SplitHorizList[SplitHorizList.Count - 1].SetDimension(dLastDimension);
                                }
                                if (bSplitStartVert)
                                {
                                    // Rimuovo da tutte le sottoaree gli element
                                    for (int subArea = 1; subArea <= ElemDimHorizList.Max(x => x.nSubArea); subArea++)
                                    {
                                        List<SplitElementDimension> elemDimList = ElemDimHorizList.Where(x => x.nSubArea == subArea).OrderByDescending(x => x.nIndex).ToList();
                                        for (var SplitIndex = elemDimList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                                        {
                                            ElemDimHorizList.Remove(elemDimList.ElementAt(elemDimList.Count - 1));
                                        }
                                    }
                                }
                                else
                                {
                                    int deleteSubArea = ElemDimHorizList.Count + 1;
                                    for (var SplitIndex = ElemDimHorizList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                                    {
                                        ElemDimHorizList.RemoveAt(ElemDimHorizList.Count - 1);
                                    }
                                    if (nSplitQtyVert > 0)
                                        ElemDimVertList.RemoveAll(x => x.nSubArea == deleteSubArea);
                                }
                            }
                        }
                    }
                }
            }
        }

        public override int nSplitQtyVert
        {
            get
            {
                return SplitVertList.Count > 0 ? SplitVertList.Count - 1 : 0;
            }
            set
            {
                if (value >= 0 && value < 6)
                {
                    if (value == 0)
                    {
                        for (var SplitIndex = SplitVertList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                            SplitVertList.RemoveAt(SplitIndex);
                        if (nSplitQtyHoriz == 0)
                        {
                            ParentArea.AreaList.Remove(this);
                        }
                        else
                        {
                            ElemDimVertList.Clear();
                            SetSplitShape(SplitShapes.HORIZONTAL);
                            SetSplitStartVert(false);
                            // Controllo quanti split orizzontali ci sono
                            int nHoriz = SplitHorizList.Count > 0 ? SplitHorizList.Count : 1;
                            // Cancello aree di troppo
                            for (var SplitIndex = nHoriz; SplitIndex <= AreaList.Count; SplitIndex++)
                                AreaList.RemoveAt(AreaList.Count - 1);
                        }
                    }
                    else
                    {
                        Frame? frame = ParentWindow.AreaList.FirstOrDefault();
                        if (frame != null)
                        {
                            double widthTot = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                            // Ricalcolo dimensioni aggiungendo split
                            if (value > SplitVertList.Count - 1)
                            {
                                // recupero larghezza ultimo
                                double dLastDimension = widthTot;
                                double dNewDimension = widthTot;
                                if (SplitVertList.Count > 0)
                                {
                                    dLastDimension = SplitVertList[SplitVertList.Count - 1].dDimension;
                                    if (SplitVertList.Last().MeasureType is MeasureTypes.ABSOLUTE)
                                        dNewDimension = (dLastDimension - ElemDimVertList.Last().dDimension) / (value + 1 - nSplitQtyVert);
                                    else
                                        dNewDimension = dLastDimension / (value + 1 - nSplitQtyVert);
                                    if (SplitVertList[SplitVertList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
                                        dNewDimension = 1;
                                    SplitVertList[SplitVertList.Count - 1].SetDimension(dNewDimension);
                                }
                                else
                                    dNewDimension = dLastDimension / (value + 1 - nSplitQtyVert);
                                // aggiungo area Split di default
                                for (var SplitIndex = SplitVertList.Count; SplitIndex <= value; SplitIndex++)
                                    SplitVertList.Add(new SplitDimension(dNewDimension, SplitVertList[SplitVertList.Count - 1].MeasureType, true, this, true));
                                double thickness = SetThickness();
                                if (bSplitStartVert)
                                {
                                    //Aggiungo un elemento alla sottoarea principale
                                    SplitElementDimension newElemDim = ElemDimVertList.First().Copy();
                                    newElemDim.SetElement(ElemDimVertList.Max(x => x.nIndex) + 1, thickness, 0);
                                    ElemDimVertList.Add(newElemDim);
                                    if (nSplitQtyHoriz > 0)
                                    {
                                        // Aggiungo a tutte le sottoaree degli element
                                        int subArea = ElemDimHorizList.Max(x => x.nSubArea) + 1;
                                        for (int i = 1; i <= ElemDimHorizList.Max(x => x.nIndex); i++)
                                        {
                                            newElemDim = ElemDimHorizList.First().Copy();
                                            newElemDim.SetElement(i, thickness, subArea);
                                            ElemDimHorizList.Add(newElemDim);
                                        }
                                    }
                                }
                                else
                                {
                                    // Aggiungo a tutte le sottoaree un elemento
                                    for (int i = 1; i <= ElemDimVertList.Max(x => x.nSubArea); i++)
                                    {
                                        int index = ElemDimVertList.Where(x => x.nSubArea == i).Max(x => x.nIndex);
                                        SplitElementDimension newElemDim = ElemDimVertList.First().Copy();
                                        newElemDim.SetElement(index + 1, thickness, i);
                                        ElemDimVertList.Insert(index * i + (i - 1), newElemDim);
                                    }
                                }
                            }
                            else if (value == 0)
                            {
                                SplitVertList.RemoveAt(1);
                                SplitVertList.RemoveAt(0);
                            }
                            // Ricalcolo dimensioni rimuovendo split
                            else
                            {
                                int countProportional = SplitVertList.Count(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL));
                                if (SplitVertList.Last().MeasureType.Equals(MeasureTypes.PROPORTIONAL) && countProportional - 1 == 1)
                                {
                                    SplitVertList.RemoveAt(SplitVertList.Count() - 1);
                                    SplitVertList.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).FirstOrDefault()?.SetDimension(1);
                                }
                                else
                                {
                                    double dLastDimension = 0;
                                    for (var SplitIndex = SplitVertList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
                                    {
                                        dLastDimension += SplitVertList[SplitIndex].dDimension;
                                        if (SplitVertList.Last().MeasureType.Equals(MeasureTypes.ABSOLUTE))
                                            dLastDimension += ElemDimVertList[SplitIndex - 1].dDimension;
                                        SplitVertList.RemoveAt(SplitIndex);
                                    }
                                    dLastDimension += SplitVertList[SplitVertList.Count - 1].dDimension;
                                    SplitVertList[SplitVertList.Count - 1].SetDimension(dLastDimension);
                                }
                                if (bSplitStartVert)
                                {
                                    int deleteSubArea = ElemDimVertList.Count + 1;
                                    for(var SplitIndex = ElemDimVertList.Count - 1; SplitIndex >= value; SplitIndex += -1)
                                    {
                                        ElemDimVertList.RemoveAt(ElemDimVertList.Count - 1);
                                    }
                                    if (nSplitQtyHoriz > 0)
                                        ElemDimHorizList.RemoveAll(x => x.nSubArea == deleteSubArea);
                                }
                                else
                                {
                                    // Rimuovo da tutte le sottoaree degli element l'ultimo elemento
                                    for (int subArea = 1; subArea <= ElemDimVertList.Max(x => x.nSubArea); subArea++)
                                    {
                                        List<SplitElementDimension> elemDimList = ElemDimVertList.Where(x => x.nSubArea == subArea).OrderByDescending(x => x.nIndex).ToList();
                                        ElemDimVertList.Remove(elemDimList.ElementAt(elemDimList.Count - 1));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        public override int SelSplitShapeIndex
        {
            get
            {
                return (int)SelSplitShape;
            }
            set
            {
                SplitShapes OldSelShapeSplit = SelSplitShape;
                SelSplitShape = (SplitShapes)value;
                // Azzero quantità orizzontale e verticale
                SetSplitQtyVert(0, 0);
                SetSplitQtyHoriz(0, 0);
                if (SelSplitShape == SplitShapes.VERTICAL)
                {
                    // Inserisco valori di default
                    SetSplitStartVert(true);
                    SetSplitQtyVert(1, 0);
                }
                else if (SelSplitShape == SplitShapes.HORIZONTAL)
                {
                    // Inserisco valori di default
                    SetSplitStartVert(false);
                    SetSplitQtyHoriz(1, 0);
                }
                else
                {
                    // Inserisco valori di default
                    SetSplitStartVert(true);
                    SetSplitQtyVert(1, 1);
                    SetSplitQtyHoriz(1, 1);
                }
                UpdateSubAreaSplit();
            }
        }

        internal override double SetThickness()
        {
            double thickness = Window.m_ParameterList.GetValueOrDefault("Fill_Fill_Split_In_DimStd");
            if (ParentArea.ParentArea.ParentArea is Sash sash)
            {
                SashDimension anta = sash.SashList[0];
                if (anta.SelOpeningType is Openings.COMPLANARSLIDE_LEFT ||
                    anta.SelOpeningType is Openings.COMPLANARSLIDE_RIGHT ||
                    anta.SelOpeningType is Openings.LIFTSLIDE_LEFT ||
                    anta.SelOpeningType is Openings.COMPLANARSLIDE_RIGHT)
                {
                    if (m_SelSide is SideInglesina.INTERNAL)
                        thickness = Window.m_ParameterList.GetValueOrDefault("Fill_Slide_Fill_Split_In_DimStd");
                    else
                        thickness = Window.m_ParameterList.GetValueOrDefault("Fill_Slide_Fill_Split_Out_DimStd");
                }
                else
                {
                    if (m_SelSide is SideInglesina.INTERNAL)
                        thickness = Window.m_ParameterList.GetValueOrDefault("Fill_Fill_Split_In_DimStd");
                    else
                        thickness = Window.m_ParameterList.GetValueOrDefault("Fill_Fill_Split_Out_DimStd");
                }
            }
            else
            {
                if (m_SelSide is SideInglesina.EXTERNAL)
                    thickness = Window.m_ParameterList.GetValueOrDefault("Fill_Fill_Split_Out_DimStd");
            }
                return thickness;
        }

        private List<IdNameStruct> m_SideList = new List<IdNameStruct>
        {
            new IdNameStruct((int)SideInglesina.INTERNAL, "Internal"),
            new IdNameStruct((int)SideInglesina.EXTERNAL, "External"),
            new IdNameStruct((int)SideInglesina.BOTH, "Both")
        };

        private SideInglesina m_SelSide;
    }
}