using Microsoft.AspNetCore.Components;
using Microsoft.Extensions;
using System.Formats.Asn1;
using System.Text;
using Egw.Core.Razor.Comp.Data;

namespace Egw.Core.Razor.Comp.Components
{
    public partial class CalendarMonth
    {
        #region Public Properties

        /// <summary>
        /// Css giorno mese corrente
        /// default: text-danger
        /// </summary>
        [Parameter]
        public string CurrMonthCss { get; set; } = "text-light";

        /// <summary>
        /// Dizionario configurazione date (per check colori su data)
        /// </summary>
        [Parameter]
        public Dictionary<DateTime, string>? DateCheck { get; set; }

        /// <summary>
        /// Dizionario configurazione date tipo BLOCK (es feste, chiusure aziendali)
        /// </summary>
        [Parameter]
        public Dictionary<DateTime, string>? DateCheckBlock { get; set; }

        /// <summary>
        /// Evento selezione data valida (= entro il mese corrente/selezionato)
        /// </summary>
        [Parameter]
        public EventCallback<DateTime> DateSelected { get; set; }
        [Parameter]
        public EventCallback<bool> backToCal { get; set; }

        /// <summary>
        /// Day di riferimento (tipicamente = oggi) per disegnare calendario alla data corrente
        /// </summary>
        [Parameter]
        public DateTime DtRif { get; set; } = DateTime.Today;

        /// <summary>
        /// Elenco eventi da mostrare sul calendario
        /// </summary>
        [Parameter]
        public List<CalendarEvent>? EventList { get; set; }

        /// <summary>
        /// Css titolo
        /// default: color: red
        /// </summary>
        [Parameter]
        public string HeadStyle { get; set; } = "color: red";

        /// <summary>
        /// Css sfondo principale
        /// default: table table-dark table-borderless opt alt: table-striped, table-responsive
        /// </summary>
        [Parameter]
        public string MainCss { get; set; } = "table table-dark table-borderless";

        /// <summary>
        /// Evento cambio di mese
        /// </summary>
        [Parameter]
        public EventCallback<DateTime> MonthChanged { get; set; }

        /// <summary>
        /// Css giorno tipico
        /// default: text-danger
        /// </summary>
        [Parameter]
        public string OtherMonthCss { get; set; } = "text-secondary";

        /// <summary>
        /// Css giorno selezionato
        /// default: bg-danger text-warning
        /// </summary>
        [Parameter]
        public string SelDayCss { get; set; } = "bg-danger text-warning rounded-top p-2";

        /// <summary>
        /// Css dei giorni della settimana selezionata
        /// default: bg-danger text-warning
        /// </summary>
        [Parameter]
        public string SelWeekCss { get; set; } = "text-light m-0 px-0";

        /// <summary>
        /// Imposta di mostrare SOLO una singola settimana (per selezione data)
        /// default: false
        /// </summary>
        [Parameter]
        public bool SingleWeek { get; set; } = false;

        /// <summary>
        /// Css per giorni weekend (sab-dom)
        /// default: text-danger
        /// </summary>
        [Parameter]
        public string WeekEndCss { get; set; } = "bg-secondary text-light bg-opacity-75";

        #endregion Public Properties

        #region Protected Methods

        protected override async Task OnInitializedAsync()
        {
            dtCurr = DateTime.Today;
            await Task.Delay(1);
        }

        protected override async Task OnParametersSetAsync()
        {
            await FixDate();
        }

        #endregion Protected Methods

        #region Private Fields

        private bool singleWeek = false;

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Elenco date da mostrare
        /// </summary>
        private List<DateTime> DateList { get; set; } = new List<DateTime>();

        private DateTime dtCurr { get; set; } = DateTime.Today;
        private DateTime MonthEnd { get; set; } = DateTime.Today.AddMonths(1);

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

        /// <summary>
        /// Singola riga in caso di selezione...
        /// </summary>
        private List<DateTime> SingleWeekRow
        {
            get
            {
                List<DateTime> answ = new List<DateTime>();
                foreach (var item in WeekRows)
                {
                    if (item.Contains(DtRif))
                    {
                        answ = item;
                        break;
                    }
                }
                return answ;
            }
        }

        /// <summary>
        /// Righe da disegnare nel calendario
        /// </summary>
        private List<List<DateTime>> WeekRows { get; set; } = new List<List<DateTime>>();

        #endregion Private Properties

        #region Private Methods

        private bool hasDot(DateTime dtCurr, string type)
        {
            bool answ = false;
            if(EventList != null)
            {
                foreach(var item in EventList)
                {
                    if(item.Inizio.Date == dtCurr.Date && item.Type == type)
                    {
                        answ = true;
                    }
                }
            }
            return answ;
        } 

