using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Reflection.Metadata;
using System.Runtime.InteropServices;
using WebWindowComplex.DTO;
using WebWindowComplex.Json;
using static WebWindowComplex.Json.WindowConst;

namespace WebWindowComplex
{
    public partial class TableComp : IDisposable
    {
        #region Public Properties

        [Parameter]
        public string CssSvg { get; set; } = "responsive-svg";

        [Parameter]
        public EventCallback<bool> EC_OnClose { get; set; }

        [Parameter]
        public EventCallback<TemplateSelectDTO> EC_OnSelectedTemplate { get; set; }

        [Parameter]
        public EventCallback<Dictionary<string, string>> EC_OnUpdate { get; set; }

        [Parameter]
        public Template IN_SelTemplate
        {
            get => m_SelTemplate;
            set
            {
                // Se non ho ancora selezionato template oppure se cambio template di selezione
                if (value != null && (m_SelTemplate == null || (m_SelTemplate != null && value.nIndex != m_SelTemplate.nIndex)) && !string.IsNullOrEmpty(value.JWD))
                {
                    m_SelTemplate = value;
                    JsonWindow WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(m_SelTemplate.JWD, new PolymorphicJsonConverter()) ?? new JsonWindow("");
                    if (m_CurrWindow != null)
                    {
                        m_CurrWindow.OnPreview -= M_CurrWindow_OnPreview;
                        m_CurrWindow = null;
                    }
                    m_CurrWindow = WindowFromJson.Deserialize();
                    m_CurrWindow.OnPreview += M_CurrWindow_OnPreview;
                    // recupero dimensioni Frame e Joint Frame della finestra precedente
                    if (m_PreviousWindow != null)
                    {
                        for (int i = 0; i < 2; i++)
                            m_CurrWindow.AreaList[0].DimensionList[i] = m_PreviousWindow.AreaList[0].DimensionList[i];
                        for (int i = 0; i < 4; i++)
                            m_CurrWindow.AreaList[0].JointList[i] = m_PreviousWindow.AreaList[0].JointList[i];
                    }
                }
                if (m_CurrWindow != null)
                {
                    m_maxCol = 0;
                    m_maxRow = 0;
                    m_FillList = new List<Fill>();
                    m_SashList = new List<Sash>();
                    m_SplitList = new List<Split>();
                    m_SplitParentList = new List<SplitParent>();
                    m_SplittedList = new List<Splitted>();
                    m_ItemTableList = new List<ItemTable>();
                    CreateWindowsList(m_CurrWindow.AreaList[0], false);
                    CreateElementTable(m_CurrWindow.AreaList[0], 1, 1, 1, 1);
                }
            }
        }

        [Parameter]
        public List<TemplateSelectDTO> IN_TemplateDTOList { get; set; } = null!;

        [Parameter]
        public string LiveSVG
        {
            get => m_SelSVG;
            set => m_SelSVG = value;
        }

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            if (m_CurrWindow != null)
            {
                m_CurrWindow.OnPreview -= M_CurrWindow_OnPreview;
                m_CurrWindow = null;
            }
        }

        #endregion Public Methods

        #region Protected Enums

        protected enum CompileStep
        {
            Template = 0,
            Gerarchia = 1,
            Frame,
            Split,
            Sash,
            Fill,
            General
        }

        protected enum ColorWindow
        {
            Bianco = 0,
            Grigio = 1,
            Tortora,
            Blu,
            Verde,
            Nero
        }

        #endregion Protected Enums

        #region Protected Properties

        protected Frame FrameWindow
        {
            get => m_Frame;
            set => m_Frame = value;
        }

        protected string m_SelSVG { get; set; } = "";

        /// <summary>
        /// Componente SVG da mostrare
        /// </summary>
        protected MarkupString outSvg
        {
            get
            {
                // aggiunta gestione classe svg per posizionamento con costraints
                var newSvg = LiveSVG.Replace("<svg", $"<svg class=\"{CssSvg}\"");
                return (MarkupString)newSvg;
            }
        }

