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

namespace WebWindowComplex.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;
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        public int nSplitQtyHoriz
        {
            get
            {
                return m_SplitHorizList.Count > 0 ? m_SplitHorizList.Count - 1 : 0;
            }
            set
            {
                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
                {
                    // Ricalcolo dimensioni aggiungendo split
                    if (value > m_SplitHorizList.Count - 1)
                    {
                        // recupero larghezza ultimo
                        double dLastDimension = 100;
                        double dNewDimension = 100;
                        if (m_SplitHorizList.Count > 0)
                        {
                            dLastDimension = m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension;
                            dNewDimension = dLastDimension / (value + 1 - nSplitQtyHoriz);
                            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, 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);
                    }
                }
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        public int nSplitQtyVert
        {
            get
            {
                return m_SplitVertList.Count > 0 ? m_SplitVertList.Count - 1 : 0;
            }
            set
            {
                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
                {
                    // Ricalcolo dimensioni aggiungendo split
                    if (value > m_SplitVertList.Count - 1)
                    {
                        // recupero larghezza ultimo
                        double dLastDimension = 100;
                        double dNewDimension = 100;
                        if (m_SplitVertList.Count > 0)
                        {
                            dLastDimension = m_SplitVertList[m_SplitVertList.Count - 1].dDimension;
                            dNewDimension = dLastDimension / (value + 1 - nSplitQtyVert);
                            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, true, this, true));
                    }
                    else if (value == 0)
                    {
                        m_SplitVertList.RemoveAt(1);
                        m_SplitVertList.RemoveAt(0);
                    }
                    // Ricalcolo dimensioni rimuovendo split
                    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);
                    }
                }
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        public int SelSplitShapeIndex
        {
            get
            {
                //return IdNameStruct.IndFromId((int)m_SelSplitShape, m_SplitShapeList);
                return (int)m_SelSplitShape;
            }
            set
            {
                //m_SelSplitShape = (SplitShapes)IdNameStruct.IdFromInd(value, m_SplitShapeList);
                m_SelSplitShape = (SplitShapes)value;
                // Cancello elementi nello split e azzero quantità orizzontale e verticale
                AreaList.Clear();
                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);
                }
                // 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);
                }
                m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
            }
        }

        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);
            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, 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, 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;
        }

        #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>();

        #endregion Private Fields
    }
}