        private async Task clickDay(DateTime dtClick)
        {
            // se � mese prec/successivo --> sposto data rif
            if (dtClick < MonthStart)
            {
                DtRif = DtRif.AddMonths(-1);
                await FixDate();
                await MonthChanged.InvokeAsync(dtClick);
            }
            else if (dtClick > MonthEnd)
            {
                DtRif = DtRif.AddMonths(1);
                await FixDate();
                await MonthChanged.InvokeAsync(dtClick);
            }
            else
            {
                // altrimenti riporto evento
                await DateSelected.InvokeAsync(dtClick);
                if (EventList != null)
                {
                    var eventListWeekly = EventList.Where(x => SingleWeekRow.Contains(dtClick)).ToList();
                }
            }
            await Task.Delay(1);
        }

        private async Task addMonth()
        {
            
            await FixDate();
            await MonthChanged.InvokeAsync(DtRif.AddMonths(1));
        }
        private async Task subtractMonth()
        {
            
            await FixDate();
            await MonthChanged.InvokeAsync(DtRif.AddMonths(-1));
        }
        private string dayCss(DateTime currDay)
        {
            string answ = CurrMonthCss;
            // se � fuori estremi mese --> grigio...
            if (currDay < MonthStart || currDay > MonthEnd)
            {
                answ = OtherMonthCss;
            }
            else
            {
                // cerco prima i valori BLOCK...
                if (DateCheckBlock != null && DateCheckBlock.ContainsKey(currDay))
                {
                    answ = DateCheckBlock[currDay];
                }
                // se � weekend forzo quello
                else if (currDay.DayOfWeek == DayOfWeek.Saturday || currDay.DayOfWeek == DayOfWeek.Sunday)
                {
                    answ = WeekEndCss;
                }
            }
            return answ;
        }

        private void DisplayDate(DateTime dtSel)
        {
            dtCurr = dtSel;
            singleWeek = true;
        }

        private async Task backToCalendar()
        {
            await backToCal.InvokeAsync();
            //await reloadData();
        }

            /// <summary>
            /// Sistemazione date x disegnare controlli
            /// </summary>
            /// <returns></returns>
            private async Task FixDate()
        {
            await Task.Delay(1);
            // disegno sempre 6 righe = 42 gg
            int numDD = 42;
            MonthStart = new DateTime(DtRif.Year, DtRif.Month, 1);
            MonthEnd = MonthStart.AddMonths(1).AddDays(-1);
            DateTime calStart = MonthStart;
            // calcolo date calendario in base al giorno dell'inizio mese...
            switch (MonthStart.DayOfWeek)
            {
                case DayOfWeek.Sunday:
                    calStart = MonthStart.AddDays(-6);
                    break;

                case DayOfWeek.Monday:
                    calStart = MonthStart.AddDays(-7);
                    break;

                case DayOfWeek.Tuesday:
                    calStart = MonthStart.AddDays(-1);
                    break;

                case DayOfWeek.Wednesday:
                    calStart = MonthStart.AddDays(-2);
                    break;

                case DayOfWeek.Thursday:
                    calStart = MonthStart.AddDays(-3);
                    break;

                case DayOfWeek.Friday:
                    calStart = MonthStart.AddDays(-4);
                    break;

                case DayOfWeek.Saturday:
                    calStart = MonthStart.AddDays(-5);
                    break;

                default:
                    break;
            }
            // calcolo fine mese sapendo che sono cmq 7 x 6 week...
            int numEnd = numDD - MonthEnd.Subtract(calStart).Days;
            DateTime calEnd = MonthEnd.AddDays(numEnd);
            // calcolo elenco date (da disegnare)
            DateList = new List<DateTime>();
            for (int i = 0; i < numDD; i++)
            {
                DateList.Add(calStart.AddDays(i));
            }
            // ora sistemo le righe da disegnare...
            WeekRows = new List<List<DateTime>>();
            for (int i = 0; i < 6; i++)
            {
                WeekRows.Add(DateList.GetRange(i * 7, 7));
            }
        }

        private async Task resetCal()
        {
            singleWeek = false;
            await Task.Delay(1);
        }

        private string singleDayCss(DateTime currDay)
        {
            string answ = SelWeekCss;
            return answ;
        }

        private string singleDaySpanCss(DateTime currDay)
        {
            string answ = currDay == DtRif ? SelDayCss : CurrMonthCss;
            return answ;
        }

        private string spanCss(DateTime currDay)
        {
            string answ = "";
            if (DateCheck != null && DateCheck.ContainsKey(currDay))
            {
                answ = DateCheck[currDay];
            }
            return answ;
        }

        #endregion Private Methods
    }
}