        protected List<Sash> SashList
        {
            get => m_SashList;
        }
        protected List<Split> SplitList
        {
            get => m_SplitList;
        }
        protected List<Fill> FillList
        {
            get => m_FillList;
        }
        protected List<Splitted> SplittedList
        {
            get => m_SplittedList;
        }
        protected List<SplitParent> SplitParentList
        {
            get => m_SplitParentList;
        }
        protected List<ItemTable> ItemTableList
        {
            get => m_ItemTableList;
        }

        protected TemplateSelectDTO? SelTemplateDTO { get; set; } = null;

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Metodo per la scelta della maniglia univoca
        /// </summary>
        /// <param name="sashDim"></param>
        /// <returns></returns>
        protected async Task changeHandle(SashDimension sashDim)
        {
            //if(m_SashList[0].AreaList.Count < 3)
            //{
            foreach (SashDimension item in SashList[0].SashList)
            {
                if (item.Equals(sashDim))
                {
                    item.bHasHandle = true;
                }
                else
                {
                    item.bHasHandle = false;
                }
            }
            //}
            await Task.Delay(1);
        }

        // Ancora da fare...
        protected async Task DoClose()
        {
            await EC_OnClose.InvokeAsync(true);
        }

        /// <summary>
        /// Anteprima SVG
        /// </summary>
        /// <returns></returns>
        protected async Task DoPreviewSvg()
        {
            if (m_CurrWindow != null)
            {
                var CurrJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize(), Formatting.Indented);
                Dictionary<string, string> Args = new Dictionary<string, string>();
                Args.Add("Jwd", CurrJwd);
                Args.Add("Mode", 1.ToString());
                await EC_OnUpdate.InvokeAsync(Args);
            }
        }

        /// <summary>
        /// Metodo di reset dei dati a quelli del template
        /// </summary>
        protected async Task DoReset()
        {
            JsonWindow WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(m_SelTemplate.JWD, new PolymorphicJsonConverter()) ?? new JsonWindow("");
            if (m_CurrWindow != null)
            {
                m_CurrWindow.OnPreview -= M_CurrWindow_OnPreview;
                m_CurrWindow = null;
            }
            m_CurrWindow = WindowFromJson.Deserialize();
            m_CurrWindow.OnPreview += M_CurrWindow_OnPreview;
            m_FillList = new List<Fill>();
            m_SashList = new List<Sash>();
            m_SplitList = new List<Split>();
            m_SplittedList = new List<Splitted>();
            m_SplitParentList = new List<SplitParent>();
            m_ItemTableList = new List<ItemTable>();
            m_maxCol = 0;
            m_maxRow = 0;
            // popolo le liste Fill, Sash e Split
            CreateWindowsList(m_CurrWindow.AreaList[0], false);
            CreateElementTable(m_CurrWindow.AreaList[0], 1, 1, 1, 1);
            //currSash = -1;
            await DoPreviewSvg();
        }

        // Ancora da fare..
        protected async Task DoSave()
        {
            //manca salvataggio JWD
            await EC_OnClose.InvokeAsync(true);
        }

        /// <summary>
        /// Selezione del template
        /// </summary>
        /// <param name="newSel"> template selezionato</param>
        protected async void DoSelect(TemplateSelectDTO newSel)
        {
            SelTemplateDTO = newSel;
            //DoSelectAndPreview(CompileStep.Frame);
            await EC_OnSelectedTemplate.InvokeAsync(newSel);
        }

        /// <summary>
        /// Metodo per cambiare step e aggiornare preview svg
        /// </summary>
        /// <param name="newStep"> step successivo</param>
        protected async void NextStepAndPreview(CompileStep newStep, int Index = -1)
        {
            currStep = newStep;
            if (newStep == CompileStep.Sash)
                currSash = Index;
            else
                currSash = -1;
            await DoPreviewSvg();
        }

        protected void CreateWindowsList(Area node, bool IntoSash)
        {
            if (node != null)
            {
                if (node.ParentArea is Sash || IntoSash == true)
                    IntoSash = true;
                switch (node.AreaType)
                {
                    case AreaTypes.FRAME:
                        {
                            FrameWindow = (Frame)node;
                            break;
                        }
                    case AreaTypes.SASH:
                        {
                            m_SashList.Add((Sash)node);
                            break;
                        }
                    case AreaTypes.FILL:
                        {
                            m_FillList.Add((Fill)node);
                            break;
                        }
                    case AreaTypes.SPLIT:
                        {
                            m_SplitList.Add((Split)node);
                            break;
                        }
                    case AreaTypes.SPLITTED:
                        {
                            if (node.ParentArea is Split && !IntoSash && node.AreaList[0] is Fill)
                            {
                                m_SplittedList.Add((Splitted)node);
                            }
                            break;
                        }
                }
                foreach (var item in node.AreaList)
                {
                    CreateWindowsList(item, IntoSash);
                }
            }
        }

        protected void CreateElementTable(Area node, int row, int col, int maxRow, int maxCol)
        {
            if (node != null)
            {
                switch (node.AreaType)
                {
                    case AreaTypes.FRAME:
                        {
                            if(node.AreaList.Count >= 1)
                                ItemTableList.Add(new ItemTable(AreaTypes.FRAME, "FR", row, col, -1, node.AreaList.Count));
                            else
                                ItemTableList.Add(new ItemTable(AreaTypes.FRAME, "FR", row, col, -1, 0));
                            row++;
                            col++;
                            maxRow++;
                            maxCol++;
                            break;
                        }
                    case AreaTypes.SASH:
                        {
                            // Se ha fratelli
                            if ((node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1) ||
                                (node.ParentArea != null && node.ParentArea.AreaList.Count > 1))
                            {
                                for(int i = 0; i < SashList.Count; i++)
                                {
                                    if (SashList[i].Equals(node))
                                    {
                                        // Se il nodo ha figli, salvo il numero nell'oggetto
                                        if(node.AreaList.Count >= 1)
                                            ItemTableList.Add(new ItemTable(AreaTypes.SASH, "SH", maxRow, col, i, node.AreaList.Count));
                                        else
                                            ItemTableList.Add(new ItemTable(AreaTypes.SASH, "SH", maxRow, col, i, 0));
                                    }
                                }
                                maxCol++;
                            }
                            else
                            {
                                // Se il nodo ha figli, salvo il numero nell'oggetto
                                if (node.AreaList.Count >= 1)
                                    ItemTableList.Add(new ItemTable(AreaTypes.SASH, "SH", row, col, 0, node.AreaList.Count));
                                else
                                    ItemTableList.Add(new ItemTable(AreaTypes.SASH, "SH", row, col, 0, 0));
                                maxCol++;
                            }
                            row++;
                            col++;
                            maxRow++;
                            break;
                        }
                    case AreaTypes.FILL:
                        {
                            if((node.ParentArea.AreaList.Count > 1 && node.ParentArea.AreaList[0].Equals(node)) ||
                                (node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1 && node.ParentArea.ParentArea.AreaList[0].AreaList[0].Equals(node)))
                                maxCol++;
                            ItemTableList.Add(new ItemTable(AreaTypes.FILL, "FL", maxRow, col, -1, 0));
                            row++;
                            col++;
                            maxRow++;
                            break;
                        }
                    case AreaTypes.SPLIT:
                        {
                            if (node.ParentArea.AreaList.Count > 1 || (node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1))
                            {
                                if (node.ParentArea.AreaList[0].Equals(node) || node.ParentArea.ParentArea.AreaList[0].Equals(node))
                                    maxCol ++;
                                if (node.AreaList.Count >= 1 || node.AreaList.Count >= 1)
                                    ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP", maxRow, col, -1, node.AreaList.Count));
                                else
                                    ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP", maxRow, col, -1, 0));
                            }
                            else
                            {
                                if (node.AreaList.Count >= 1 || node.AreaList.Count >= 1)
                                    ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP", row, col, -1, node.AreaList.Count));
                                else
                                    ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP", row, col, -1, 0));
                                maxCol++;
                            }
                            row++;
                            col++;
                            maxRow++;
                            break;
                        }
                    case AreaTypes.SPLITTED:
                        {
                            break;
                        }
                }
                foreach (var item in node.AreaList)
                {
                    if (maxRow < m_maxRow)
                        CreateElementTable(item, row, col, m_maxRow, maxCol);
                    else
                        CreateElementTable(item, row, col, maxRow, maxCol);
                }
            }
            if(maxCol> m_maxCol)
            {
                m_maxCol = maxCol;
            }
            if (maxRow > m_maxRow)
            {
                m_maxRow = maxRow;
            }
        }
        
        private string fillTable(int row, int col)
        {
            List<ItemTable> itemSameCol = new List<ItemTable>();
            for(int k = 0; k < row; k++)
            {
                if(ItemTableList[k].Col == col+1)
                {
                    itemSameCol.Add(ItemTableList[k]);
                }
                continue;
            }
            int numItemNextCol = 0;
            for (int k = 0; k < row; k++)
            {
                if (ItemTableList[k].Row <= row && ItemTableList[k].Col == col + 2)
                {
                    numItemNextCol++;
                }
                continue;
            }
            if (itemSameCol.Count > 1)
            {
                for (int i = 0; i <= itemSameCol.Count - 2; i++)
                {
                    if (itemSameCol[i].NumChild > 0)
                        numItemNextCol = numItemNextCol - itemSameCol[i].NumChild;
                }
            }
            if (itemSameCol.Count > 0)
            {
                // Sono alla riga successiva di un elemento e nella stessa colonna
                if(itemSameCol.Last().Row == row)
                {
                    // se ha un solo figlio
                    if(itemSameCol.Last().NumChild == 1)
                    {
                        return "└";
                    }
                    else if (itemSameCol.Last().NumChild == 0)
                    {
                        return " ";
                    }
                    else
                    {
                        return "├";
                    }
                }
                // Non solo alla riga successiva
                else
                {
                    // se ha un solo figlio
                    if(itemSameCol.Last().NumChild == 1)
                    {
                        return " ";
                    }
                    else if (col + 2 <= m_maxCol && ItemTableList[row].Col == col + 2)
                    {
                        if (numItemNextCol < itemSameCol.Last().NumChild && numItemNextCol != (itemSameCol.Last().NumChild - 1))
                        {
                            return "├";
                        }
                        return "└";
                    }
                    else if (numItemNextCol < itemSameCol.Last().NumChild)
                    {
                        return "│";
                    }
                    else
                    {
                        return " ";
                    }
                }
            }
            else
            {
                return " ";
            }
        }

        /// <summary>
        /// Metodo per settare tutti i Joints di Frame o Sash come ANGLED o FULL_H o FULL_V
        /// </summary>
        /// <param name="int_type"> tipo di giunzione (ANGLED o FULL_H o FULL_V)</param>
        /// <param name="int_place"> oggetto a cui essere applicato (Frame o Sash)</param>
        /// <returns></returns>
        private async Task AllJointsFrame(int int_type, int int_place)
        {
            Joints type = Joints.ANGLED;
            if (int_type == 2)
            {
                type = Joints.FULL_H;
            }
            else if (int_type == 3)
            {
                type = Joints.FULL_V;
            }
            if (int_place == 0)
            {
                foreach (Joint joint in FrameWindow.JointList)
                {
                    joint.SetSelJointType(type);
                }
            }
            else if (int_place == 1)
            {
                foreach (Joint joint in m_SashList[0].JointList)
                {
                    joint.SetSelJointType(type);
                }
            }
            await DoPreviewSvg();
        }

        /// <summary>
        /// Metodo per settare tutti i Joints di Frame o Sash come ANGLED o FULL_H o FULL_V
        /// </summary>
        /// <param name="int_type"> tipo di giunzione (ANGLED o FULL_H o FULL_V)</param>
        /// <param name="int_place"> oggetto a cui essere applicato (Frame o Sash)</param>
        /// <returns></returns>
        private async Task AllFill(int int_type)
        {
            FillTypes type = FillTypes.GLASS;
            if (int_type == 2)
            {
                type = FillTypes.WOOD;
            }
            foreach (Fill currFill in m_FillList)
            {
                currFill.SetFillType(type);
            }
            await DoPreviewSvg();
        }

        private void CopyContent(Sash sashItem, int IndexCopy, int IndexModify)
        {
            // Rimuovo riempimento da anta selezionata
            sashItem.AreaList[IndexModify].AreaList.RemoveAt(0);
            // Creo la copia dell'anta scelta
            Area a = sashItem.AreaList[IndexCopy-1].AreaList[0].Copy();
            // Aggiungo copia all'anta selezionata
            sashItem.AreaList[IndexModify].AreaList.Add(a);
        }

        private async Task SwapTwoAree(Area currArea)
        {
            currArea.SwapAree();
            await DoPreviewSvg();
        }


        #endregion Protected Methods

        #region Private Fields

        private CompileStep currStep = CompileStep.Template;

        private int currSash = -1;

        private ColorWindow currColorWin = ColorWindow.Bianco;

        private Frame m_Frame;

        private List<Sash> m_SashList = new List<Sash>();

        private List<Split> m_SplitList = new List<Split>();

        private List<Fill> m_FillList = new List<Fill>();

        private List<Splitted> m_SplittedList = new List<Splitted>();

        private List<ItemTable> m_ItemTableList = new List<ItemTable>();

        private List<SplitParent> m_SplitParentList = new List<SplitParent>();

        private int m_maxCol = 0;
        private int m_maxRow = 0;

        private enum positionJoints
        {
            BL = 0, // Bottom Left
            BR = 1, // Bottom Right
            TR,   // Top Right
            TL    // Top Left
        }

        #endregion Private Fields

        #region Private Properties

        private Window? m_CurrWindow { get; set; } = null;

        private Window? m_PreviousWindow { get; set; } = null;

        private Template m_SelTemplate { get; set; } = null!;

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Metodo per andare allo step successivo
        /// </summary>
        /// <param name="newStep"> step successivo</param>
        private void AdvStep(CompileStep newStep)
        {
            currStep = newStep;
            currSash = -1;
        }


        private void ChangeColorWindow(ColorWindow newColorWin)
        {
            currColorWin = newColorWin;
        }

        private void M_CurrWindow_OnPreview(object? sender, OnPreviewEventArgs e)
        {
            Dictionary<string, string> Args = new Dictionary<string, string>();
            Args.Add("Jwd", e.sJwd);
            Args.Add("Mode", 1.ToString());
            EC_OnUpdate.InvokeAsync(Args);
        }

        /// <summary>
        /// Calcola il css del tab selezionato
        /// </summary>
        /// <param name="testStep"></param>
        /// <returns></returns>
        private string tabNavCss(CompileStep testStep, int Index = -1)
        {
            if (testStep == CompileStep.Sash)
            {
                if ((currSash == 0 && Index == 0) || (currSash == 1 && Index == 1))
                {
                    return "nav-link active fw-bold";
                }
                else
                {
                    return "nav-link text-secondary";
                }
            }
            return (testStep == currStep) ? "nav-link active fw-bold" : "nav-link text-secondary";
        }

        private string buttonCss(ColorWindow testColor)
        {
            return testColor.Equals(currColorWin) ? "btn btn-outline-secondary active" : "btn btn-outline-secondary";
        }

        /// <summary>
        /// Calcola larghezza colonna da mostrare
        /// </summary>
        /// <returns></returns>
        private string mainCss()
        {
            return (currStep == CompileStep.Template) ? "col-12" : "col-6";
        }

        #endregion Private Methods
    }
}