using Microsoft.AspNetCore.Components;
using WebWindowComplex.Models;
using static WebWindowComplex.Json.WindowConst;
using static WebWindowComplex.LayoutConst;

namespace WebWindowComplex.Compo
{
    public partial class CardSashGroup
    {
        #region Public Properties

        /// <summary>
        /// Sash corrente rispetto alla lista Sash
        /// </summary>
        [CascadingParameter(Name = "CurrSashGroup")]
        public Sash CurrSashGroup { get; set; } = null!;

        /// <summary>
        /// Livello di accesso (utente base)
        /// </summary>
        [CascadingParameter(Name = "User")]
        public bool User { get; set; } = false!;

        /// <summary>
        /// Evento per cambiare tutti i fill
        /// </summary>
        [Parameter]
        public EventCallback<DataUpdateFrame> EC_UpdateFrame { get; set; }

        /// <summary>
        /// Evento per tornare nella pagine Tree
        /// </summary>
        [Parameter]
        public EventCallback<bool> EC_ReqClose { get; set; }

        /// <summary>
        /// Evento per richiedere reset dizionario Shape
        /// </summary>
        [Parameter]
        public EventCallback<DataUpdateRes> EC_ReqResetDict { get; set; }

        /// <summary>
        /// Evento per richiedere opzioni hardware
        /// </summary>
        [Parameter]
        public EventCallback<Sash> EC_ReqOptionHw { get; set; }

        /// <summary>
        /// Evento per richiedere per la prima volta opzioni hardware
        /// </summary>
        [Parameter]
        public EventCallback<Sash> EC_ReqFirstOptionHw { get; set; }

        /// <summary>
        /// Evento per segnalare aggiornamento
        /// </summary>
        [Parameter]
        public EventCallback<DataUpdateSash> EC_UpdateSashGroup { get; set; }

        /// <summary>
        /// Evento per richiesta profili degli Element
        /// </summary>
        [Parameter]
        public EventCallback<Sash> EC_ReqElement { get; set; }

        /// <summary>
        /// Lista di sash
        /// </summary>
        [CascadingParameter(Name = "SashList")]
        public List<Sash> SashList { get; set; } = null!;

        /// <summary>
        /// Frame corrente
        /// </summary>
        [Parameter]
        public Frame FrameWindow { get; set; } = null!;

        #endregion Public Properties

        #region Protected Properties

        /// <summary>
        /// Selezione quantità di ante
        /// </summary>
        protected int SashQty
        {
            get => CurrSashGroup.nSashQty;
            set
            {
                if (CurrSashGroup.nSashQty != value)
                {
                    CurrSashGroup.nSashQty = value;
                    _ = EC_ReqResetDict.InvokeAsync(new DataUpdateRes { req = LayoutConst.DataAction.ResetDimElem });
                    _ = EC_ReqResetDict.InvokeAsync(new DataUpdateRes { req = LayoutConst.DataAction.ResetHwOpt });
                    var args = new DataUpdateSash()
                    {
                        currSash = CurrSashGroup,
                        svgNoHw = true
                    };
                    _ = EC_UpdateSashGroup.InvokeAsync(args);
                    _ = EC_ReqElement.InvokeAsync(CurrSashGroup);
                    if(CurrSashGroup.SelHardware.Id != "000000")
                        _ = EC_ReqOptionHw.InvokeAsync(CurrSashGroup);
                }
            }
        }

        /// <summary>
        /// Selezione quantità bottom rail
        /// </summary>
        protected int SashBottomRailQty
        {
            get => CurrSashGroup.SashBottomRailQty;
            set
            {
                if (CurrSashGroup.SashBottomRailQty != value)
                {
                    CurrSashGroup.SashBottomRailQty = value;
                    if (CurrSashGroup.SashBottomRailQty > 0)
                        CurrSashGroup.SetSashBottomRail(true);
                    else
                        CurrSashGroup.SetSashBottomRail(false);
                    var args = new DataUpdateSash()
                    {
                        currSash = CurrSashGroup
                    };
                    _ = EC_UpdateSashGroup.InvokeAsync(args);
                }
            }
        }

        /// <summary>
        /// Selezione tipo di orientamento della sash
        /// </summary>
        protected int OrientationSashTypeIndex
        {
            get => CurrSashGroup.SelOrientationSashTypeIndex;
            set
            {
                if (CurrSashGroup.SelOrientationSashTypeIndex != value)
                {
                    CurrSashGroup.SelOrientationSashTypeIndex = value;
                    var args = new DataUpdateSash()
                    {
                        currSash = CurrSashGroup
                    };
                    _ = EC_UpdateSashGroup.InvokeAsync(args);
                }
            }
        }

