using GPW.CORE.Data.DbModels;
using GPW.CORE.Smart.Data;
using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using NLog;
using System.Diagnostics;

namespace GPW.CORE.Smart.Components.Compo
{
    public partial class RegAttEditor
    {
        #region Public Properties

        [Parameter]
        public RegAttivitaModel? CurrRecord
        {
            get => currRecord;
            set => currRecord = value;
        }

        public string gruppoSel
        {
            get
            {
                return _gruppoSel;
            }
            set
            {
                _gruppoSel = value;
                if (!vetoUpd)
                {
                    var pUpd = Task.Run(async () => await ReloadData(true, true));
                    pUpd.Wait();
                }
            }
        }

        public int idxProj
        {
            get
            {
                return _idxProj;
            }
            set
            {
                _idxProj = value;
                if (!vetoUpd)
                {
                    var pUpd = Task.Run(async () => await ReloadData(false, true));
                    pUpd.Wait();
                }
            }
        }

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

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

        #endregion Public Properties

        #region Protected Fields

        protected string _gruppoSel = "";

        protected int _idxProj = 0;

        protected bool vetoUpd = false;

        #endregion Protected Fields

        #region Protected Properties

        [Inject]
        protected CoreSmartDataService CDService { get; set; } = null!;

        /// <summary>
        /// Wrapper salvataggio in MServ
        /// </summary>
        protected RegAttivitaModel? currRecord
        {
            get => AppMServ.recordRA;
            set => AppMServ.recordRA = value;
        }

        protected List<AnagFasiModel> fasiList { get; set; } = new List<AnagFasiModel>();

        protected List<AnagGruppiModel> gruppiList { get; set; } = new List<AnagGruppiModel>();

        protected int idxFase
        {
            get
            {
                int answ = 0;
                if (CurrRecord != null)
                {
                    answ = CurrRecord.IdxFase;
                }
                return answ;
            }
            set
            {
                if (CurrRecord != null)
                {
                    CurrRecord.IdxFase = value;
                }
            }
        }

        protected List<AnagProgettiModel> projList { get; set; } = new List<AnagProgettiModel>();

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Salvo in MService record clonato
        /// </summary>
        protected async void DoClone()
        {
            if (CurrRecord != null)
            {
                var newData = CurrRecord.Clone();
                newData.IdxRa = 0;
                AppMServ.clonedRA = newData;
                await ItemReset.InvokeAsync(true);
            }
        }

        /// <summary>
        /// Elimino record
        /// </summary>
        protected async void DoDelete()
        {
            // chiedo verifica
            if (!await JSRuntime.InvokeAsync<bool>("confirm", "Sicuro di voler eliminare il record selezionato??"))
                return;

            if (CurrRecord != null)
            {
                // aggiorno
                await CDService.RegAttDelete(CurrRecord);
                // registro fatto
                await ItemUpdated.InvokeAsync(true);
            }
        }

        /// <summary>
        /// Indico item selezionato
        /// </summary>
        protected async void DoReset()
        {
            await ItemReset.InvokeAsync(true);
        }

        /// <summary>
        /// Aggiorno e riporto update
        /// </summary>
        protected async void DoUpdate()
        {
            arrotondaMinuti();
            // aggiorno
            if (CurrRecord != null)
            {
                // controllo IdxDipendente
                if (CurrRecord.IdxDipendente == 0)
                {
                    CurrRecord.IdxDipendente = AppMServ.IdxDipendente;
                }

                // prearo lista inserimento
                List<RegAttivitaModel> data2ins = new List<RegAttivitaModel>();

                // se inizio/fine stesso giorno processo
                if (CurrRecord.Fine.Date.Equals(CurrRecord.Inizio.Date))
                {
                    data2ins.Add(CurrRecord);
                }
                // in caso di eventuale supero della mezzanotte --> chiedo se si vuole split su 2 attivit�...
                else
                {
                    bool doSplit = await JSRuntime.InvokeAsync<bool>("confirm", "L'attivit� si protrae su pi� giorni, vuoi suddividere in record per ogni giornata?");
                    // chiedo verifica x splittare in N+1 periodi (N = giorni)
                    if (doSplit)
                    {
                        RegAttivitaModel currRA = CurrRecord.Clone() as RegAttivitaModel;
                        // primo record � inizio --> mezzanote
                        DateTime lastInizio = currRA.Inizio;
                        DateTime lastFine = currRA.Inizio.Date.AddDays(1);
                        currRA.Fine = lastFine;
                        data2ins.Add(currRA);
                        // calcolo i gg
                        int numGG = CurrRecord.Fine.Date.Subtract(CurrRecord.Inizio.Date).Days;
                        // ciclo
                        for (int i = 0; i < numGG; i++)
                        {
                            // splitto... inizio = fine + 1 sec...
                            currRA = CurrRecord.Clone() as RegAttivitaModel;
                            currRA.Inizio = lastFine;
                            // porto avanti ultima fine...
                            lastFine = lastFine.AddDays(1);
                            currRA.Fine = currRA.Fine > lastFine ? lastFine : currRA.Fine;
                            data2ins.Add(currRA);
                        }
                    }
                    else
                    {
                        data2ins.Add(CurrRecord);
                    }
                }
                // ciclo x inserire
                foreach (var item in data2ins)
                {
                    await CDService.RegAttUpdate(item);
                }
            }
            // resetto clone e record corrente...
            AppMServ.clonedRA = null;
            CurrRecord = null;
            // registro fatto
            await ItemUpdated.InvokeAsync(true);
        }

