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

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

        public SashDimension(double dDimension, MeasureTypes MeasureType, Sash Parent, int nSashId):base(dDimension, MeasureType, Parent)
        {
            m_dDimension = dDimension;
            m_nSashId = nSashId;
            m_Parent = Parent;
            SetMeasureType(MeasureType);
            // assengno maniglia
            if (Parent.SashList.Count == 0 || !Parent.SashList.Any(x => x.bHasHandle))
                m_bHasHandle = true;
            // assegno tipo di anta
            if (Parent.SashList.Count == 0)
                SetOpeningType(Openings.TILTTURN_LEFT);
            else if (Parent.SashList.Count == 1)
            {
                switch (Parent.SashList[0].OpeningType)
                {
                    case Openings.TURNONLY_LEFT:
                    case Openings.TILTTURN_LEFT:
                        {
                            SetOpeningType(Openings.TURNONLY_RIGHT);
                            break;
                        }

                    case Openings.TURNONLY_RIGHT:
                    case Openings.TILTTURN_RIGHT:
                        {
                            SetOpeningType(Openings.TURNONLY_LEFT);
                            break;
                        }

                    case Openings.TILTONLY_TOP:
                        {
                            SetOpeningType(Openings.TILTONLY_BOTTOM);
                            break;
                        }

                    case Openings.TILTONLY_BOTTOM:
                        {
                            SetOpeningType(Openings.TILTONLY_TOP);
                            break;
                        }

                    case Openings.COMPLANARSLIDE_LEFT:
                        {
                            SetOpeningType(Openings.COMPLANARSLIDE_RIGHT);
                            break;
                        }

                    case Openings.COMPLANARSLIDE_RIGHT:
                        {
                            SetOpeningType(Openings.COMPLANARSLIDE_LEFT);
                            break;
                        }

                    case Openings.LIFTSLIDE_LEFT:
                        {
                            SetOpeningType(Openings.LIFTSLIDE_RIGHT);
                            break;
                        }

                    case Openings.LIFTSLIDE_RIGHT:
                        {
                            SetOpeningType(Openings.LIFTSLIDE_LEFT);
                            break;
                        }
                }
            }
            else
                SetOpeningType(Parent.SashList[Parent.SashList.Count - 1].OpeningType);
        }

        #endregion Public Constructors

        #region Public Properties

        public bool bHasHandle
        {
            get
            {
                return m_bHasHandle;
            }
            set
            {
                m_bHasHandle = value;
            }
        }

        public Sash Parent
        {
            get
            {
                return m_Parent;
            }
            set
            {
                m_Parent = value;
            }
        }
        public List<ElementDimension> ElementDimensionList
        {
            get
            {
                return m_ElementDimensionList;
            }
            set
            {
                m_ElementDimensionList = value;
            }
        }

        public List<Joint> JointList
        {
            get
            {
                return m_JointList;
            }
            set
            {
                m_JointList = value;
            }
        }

        public override double dDimension
        {
            get
            {
                return m_dDimension;
            }
            set
            {
                Frame? frame = m_Parent.ParentWindow.AreaList.FirstOrDefault();
                if (frame != null)
                {
                    double widthTot = (Parent.CalculateWidthSashGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false))).m_Dimension;
                    if (m_Parent.bIsDimensionLight)
                    {
                        for (int i = 0; i < m_Parent.SashList.Count; i++)
                        {
                            if (i == 0)
                                widthTot = widthTot - m_Parent.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
                                                    - m_Parent.SashList.ElementAt(i).ElementDimensionList.Last().dDimension;
                            else
                                widthTot = widthTot - m_Parent.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
                                                    - m_Parent.SashList.ElementAt(i).ElementDimensionList.Last().dDimension
                                                    + m_Parent.SashList.ElementAt(i).ElementDimensionList.Last().dOverlap;
                        }
                    }
                    double valMinAbsolute = 100;
                    double valMaxAbsolute = widthTot - valMinAbsolute * (m_Parent.SashList.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 / widthTot * 100;
                                valMinAbsolute = valMinAbsolute / widthTot * 100;
                                valueAccept = (value < valMaxAbsolute && value > valMinAbsolute) ? true : false;
                                break;
                            }
                    }
                    if (valueAccept)
                    {
                        List<SashDimension> dimensions = m_Parent.SashList;
                        List<double> absoluteValList = new List<double>();
                        AreaDimension ad = new AreaDimension(m_dDimension, SelMeasureType, Parent);
                        List<AreaDimension> adList = new List<AreaDimension>();
                        foreach (var it in m_Parent.SashList)
                        {
                            adList.Add(new AreaDimension(it.m_dDimension, it.SelMeasureType, it.Parent));
                        }
                        int index = 0;
                        foreach (var item in m_Parent.SashList)
                        {
                            absoluteValList.Add(adList.ElementAt(index).CalculateAbsoluteValue(adList, widthTot));
                            index++;
                        }
                        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 || SelMeasureType.Equals(MeasureTypes.PROPORTIONAL) ||
                            (SelMeasureType.Equals(MeasureTypes.ABSOLUTE) && proportionalCount == absoluteValList.Count -1))
                        {
                            m_dDimension = value;
                        }
                        // Le dimensioni sono solo in percentuale
                        else if (percentageCount == dimensions.Count)
                        {
                            if (value < m_dDimension)
                            {
                                // L'anta modificata non è l'ultima
                                if (nIndex < dimensions.Count - 1)
                                    dimensions[nIndex + 1].SetDimension(Math.Round(dimensions[nIndex + 1].m_dDimension + (m_dDimension - value), 2));
                                else if (dimensions.Count > 1)
                                    dimensions[nIndex - 1].SetDimension(Math.Round(dimensions[nIndex - 1].m_dDimension + (m_dDimension - value), 2));
                                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].m_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].m_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 = widthTot / pesi * value;
                                        break;
                                    }
                                case MeasureTypes.PERCENTAGE:
                                    {
                                        valueInAbsolute = (value / 100) * widthTot;
                                        break;
                                    }
                            }
                            int indexDimChange = 0;
                            // L'anta modificata non è l'ultima
                            if (nIndex < absoluteValList.Count - 1)
                                indexDimChange = nIndex + 1;
                            // L'anta modificata è l'ultima
                            else if (dimensions.Count > 1)
                                indexDimChange = nIndex - 1;
                            if (value < m_dDimension)
                            {
                                absoluteValList[indexDimChange] = absoluteValList[indexDimChange] + (absoluteValList[nIndex] - valueInAbsolute);
                                absoluteValList[nIndex] = valueInAbsolute;
                            }
                            else
                            {
                                absoluteValList[indexDimChange] = absoluteValList[indexDimChange] - (valueInAbsolute - absoluteValList[nIndex]);
                                absoluteValList[nIndex] = valueInAbsolute;
                            }
                            if (MeasureType.Equals(MeasureTypes.PROPORTIONAL))
                                m_dDimension = value;
                            for (int i = 0; i < absoluteValList.Count; i++)
                            {
                                var item = m_Parent.SashList.ElementAt(i);
                                item.SetDimension(ad.ConvertAbsoluteIn(adList, absoluteValList[i], (MeasureTypes)item.SelMeasureTypeIndex, widthTot));
                            }
                        }
                        foreach(var item in m_Parent.AreaList)
                        {
                            List<AreaDimension> dimList = new List<AreaDimension>();
                            foreach (var itemDim in Parent.SashList)
                                dimList.Add(new AreaDimension(itemDim.dDimension, itemDim.MeasureType, itemDim.Parent));
                            double dim = dDimension;
                            if (!(MeasureType.Equals(MeasureTypes.ABSOLUTE)))
                            {
                                double width = Parent.CalculateWidthSashGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                                dim = ConvertDimension(dimList, MeasureType, MeasureTypes.ABSOLUTE, width, -1);
                            }
                            if (item.AreaList.First() is Split s)
                            {
                                if (s.SplitVertList.Count > 0)
                                {
                                    int indexSash = m_Parent.AreaList.IndexOf(item);
                                    dim = dim - Parent.SashList.ElementAt(indexSash).ElementDimensionList.ElementAt(1).dDimension
                                              - Parent.SashList.ElementAt(indexSash).ElementDimensionList.Last().dDimension;
                                }
                            }
                            item.SearchAreaList(item, dim, "Width");
                        }
                    }
                }
            }
        }

        public int nSashId
        {
            get
            {
                return m_nSashId;
            }
        }

        public Openings OpeningType
        {
            get
            {
                return m_SelOpeningType;
            }
        }

        public List<IdNameStruct> OpeningTypeList
        {
            get
            {
                return m_OpeningTypeList;
            }
        }

        public Openings SelOpeningType
        {
            get
            {
                return m_SelOpeningType;
            }
            set
            {
                m_SelOpeningType = value;
                m_Parent.ClearHardwareOptionList();
                m_Parent.SetFirstHardware();
            }
        }

        public int SelOpeningTypeIndex
        {
            get
            {
                return (int)m_SelOpeningType;
            }
            set
            {
                Openings newOpening = (Openings)value;
                if ((newOpening != Openings.TILTTURN_LEFT && newOpening != Openings.TILTTURN_RIGHT) ||
                    (newOpening == Openings.TILTTURN_LEFT && m_bHasHandle) ||
                    (newOpening == Openings.TILTTURN_RIGHT && m_bHasHandle))
                {
                    m_SelOpeningType = newOpening;
                    m_Parent.ClearHardwareOptionList();
                    m_Parent.RefreshHardwareList();
                    m_Parent.SetFirstHardware();
                }
            }
        }

        public override int SelMeasureTypeIndex
        {
            get
            {
                return (int)SelMeasureType;
            }
            set
            {
                if(SelMeasureType != (MeasureTypes)value)
                {
                    MeasureTypes newType = (MeasureTypes)value;
                    Frame? frame = m_Parent.ParentWindow.AreaList.FirstOrDefault();
                    if (frame != null) 
                    {
                        double widthTot = Parent.CalculateWidthSashGroup(frame!, frame!.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
                        if (Parent.bIsDimensionLight)
                        {
                            for (int i = 0; i < m_Parent.SashList.Count; i++)
                            {
                                if (i == 0)
                                    widthTot = widthTot
                                                   - m_Parent.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
                                                   - m_Parent.SashList.ElementAt(i).ElementDimensionList.Last().dDimension;
                                else
                                    widthTot = widthTot
                                                   - m_Parent.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
                                                   - m_Parent.SashList.ElementAt(i).ElementDimensionList.Last().dDimension
                                                   + m_Parent.SashList.ElementAt(i).ElementDimensionList.Last().dOverlap;
                            }
                        }
                        else
                        {
                            for (int i = 0; i < m_Parent.SashList.Count - 1; i++)
                                widthTot = widthTot + m_Parent.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dOverlap;
                        }
                        AreaDimension ad = new AreaDimension(m_dDimension, SelMeasureType, Parent);
                        List<AreaDimension> newDimensions = new List<AreaDimension>();
                        foreach (var it in m_Parent.SashList)
                            newDimensions.Add(new AreaDimension(it.m_dDimension, it.SelMeasureType, it.Parent));
                        if (newType is MeasureTypes.PROPORTIONAL)
                        {
                            newDimensions = ad.RicalculatePropVal(newDimensions, nSashId - 1, widthTot);
                            for (int i = 0; i < newDimensions.Count; i++)
                                m_Parent.SashList.ElementAt(i).SetDimension(newDimensions.ElementAt(i).dDimension);
                        }
                        else
                            m_dDimension = ad.ConvertDimension(newDimensions, SelMeasureType, newType, widthTot, nSashId - 1);
                        SelMeasureType = (MeasureTypes)value;
                    }
                }
            }
        }

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Metodo per copiare l'intero oggetto
        /// </summary>
        /// <returns></returns>
        public SashDimension Copy()
        {
            SashDimension newSashDim = new SashDimension(m_dDimension, MeasureType, m_Parent, m_nSashId);
            newSashDim.SetMeasureType(MeasureType);
            newSashDim.SetOpeningType(SelOpeningType);
            newSashDim.SetHasHandle(bHasHandle);
            foreach (var item in ElementDimensionList)
            {
                ElementDimension newElementDimension = item.Copy();
                newSashDim.ElementDimensionList.Add(newElementDimension);
            }
            foreach (var item in JointList)
            {
                Joint newJoint = item.Copy();
                newSashDim.JointList.Add(newJoint);
            }
            return newSashDim;
        }

        #endregion Public Methods

        #region Internal Methods

        internal void SetDimensionLight(double Dimension)
        {
            m_dDimension = Dimension;
        }

        internal JsonSashDimension Serialize()
        {
            JsonSashDimension JsonSashDimension = new JsonSashDimension(OpeningType, MeasureType, m_bHasHandle, dDimension, m_nSashId);
            foreach (var Joint in JointList)
                JsonSashDimension.JointList.Add(Joint.Serialize());
            foreach (var Elem in ElementDimensionList)
                JsonSashDimension.ElementDimensionList.Add(Elem.Serialize());
            return JsonSashDimension;
        }

        internal void SetHasHandle(bool value)
        {
            m_bHasHandle = value;
        }

        internal void SetOpeningType(Openings value)
        {
            m_SelOpeningType = value;
        }

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

        //internal void SetSelMeasureType(MeasureTypes value, int indexSash)
        //{
        //    if (SelMeasureType != (MeasureTypes)value)
        //    {
        //        MeasureTypes newType = (MeasureTypes)value;
        //        Frame? frame = m_Parent.ParentWindow.AreaList.FirstOrDefault();
        //        if (frame != null)
        //        {
        //            double widthTot = Parent.CalculateWidthSashGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
        //            if (Parent.bIsDimensionLight)
        //            {
        //                for(int i = 0; i < Parent.SashList.Count; i++)
        //                {
        //                    if (i == 0)
        //                        widthTot = widthTot - Parent.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
        //                                            - Parent.SashList.ElementAt(i).ElementDimensionList.Last().dDimension;
        //                    else
        //                        widthTot = widthTot - Parent.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
        //                                            - Parent.SashList.ElementAt(i).ElementDimensionList.Last().dDimension
        //                                            + Parent.SashList.ElementAt(i).ElementDimensionList.Last().dOverlap;
        //                }
        //            }
        //            else
        //            {
        //                for (int i = 0; i < m_Parent.SashList.Count - 1; i++)
        //                {
        //                    widthTot = widthTot + m_Parent.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dOverlap;
        //                }
        //            }
        //            AreaDimension ad = new AreaDimension(dDimension, SelMeasureType, Parent);
        //            List<AreaDimension> newDimensions = new List<AreaDimension>();
        //            foreach(var item in m_Parent.SashList)
        //            {
        //                newDimensions.Add(new AreaDimension(item.dDimension, item.SelMeasureType, item.Parent));
        //            }
        //            int index = m_Parent.SashList.IndexOf(this);
        //            m_dDimension = ad.ConvertDimension(newDimensions, SelMeasureType, newType, widthTot, indexSash);
        //            SelMeasureType = (MeasureTypes)value;
        //        }
        //    }
        //}

        #endregion Internal Methods

        #region Private Fields

        private bool m_bHasHandle;

        private int m_nSashId;

        private List<IdNameStruct> m_OpeningTypeList = new List<IdNameStruct>
        {
            new IdNameStruct((int)Openings.TURNONLY_LEFT, "A bandiera sinistra"),
            new IdNameStruct((int)Openings.TURNONLY_RIGHT, "A bandiera destra"),
            new IdNameStruct((int)Openings.TILTTURN_LEFT, "Ad anta-ribalta sinistra"),
            new IdNameStruct((int)Openings.TILTTURN_RIGHT, "Ad anta-ribalta destra"),
            new IdNameStruct((int)Openings.TILTONLY_TOP, "Solo verso alto"),
            new IdNameStruct((int)Openings.TILTONLY_BOTTOM, "Solo verso basso"),
            new IdNameStruct((int)Openings.PIVOT, "Pivot"),
            new IdNameStruct((int)Openings.FIXED, "Fissa"),
            new IdNameStruct((int)Openings.COMPLANARSLIDE_LEFT, "Complanare sinistra"),
            new IdNameStruct((int)Openings.COMPLANARSLIDE_RIGHT, "Complanare destra"),
            new IdNameStruct((int)Openings.LIFTSLIDE_LEFT, "Scorrevole sinistra"),
            new IdNameStruct((int)Openings.LIFTSLIDE_RIGHT, "Scorrevole destra")

            //new IdNameStruct((int)Openings.TURNONLY_LEFT, ">"),
            //new IdNameStruct((int)Openings.TURNONLY_RIGHT, "<"),
            //new IdNameStruct((int)Openings.TILTTURN_LEFT, ">*"),
            //new IdNameStruct((int)Openings.TILTTURN_RIGHT, "<*"),
            //new IdNameStruct((int)Openings.TILTONLY_TOP, "˄"),
            //new IdNameStruct((int)Openings.TILTONLY_BOTTOM, "˅"),
            //new IdNameStruct((int)Openings.PIVOT, "◊"),
            //new IdNameStruct((int)Openings.FIXED, "X"),
            //new IdNameStruct((int)Openings.COMPLANARSLIDE_LEFT, "-→"),
            //new IdNameStruct((int)Openings.COMPLANARSLIDE_RIGHT, "←-"),
            //new IdNameStruct((int)Openings.LIFTSLIDE_LEFT, "┌→"),
            //new IdNameStruct((int)Openings.LIFTSLIDE_RIGHT, "←┐")
        };

        // reference
        private Sash m_Parent;

        private List<Joint> m_JointList = new List<Joint>();
        private List<ElementDimension> m_ElementDimensionList = new List<ElementDimension>();
        private Openings m_SelOpeningType;

        #endregion Private Fields

    }
}