public EventStatusChangesWindow(WpfScheduler.Event eventToCheck)
		{
			this.InitializeComponent();

            _eventToCheck = eventToCheck;
            LoadEventInfo();
            UpdateGrid();
		}
        public FinishedEventsControl(Model.Event eventToRender, Model.User userLoggedIn)
		{
			this.InitializeComponent();

            _userLoggedIn = userLoggedIn;
            _eventToRender = eventToRender;
            _schedulerEvent = new WpfScheduler.Event() { EventInfo = _eventToRender };

            LoadEventInfo();
		}
        private void btnAccept_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            if (cbPatientName.SelectedIndex == -1)
            {
                MessageBox.Show("Seleccione un paciente", "Informaicón", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            if (cbTratmentName.SelectedIndex == -1)
            {
                MessageBox.Show("Seleccione un tratamiento", "Informaicón", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            List<Model.Event> skippedEvents = _selectedPatient.Events
                                                .Where(ev => ev.IsCompleted && ev.PatientSkips)
                                                .OrderBy(ev => ev.StartEvent)
                                                .ToList();

            
            if (skippedEvents.Count >= maxSkippedEvents)
            {
                string skippedEventsMessage = string.Empty;
                for (int i = 0; i < skippedEvents.Count; i++)
                {
                    skippedEventsMessage += string.Format(
                                                "\nFalta #{0}:" +
                                                "\n -Tratamiento: {1}" +
                                                "\n -Día de la cita: {2}" +
                                                "\n -Hora de inicio de la cita: {3}" +
                                                "\n -Hora de fin de la cita: {4}",
                                                i + 1,
                                                skippedEvents[i].Treatment.Name,
                                                skippedEvents[i].StartEvent.ToString("D"),
                                                skippedEvents[i].StartEvent.ToString("HH:mm") + " hrs",
                                                skippedEvents[i].EndEvent.ToString("HH:mm") + " hrs" + (i == skippedEvents.Count - 1 ? "" : "\n"));
                }

                MessageBox.Show(string.Format("El paciente seleccionado no puede agendar cita, ya que cuenta con {0} {1} y el máximo permitido es de {2} {3}\n{4}",
                                                    skippedEvents.Count,
                                                    skippedEvents.Count == 1 ? "falta" : "faltas",
                                                    maxSkippedEvents,
                                                    maxSkippedEvents == 1 ? "falta" : "faltas",
                                                    skippedEventsMessage
                                                ),
                                                "Advertencia",
                                                MessageBoxButton.OK,
                                                MessageBoxImage.Warning);
                return;
            }

            //Health Insurance
            if (_selectedPatient.HasHealthInsurance)
            {
                if (_selectedPatient.IsDentegra)
                {
                    List<Model.DentegraAuthorization> elegibilities = _selectedPatient.DentegraAuthorizations
                                                                       .OrderByDescending(a => a.AuthorizationDate)
                                                                       .Take(1)
                                                                       .ToList();

                    if (elegibilities.Count == 0 || IsValidElegibility(elegibilities[0]) == false)
                    {
                        if (MessageBox.Show("El paciente seleccionado tiene seguro médico pero no cuenta con un número de " +
                                        "elegibilidad vigente.\n¿Desea agendar la cita?",
                                        "Advertencia",
                                        MessageBoxButton.YesNo,
                                        MessageBoxImage.Warning
                                    ) == MessageBoxResult.No || MainWindow.IsValidAdminPassword(_userLoggedIn) == false)
                        {
                            return;
                        }
                    }
                }
                else if (_selectedPatient.IsDiverse == false)
	            {
                    List<Model.Authorization> authorizations = _selectedPatient.Authorizations
                                                                       .OrderByDescending(a => a.AuthorizationDate)
                                                                       .Take(1)
                                                                       .ToList();

                    if (authorizations.Count == 0 || IsValidAuthorization(authorizations[0]) == false)
                    {
                        if (MessageBox.Show("El paciente seleccionado tiene seguro médico pero no cuenta con un número de " +
                                        "autorización vigente.\n¿Desea agendar la cita?",
                                        "Advertencia",
                                        MessageBoxButton.YesNo,
                                        MessageBoxImage.Warning
                                    ) == MessageBoxResult.No || MainWindow.IsValidAdminPassword(_userLoggedIn) == false)
                        {
                            return;
                        }
                    }
	            }
            }

            //Statements
            Model.Statement currentStatement = _selectedPatient.Statements
                                                    .Where(s => s.IsPaid == false)
                                                    .FirstOrDefault();

            if (currentStatement != null && currentStatement.ExpirationDate < DateTime.Now.Date)
            {
                MessageBox.Show("Este paciente posee un estado de cuenta que ha expirado (Estado de cuenta número: " + currentStatement.StatementId + ")" +
                                "\nEs necesario que el paciente liquide el estado de cuenta para poder agendarle una cita.",
                                "Información", MessageBoxButton.OK, MessageBoxImage.Information);

                return;
            }

            //Check for restricted hours if user has recurrent canceled events
            List<Model.Event> canceledEventsInARow = AgendaWindow.GetPatientCanceledEventsInARow(_selectedPatient.PatientId, 3);
            if (canceledEventsInARow != null && IsRestrictedHour(_eventStart))
            {
                string canceledEventsMessage = string.Empty;
                for (int i = 0; i < canceledEventsInARow.Count; i++)
                {
                    canceledEventsMessage += string.Format(
                                                "\nCita cancelada #{0}:" +
                                                "\n -Tratamiento: {1}" +
                                                "\n -Día de la cita: {2}" +
                                                "\n -Hora de inicio de la cita: {3}" +
                                                "\n -Hora de fin de la cita: {4}",
                                                i + 1,
                                                canceledEventsInARow[i].Treatment.Name,
                                                canceledEventsInARow[i].StartEvent.ToString("D"),
                                                canceledEventsInARow[i].StartEvent.ToString("HH:mm") + " hrs",
                                                canceledEventsInARow[i].EndEvent.ToString("HH:mm") + " hrs" + (i == canceledEventsInARow.Count - 1 ? "" : "\n"));
                }

                MessageBox.Show(string.Format("El paciente seleccionado no puede agendar cita en un horario fuera de " + 
                                                "13 hrs. a 15 hrs. y 19 hrs. en delante, dado que se le ha penalizado " +
                                                "por 3 citas canceladas consecutivamente.\n\nUltimas 3 citas canceladas:\n{0}",
                                                    canceledEventsMessage
                                                ),
                                                "Advertencia",
                                                MessageBoxButton.OK,
                                                MessageBoxImage.Warning);

                return;
            }

            Model.Event eventToAdd = new Model.Event();
            if (IsValidEvent(eventToAdd))
            {
                if (IsValidTreatmentInstrumentRelation(eventToAdd) == false)
                {
                    return;
                }

                if (BusinessController.Instance.Add<Model.Event>(eventToAdd))
                {
                    WpfScheduler.Event eventToAddScheduler = new WpfScheduler.Event() { EventInfo = eventToAdd };
                    _scheduler.AddEvent(eventToAddScheduler);

                    //Change status
                    bool eventStatusChangeRegistered = Utils.AddEventStatusChanges(null, eventToAddScheduler.EventStatus.ToString(), eventToAdd.EventId, _userLoggedIn.UserId);
                    if (eventStatusChangeRegistered == false)
                    {
                        MessageBox.Show("No se pudo guardar el cambio registrado en el estado de la cita", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                    }

                    //Discount UsesLeft to the selected instrument
                    List<Model.Instrument> missingInstruments = new List<Model.Instrument>();
                    if (eventToAdd.Instruments.Count > 0)
                    {
                        bool discountError = false;
                        foreach (var instrument in eventToAdd.Instruments)
                        {
                            if (instrument.UsesLeft > 0)
                            {
                                instrument.UsesLeft--;
                                discountError &= !BusinessController.Instance.Update<Model.Instrument>(instrument);
                            }
                            else
                            {
                                missingInstruments.Add(instrument);
                            }
                        }
                        
                        if (discountError)
                        {
                            MessageBox.Show("No se pudo descontar la cantidad de usos a algún instrumento seleccionado", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                        }
                    }

                    if (missingInstruments.Count > 0)
                    {
                        MessageBox.Show("La cita se ha agendado, pero debe tomar en cuenta que faltan los siguientes instrumentos:\n-" + string.Join("\n-", missingInstruments.Select(i => i.Name)), "Información", MessageBoxButton.OK, MessageBoxImage.Information);   
                    }

                    this.Close();
                }
                else
                {
                    MessageBox.Show("No pudo ser agendada la cita", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            if (values.Length == 5)
            {
                Model.Event modelEvent = new Model.Event()
                {
                    IsException = (bool)values[0],
                    IsCanceled = (bool)values[1],
                    IsCompleted = (bool)values[2],
                    PatientSkips = (bool)values[3],
                    IsConfirmed = (bool)values[4]
                };

                WpfScheduler.Event scheduleEvent = new WpfScheduler.Event() { EventInfo = modelEvent };

                return scheduleEvent.EventStatusString;
            }
            else if (values.Length == 1 && values[0] is DateTime)
            {
                DateTime dateToShow = (DateTime)values[0];
                return dateToShow.ToString("dd/MMMM/yyyy") + dateToShow.ToString(", HH:mm") + " hrs";
            }

            return string.Empty;
        }