        protected override async Task OnParametersSetAsync()
        {
            vetoUpd = true;
            Stopwatch sw = new Stopwatch();
            sw.Start();
            var value = currRecord;
            if (value != null)
            {
                if (value.FasiNav != null && value.FasiNav.ProgettoNav != null)
                {
                    gruppoSel = value.FasiNav.ProgettoNav.Gruppo;
                    idxProj = value.FasiNav.IdxProgetto != null ? (int)value.FasiNav.IdxProgetto : 0;
                }
                else
                {
                    // effettuo selezione manuale...
                    var currFase = await CDService.AnagFasiByKey(value.IdxFase);
                    if (currFase != null)
                    {
                        if (currFase.ProgettoNav != null)
                        {
                            gruppoSel = currFase.ProgettoNav.Gruppo;
                        }
                        idxProj = currFase.IdxProgetto != null ? (int)currFase.IdxProgetto : 0;
                    }
                    value.IdxFase = 0;
                }
            }
            await ReloadData(false, false);
            sw.Stop();
            TimeSpan ts = sw.Elapsed;

            Log.Trace($"Test esecuzione sel cascata: {ts.TotalMilliseconds} ms");
            vetoUpd = false;
        }

        protected async Task ReloadData(bool resetProj, bool resetFase)
        {
            gruppiList = await CDService.AnagGruppiUser(AppMServ.IdxDipendente);
            var allProj = await CDService.AnagProjAll();
            projList = allProj
                        .Where(x => x.Attivo == true && x.Gruppo == gruppoSel)
                        .OrderBy(x => x.ClienteNav.RagSociale)
                        .ThenBy(x => x.NomeProj)
                        .ToList();
            if (resetProj)
            {
                if (projList.Count > 0)
                {
                    idxProj = projList[0].IdxProgetto;
                }
            }
            var fasiProj = await CDService.AnagFasiByProj(idxProj);
            if (fasiProj != null)
            {
                fasiList = fasiProj;
            }
            else
            {
                fasiList = new List<AnagFasiModel>();
            }
            if (resetFase)
            {
                // se ho 2+ risultati --> il primo � titolo faccio il secondo
                if (fasiList.Count > 1)
                {
                    var currData = fasiList.Skip(1).FirstOrDefault();
                    if (currData != null)
                    {
                        idxFase = currData.IdxFase;
                    }
                }
                // altrimenti primo...
                else
                {
                    var currData = fasiList.FirstOrDefault();
                    if (currData != null)
                    {
                        idxFase = currData.IdxFase;
                    }
                }
            }
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Private Properties

        [Inject]
        private MessageService AppMServ { get; set; } = null!;

        [Inject]
        private IJSRuntime JSRuntime { get; set; } = null!;

        private bool VetoInsert
        {
            get => CDService.VetoInsert;
        }

        #endregion Private Properties

        #region Private Methods

        private void arrotondaMinuti()
        {
            if (CurrRecord != null)
            {
                // arrotondo ai 5 min...
                CurrRecord.Inizio = CORE.Data.Utils.DateRounded(CurrRecord.Inizio.AddMinutes(2), 5, true);
                // arrotondo ai 5 min...
                CurrRecord.Fine = CORE.Data.Utils.DateRounded(CurrRecord.Fine.AddMinutes(2), 5, true);
                checkCoerenzaDate(true);
            }
        }

        /// <summary> Verifico coerenza date (inizio < fine) </summary> <param
        /// name="modInizio">indica se la data modificata sia l'inizio</param>
        private void checkCoerenzaDate(bool modInizio)
        {
            bool inError = false;
            // verifica presenza errori
            if (CurrRecord != null)
            {
                inError = CurrRecord.Inizio >= CurrRecord.Fine;
                if (inError)
                {
                    // se ho mod inizio --> tengo ferma fine, inizio 1/2 h prima
                    if (modInizio)
                    {
                        CurrRecord.Inizio = CurrRecord.Fine.AddMinutes(-30);
                    }
                    else
                    {
                        CurrRecord.Fine = CurrRecord.Inizio.AddMinutes(30);
                    }
                }
            }
        }

        #endregion Private Methods
    }
}