        /// <summary>
        /// Selezione famiglia hardware
        /// </summary>
        protected string FamilyHardware
        {
            get => CurrSashGroup.SelFamilyHardware;
            set
            {
                if (CurrSashGroup.SelFamilyHardware != value)
                {
                    CurrSashGroup.SelFamilyHardware = value;
                    var args = new DataUpdateSash()
                    {
                        currSash = CurrSashGroup,
                        svgNoHw = true
                    };
                    _ = EC_UpdateSashGroup.InvokeAsync(args);
                    _ = EC_ReqResetDict.InvokeAsync(new DataUpdateRes { req = DataAction.ResetHwOpt});
                    _ = EC_ReqOptionHw.InvokeAsync(CurrSashGroup);
                }
            }
        }

        /// <summary>
        /// Selezione hardware
        /// </summary>
        protected string SelHwType
        {
            get => CurrSashGroup.SelHardwareFromId;
            set
            {
                if (CurrSashGroup.SelHardwareFromId != value)
                {
                    CurrSashGroup.SelHardwareFromId = value;
                    var args = new DataUpdateSash
                    {
                        currSash = CurrSashGroup
                    };
                    _ = EC_UpdateSashGroup.InvokeAsync(args);
                    _ = EC_ReqOptionHw.InvokeAsync(CurrSashGroup);
                }
            }
        }

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Metodo per rimuovere area corrente
        /// </summary>
        /// <returns></returns>
        protected async Task RemoveArea()
        {
            CurrSashGroup.Remove();
            FrameWindow.SetSelThresholdFromName(FrameWindow.ThresholdList.FirstOrDefault(x => x.Name != "Threshold")?.Name);
            var args = new DataUpdateFrame()
            {
                currFrame = FrameWindow,
                groupIdDelete = CurrSashGroup.GroupId
            };
            // richiesta reset dict shape
            await EC_ReqResetDict.InvokeAsync(new DataUpdateRes { req=DataAction.ResetDictShape});
            await EC_ReqResetDict.InvokeAsync(new DataUpdateRes { req = DataAction.ResetDimElem});
            await EC_UpdateFrame.InvokeAsync(args);
            await EC_ReqClose.InvokeAsync(true);
        }

        /// <summary>
        /// Metodo per cambiare dimensione solo luce
        /// </summary>
        /// <returns></returns>
        private Task ChangeTypeDimension(bool type)
        {
            if(CurrSashGroup.bIsDimensionLight != type)
            {
                CurrSashGroup.bIsDimensionLight = type;
                foreach (var CurrSashDim in CurrSashGroup.SashList)
                {
                    if (CurrSashDim.SelMeasureType is MeasureTypes.ABSOLUTE)
                    {
                        if (CurrSashGroup.bIsDimensionLight)
                        {
                            CurrSashDim.SetDimensionLight(CurrSashDim.dDimension -
                                                          CurrSashDim.ElementDimensionList.ElementAt(1).dDimension -
                                                          CurrSashDim.ElementDimensionList.Last().dDimension);
                        }
                        else
                        {
                            CurrSashDim.SetDimensionLight(CurrSashDim.dDimension +
                                                          CurrSashDim.ElementDimensionList.ElementAt(1).dDimension +
                                                          CurrSashDim.ElementDimensionList.Last().dDimension);
                        }
                    }
                }
            }
            DataUpdateSash args = new DataUpdateSash()
            {
                currSash = CurrSashGroup,
                noSvg = false
            };
            return EC_UpdateSashGroup.InvokeAsync(args);
        }

        /// <summary>
        /// Metodo per scegliere tipo di misura
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        protected Task SetMeasureType(MeasureTypes type)
        {
            //isOpen = !isOpen;
            for (int i = 0; i < CurrSashGroup.SashList.Count; i++)
            {
                CurrSashGroup.SashList.ElementAt(i).SetSelMeasureType(type, i);
            }
            var args = new DataUpdateSash { currSash = CurrSashGroup, noSvg = true };
            return EC_UpdateSashGroup.InvokeAsync(args);
        }

        /// <summary>
        /// Metodo per aggiornare la sash dimension 
        /// </summary>
        /// <param name="updateSD"></param>
        /// <returns></returns>
        protected async Task UpdateSashDimension(SashDimension updateSD)
        {
            _ = EC_ReqResetDict.InvokeAsync(new DataUpdateRes { req = LayoutConst.DataAction.ResetDimElem });
            var currRec = CurrSashGroup.SashList.First(x => x.nSashId == updateSD.nSashId);
            if(currRec != null)
            {
                currRec = updateSD;
                var args = new DataUpdateSash
                {
                    currSash = CurrSashGroup
                };
                await EC_ReqElement.InvokeAsync(CurrSashGroup);
                await EC_UpdateSashGroup.InvokeAsync(args);
            }
        }

