using GPW.CORE.Data.DbModels;
using GPW.CORE.Data.DTO;
using GPW.CORE.Smart.Data;
using Microsoft.AspNetCore.Components;

namespace GPW.CORE.Smart.Components.Compo
{
    public partial class CompTimbra : IDisposable
    {
        #region Public Properties

        [Parameter]
        public int IdxDipCurr { get; set; } = 0;

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            MService.EA_TimbUpd -= MService_EA_TimbUpd;
            MService.EA_DateChanged -= MService_EA_DateChanged;
            MService.EA_CalModeChanged -= MService_EA_CalModeChanged;
            listRecords = null;
            listRecordsRichieste = null;
            listCFF = null;
            GC.Collect();
        }

        #endregion Public Methods

        #region Protected Properties

        [Inject]
        protected MessageService MService { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        //private int idxDipCurr { get; set; } = 0;
        protected override void OnInitialized()
        {
            MService.EA_TimbUpd += MService_EA_TimbUpd;
            MService.EA_DateChanged += MService_EA_DateChanged;
            MService.EA_CalModeChanged += MService_EA_CalModeChanged;
            isRicTimb = MService.isRicTimb;
            nextIsEntrata = MService.NextIsEntrata;
        }

        protected override async Task OnParametersSetAsync()
        {
            await Task.Delay(1);
            if (IdxDipCurr > 0)
            {
                await reloadData();
            }
        }

        #endregion Protected Methods

        #region Private Fields

        /// <summary>
        /// elenco principale record utente
        /// </summary>
        private List<DailyDataDTO>? listRecords = null;

        private List<RegRichiesteModel>? listRecordsRichieste = null;
        private List<CalFesteFerieModel>? listCFF { get; set; } = null;

        #endregion Private Fields

        #region Private Properties

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

        private DateTime dtCurr { get; set; } = DateTime.Today;

        private bool isLoading
        {
            get => IdxDipCurr == 0;
        }

        /// <summary>
        /// Indica se si � in modalit� mancata timbratura
        /// </summary>
        private bool isRicTimb { get; set; } = false;

        private CalendarModeEnum.modoControllo modoCal { get; set; } = CalendarModeEnum.modoControllo.showCalendar;

        /// <summary>
        /// Indica quale deve essere prossima timbratura
        /// </summary>
        private bool nextIsEntrata { get; set; } = true;

        private DailyDataDTO? todayDTO { get; set; } = null;

        #endregion Private Properties

        #region Private Methods

        /// <summary> Richiesta evento reload --> lo passa al componente superiore <param name="doForce"></param>
        private async Task ForceReload(bool doForce)
        {
            if (doForce)
            {
                await reloadData();
            }
        }

        private async void MService_EA_CalModeChanged()
        {
            modoCal = MService.modoCal;
            //isRicTimb = (modoCal == Calendario.modoControllo.showTimbr);
            isRicTimb = MService.isRicTimb;
            await Task.Delay(1);
            await InvokeAsync(StateHasChanged);
        }

        private async void MService_EA_DateChanged()
        {
            dtCurr = MService.targetDate;
            await Task.Delay(1);
            await reloadData();
            await Task.Delay(1);
            await InvokeAsync(StateHasChanged);
        }

        private async void MService_EA_TimbUpd()
        {
            nextIsEntrata = MService.NextIsEntrata;
            await Task.Delay(1);
            await reloadData();
            await Task.Delay(1);
            await InvokeAsync(StateHasChanged);
        }

        private async Task reloadData()
        {
            if (IdxDipCurr > 0)
            {
                var lastMode = modoCal;
                modoCal = CalendarModeEnum.modoControllo.showCalendar;
                listRecords = null;
                await Task.Delay(25);
                // calcolo mese corrente e recupero dati
                DateTime MeseStart = new DateTime(dtCurr.Year, dtCurr.Month, 1);
                DateTime MeseEnd = MeseStart.AddMonths(1);
                listRecords = await CDService.DailyDetails(IdxDipCurr, MeseStart, MeseEnd);
                listRecordsRichieste = await CDService.RegRichiesteGetByDip(IdxDipCurr, MeseStart, MeseEnd);
                listCFF = await CDService.CalFestFeriePeriodo(MeseStart, MeseEnd);
                // recupero dati che mi servono...
                await updateNextTimb();
                await Task.Delay(25);
                modoCal = lastMode;
            }
        }

        private async Task updateNextTimb()
        {
            // verifico valore entrata/uscita x timbrature dipendente...
            DateTime oggi = DateTime.Today.Date;
            // recupero da dati correnti...
            if (listRecords != null)
            {
                todayDTO = listRecords.FirstOrDefault(x => x.DtRif == oggi);
                if (todayDTO != null)
                {
                    nextIsEntrata = todayDTO.ListTimbr.Count % 2 == 0;
                }
            }
            else
            {
                List<TimbratureModel> ListTimbOggi = await CDService.TimbratureDay(oggi, IdxDipCurr);
                if (ListTimbOggi != null)
                {
                    nextIsEntrata = ListTimbOggi.Count % 2 == 0;
                }
                else
                {
                    nextIsEntrata = true;
                }
            }
            MService.NextIsEntrata = nextIsEntrata;
        }

        #endregion Private Methods
    }
}