        /// <summary>
        /// Metodo per aggiornare sash group
        /// </summary>
        /// <param name="updateS"></param>
        /// <returns></returns>
        protected async Task UpdateSash(DataUpdateProfile updateS)
        {
            _ = EC_ReqResetDict.InvokeAsync(new DataUpdateRes { req = LayoutConst.DataAction.ResetDimElem });
            if (updateS != null)
            {
                CurrSashGroup = updateS.sash;
                var args = new DataUpdateSash
                {
                    currSash = CurrSashGroup
                };
                if (updateS.reqProfile)
                    await EC_ReqElement.InvokeAsync(CurrSashGroup);
                await EC_UpdateSashGroup.InvokeAsync(args);
            }
        }

        /// <summary>
        /// Metodo per aggiornare sash group
        /// </summary>
        /// <param name="updRec"></param>
        /// <returns></returns>
        protected async Task UpdateBottomRail(DataBottomRail updRec)
        {
            if (updRec.sash != null)
            {
                CurrSashGroup = updRec.sash;
                var args = new DataUpdateSash
                {
                    currSash = CurrSashGroup
                };
                await EC_UpdateSashGroup.InvokeAsync(args);
            }
        }

        /// <summary>
        /// Metodo per aggiornare bottom rail
        /// </summary>
        /// <param name="updRec"></param>
        /// <returns></returns>
        protected async Task UpdateBottomRail(ElementDimension updRec)
        {
            var currRec = CurrSashGroup.BottomRailElemDimList.FirstOrDefault(x => x.ParentArea == updRec.ParentArea && x.nIndex == updRec.nIndex);
            if (currRec != null)
            {
                currRec = updRec;
                var args = new DataUpdateSash
                {
                    currSash = CurrSashGroup
                };
                await EC_UpdateSashGroup.InvokeAsync(args);
            }
        }

        /// <summary>
        /// Metodo per resettare dizionario richiesto
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        protected Task ResetDict(DataUpdateRes args)
        {
            return EC_ReqResetDict.InvokeAsync(args);
        }

        #endregion Protected Methods

        #region Private Methods

        private bool editMode = false;
        private List<int> currSashDimEdit = new List<int>();
        private void EditView(DataChangeMode args)
        {
            //editMode = args.Edit;
            if(args.IndexSashEdit != -1)
                currSashDimEdit.Add(args.IndexSashEdit);
            if (args.IndexSashClose != -1)
                currSashDimEdit.Remove(args.IndexSashClose);
        }

        /// <summary>
        /// Sollevo evento per tornare alla pagina Tree
        /// </summary>
        private void ReqClose()
        {
            _ = EC_ReqClose.InvokeAsync(true);
        }

        /// <summary>
        /// Aggiornamento opzioni hardware
        /// </summary>
        /// <param name="argsHw"></param>
        /// <returns></returns>
        private async Task UpdateOpt(DataUpdateHwOption argsHw)
        {
            AGBOptionCombo AGBOptCombo = argsHw.AGBOptCombo;
            AGBOptionText AGBOptText = argsHw.AGBOptText;
            if (AGBOptCombo != null)
            {
                // cerco il record
                var currRec = CurrSashGroup.HwOptionList.FirstOrDefault(x => x.sName == AGBOptCombo.sName && x.sDescription == AGBOptCombo.sDescription);
                currRec = AGBOptCombo;
            }
            else if(AGBOptText != null)
            {
                // cerco il record
                var currRec = CurrSashGroup.HwOptionList.FirstOrDefault(x => x.sName == AGBOptText.sName && x.sDescription == AGBOptText.sDescription);
                currRec = AGBOptText;
            }
            if(AGBOptCombo != null || AGBOptText != null)
            {
                var args = new DataUpdateSash
                {
                    currSash = CurrSashGroup
                };
                await EC_UpdateSashGroup.InvokeAsync(args);
                await EC_ReqOptionHw.InvokeAsync(CurrSashGroup);
            }
        }

        /// <summary>
        /// Prima chiamata hw option list
        /// </summary>
        /// <returns></returns>
        private Task FirstHwOptionList()
        {
            var args = new DataUpdateSash { currSash = CurrSashGroup };
            return EC_ReqFirstOptionHw.InvokeAsync(CurrSashGroup);
        }

        //private bool isOpen = false;
        //private void ToggleDropdown()
        //{
        //    isOpen = !isOpen;
        //}

        private string AreaSashCss(int i)
        {
            if (i == 0)
                return "row mt-4";
            else
                return "row mt-2";
        }
        
        #endregion Private Methods
    }

    public class DataUpdateSash
    {
        public Sash currSash { get; set; } = null!;
        public bool svgNoHw { get; set; } = false;
        public bool noSvg { get; set; } = false;
    }

    public class DataUpdateRes
    {
        public DataAction req { get; set; } = DataAction.None;
    }
}