import {
  AppointmentForGet,
  ClinicAppointmentForUpdate,
  ClinicsService,
  PagedPatients,
  Patient,
  PatientsService,
  UserAndRole,
  UserRead,
  UsersService
} from '../../../out';
import {PopupDiagComponent} from '../appointments/calendar/popup-diag/popup-diag.component';
import {CalendarEvent, CalendarEventTimesChangedEvent} from 'angular-calendar';
import {AuthenticationService} from './authentication.service';
import {ErrorHandlingService} from './error-handling.service';
import {isSameDay, isSameMonth} from 'date-fns';
import {LoaderService} from './loader.service';
import {ChartService} from './chart.service';
import {Injectable} from '@angular/core';
import {SmsService} from './sms.service';
import {Router} from '@angular/router';
import swal from 'sweetalert2';
import {Subject} from 'rxjs';

const colors: any = [
  {
    primary: '#abfaf9',
    secondary: '#abfaf9'
  },
  {
    primary: '#faabbb',
    secondary: '#faabbb'
  },
  {
    primary: '#75fea5',
    secondary: '#75fea5'
  }
];


@Injectable({
  providedIn: 'root',
})

export class AppointmentsService {

  modalData: {
    action: string;
    event: CalendarEvent;
  };
  updateAppointment: ClinicAppointmentForUpdate = {} as ClinicAppointmentForUpdate;
  monthNames = ['January', 'February', 'March', 'April', 'May', 'June',
    'July', 'August', 'September', 'October', 'November', 'December'];
  patientCollections: PagedPatients;
  appointments: Array<AppointmentForGet> = [];
  userCollections: Array<UserRead> = [];
  refresh: Subject<any> = new Subject();
  lazyLoadingArray: Array<any> = [];
  data: any = [{id: '', text: ''}];
  editingAppId: string | number;
  addedDate?: Date = new Date();
  appointmentPatientId: string;
  events: CalendarEvent[] = [];
  viewDate: Date = new Date();
  users: Array<UserAndRole>;
  lazyLoadingIndex: number;
  appTitleService: string;
  activeDayIsOpen = true;
  AppServiceTime?: Date;
  MS_PER_MINUTE = 60000;
  monthShowed: string;
  userFilter = false;
  yearShowed: number;
  startDate: string;
  clinicId: string;
  endDate: string;
  view = 'month';
  userId: string;
  interval: any;

  constructor(private auth: AuthenticationService,
              private route: Router,
              private api: ClinicsService,
              private api2: PatientsService,
              private smsService: SmsService,
              private api3: UsersService,
              private loaderService: LoaderService,
              private errHandler: ErrorHandlingService,
              public popup: PopupDiagComponent,
              private chartService: ChartService) {
    this.clinicId = auth.getClinicId();
    this.userId = auth.getId();
    this.getClinicUsers();
  }

  AddedValueToTime(d: Date, minutes: number): any {
    this.addedDate = new Date(d.getTime() + minutes * this.MS_PER_MINUTE);
    d = this.addedDate;
    return d;
  }

  getDate(event, userId?) {
    if (this.monthShowed !== this.monthNames[event.getMonth()] || userId) {
      this.loaderService.show();
      this.monthShowed = this.monthNames[event.getMonth()];
      this.yearShowed = event.getFullYear();

      const a = event.getMonth() + 1 + '' + this.yearShowed;
      this.lazyLoadingIndex = Number(a);

      const startDateString = this.monthShowed + ' ' + 1 + ', ' + this.yearShowed;
      const endDateString = this.monthShowed + ' ' +
        (this.getDaysInMonth(Number(event.getMonth()), this.yearShowed)) +
        ', ' + this.yearShowed;
      this.startDate = new Date(startDateString).toISOString();
      this.endDate = new Date(endDateString).toISOString();
      if (!this.lazyLoadingArray[this.lazyLoadingIndex] || userId) {
        this.fetchClinicAppointments(undefined, userId);
      } else {
        this.events = [];
        this.auth.refreshToken('appointments.service, getDate').then(() => {
          this.fetchAppEvent(this.lazyLoadingArray[this.lazyLoadingIndex]).then(() => {
            setTimeout(() => {
              this.refresh.next();
            }, 1000);
          });
        });
      }
    }
  }

  getDaysInMonth(month, year) {
    return new Date(year, month + 1, 0).getDate();
  }

  fetchClinicAppointments(searchString?, userId?) {
    this.loaderService.show();
    this.refresh.next();
    if (searchString && searchString !== '') {
      const currentDate = new Date(Date.now());
      const year = currentDate.getFullYear() + 1;
      this.monthShowed = this.monthNames[currentDate.getMonth()];
      this.yearShowed = currentDate.getFullYear();
      const startDateString = this.monthShowed + ' ' + 1 + ', ' + this.yearShowed;
      const endDateString = this.monthShowed + ' ' +
        (this.getDaysInMonth(Number(this.viewDate.getMonth()), year)) +
        ', ' + year;
      this.auth.refreshToken('appointments.service fetchClinicAppointments if').then(() => {
        if (userId) {
          userId = this.userId;
          if (this.userFilter) {
            this.userFilter = false;
            userId = undefined;
          } else {
            this.userFilter = true;
          }
        }
        this.api.getClinicItemAppointmentsCollection(this.clinicId, new Date(endDateString).toISOString(),
          new Date(startDateString).toISOString(), searchString, userId).subscribe((res) => {
          if (res && res.length === 0) {
            this.loaderService.hide();
            this.refresh.next();
            swal('Appointments Search Failed', 'Nothing found, Please try something else', 'info');
          } else {
            const interv = setInterval(() => {
              if (res.length === this.events.length || this.events.length > res.length) {
                clearInterval(interv);
                this.loaderService.hide();
              }
            }, 1500);
            for (let i = 0; i < res.length; i++) {
              if (!res[i].summary) {
                res[i].summary = '';
              }
              if (res[i].patient_id) {
                this.api2.getPatientItem(res[i].patient_id).subscribe((res2) => {
                  res[i] = Object.assign(res2, res[i]);
                }, err => {
                  this.errHandler.handleError(err, 'AppointmentsService, getPatientItem');
                });
              }
              if (i + 1 === res.length) {
                this.popup.openDialog();
                this.chartService.searchAppointments = res;
                this.popup.searchAppointments = res;
              }
            }
          }
        }, err => {
          this.errHandler.handleError(err, 'AppointmentsService, getClinicItemAppointmentsCollection');
        });
      });
    } else {
      this.auth.refreshToken('appointments.service fetchClinicAppointments else').then(() => {
        this.monthShowed = this.monthNames[this.viewDate.getMonth()];
        this.yearShowed = this.viewDate.getFullYear();

        const a = this.viewDate.getMonth() + 1 + '' + this.yearShowed;
        this.lazyLoadingIndex = Number(a);

        const startDateString = this.monthShowed + ' ' + 1 + ', ' + this.yearShowed;
        const endDateString = this.monthShowed + ' ' +
          (this.getDaysInMonth(Number(this.viewDate.getMonth()), this.yearShowed)) +
          ', ' + this.yearShowed;
        this.startDate = new Date(startDateString).toISOString();
        this.endDate = new Date(endDateString).toISOString();
        this.events = [];
        if (userId) {
          userId = this.userId;
          if (this.userFilter) {
            this.userFilter = false;
            userId = undefined;
          } else {
            this.userFilter = true;
          }
        }
        this.api.getClinicItemAppointmentsCollection(this.clinicId, this.endDate.toString(),
          this.startDate.toString(), undefined, userId).subscribe((res) => {
          if (res && res.length === 0) {
            this.loaderService.hide();
            this.refresh.next();
          } else {
            const interv = setInterval(() => {
              if (res.length === this.events.length || this.events.length > res.length) {
                clearInterval(interv);
                this.loaderService.hide();
              }
            }, 1500);
            this.lazyLoadingArray[this.lazyLoadingIndex] = res;
            this.appointments = res;
            this.auth.refreshToken('appointments.service, fetchClinicAppointments() else else').then(() => {
              this.fetchAppEvent(res).then(() => {
                setTimeout(() => {
                  this.refresh.next();
                }, 1000);
              });
            });
          }
        }, err => {
          this.errHandler.handleError(err, 'AppointmentsService, getClinicItemAppointmentsCollection');
        });
      });
    }
  }

  fetchAppEvent(res, index?) {
    this.loaderService.show();
    this.refresh.next();
    return new Promise((resolve, reject) => {
      if (res && res.length === 0) {
        this.refresh.next();
        reject(res.length);
      } else {
        const interv = setInterval(() => {
          if (res.length === this.events.length || this.events.length > res.length) {
            clearInterval(interv);
            this.loaderService.hide();
          }
        }, 1500);
        for (let i = 0; i < res.length; i++) {
          if (!res[i].is_clinic_appointment) {
            if (res[i].patient_id) {
              this.getPatient(res[i].patient_id).then((patient: Patient) => {
                if (patient) {
                  if (patient.first_name && patient.last_name) {
                    let titleText: string;
                    if (res[i].summary) {
                      titleText = patient.last_name + ' ' + patient.first_name +
                        ', ' + res[i].summary;
                    } else {
                      titleText = patient.last_name + ' ' + patient.first_name;
                    }
                    if (res[i].user_participants.length > 0) {
                      for (let y = 0; y < res[i].user_participants.length; y++) {
                        this.getUserCollection(res[i].user_participants[y]).then((userCollection) => {
                          const cid = 0;
                          const appEvent = {
                            id: res[i].id,
                            title: titleText,
                            start: new Date(res[i].start_time),
                            end: new Date(res[i].stop_time),
                            color: colors[cid],
                            draggable: true,
                            resizable: {
                              beforeStart: true,
                              afterEnd: true
                            },
                            meta: {
                              user: {
                                id: res[i].user_participants[y],
                                // @ts-ignore
                                name: userCollection.first_name + ' ' + userCollection.last_name,
                                color: colors[cid]
                              }
                            }
                          };
                          this.appointments.sort((a, b) => new Date(b.date_created).getTime() - new Date(a.date_created).getTime());
                          appEvent.title = titleText + ' by ' + userCollection.first_name + ' ' + userCollection.last_name;
                          if (index || index === 0) {
                            this.events[index] = appEvent;
                          } else {
                            this.events.push(appEvent);
                          }
                          this.refresh.next();
                          if (i + 1 === res.length) {
                            resolve('done');
                          }
                        });
                      }
                    } else {
                      const cid = 0;
                      const appEvent = {
                        id: res[i].id,
                        title: titleText,
                        start: new Date(res[i].start_time),
                        end: new Date(res[i].stop_time),
                        color: colors[0],
                        draggable: true,
                        resizable: {
                          beforeStart: true,
                          afterEnd: true
                        },
                        meta: {
                          user: {
                            id: 0,
                            name: 'All',
                            color: colors[cid]
                          }
                        }
                      };
                      this.appointments.sort((a, b) => new Date(b.date_created).getTime() - new Date(a.date_created).getTime());
                      if (index || index === 0) {
                        this.events[index] = appEvent;
                      } else {
                        this.events.push(appEvent);
                      }
                      this.refresh.next();
                      if (i + 1 === res.length) {
                        resolve('done');
                      }
                    }
                  }
                }
              }).catch(() => {
                let titleText: string;
                if (res[i].summary) {
                  titleText = 'Patient not found: ' + res[i].summary;
                } else {
                  titleText = 'Patient not found';
                }
                if (res[i].user_participants.length > 0) {
                  for (let y = 0; y < res[i].user_participants.length; y++) {
                    this.getUserCollection(res[i].user_participants[y]).then((userCollection) => {
                      const cid = 0;
                      const appEvent = {
                        id: res[i].id,
                        title: titleText,
                        start: new Date(res[i].start_time),
                        end: new Date(res[i].stop_time),
                        color: colors[cid],
                        draggable: true,
                        resizable: {
                          beforeStart: true,
                          afterEnd: true
                        },
                        meta: {
                          user: {
                            id: res[i].user_participants[y],
                            // @ts-ignore
                            name: userCollection.first_name + ' ' + userCollection.last_name,
                            color: colors[cid]
                          }
                        }
                      };
                      this.appointments.sort((a, b) => new Date(b.date_created).getTime() - new Date(a.date_created).getTime());
                      appEvent.title = titleText + ' by ' + userCollection.first_name + ' ' + userCollection.last_name;
                      if (index || index === 0) {
                        this.events[index] = appEvent;
                      } else {
                        this.events.push(appEvent);
                      }
                      this.refresh.next();
                    });
                    if (i + 1 === res.length) {
                      resolve('done');
                    }
                  }
                } else {
                  const cid = 0;
                  const appEvent = {
                    id: res[i].id,
                    title: titleText,
                    start: new Date(res[i].start_time),
                    end: new Date(res[i].stop_time),
                    color: colors[cid],
                    draggable: true,
                    resizable: {
                      beforeStart: true,
                      afterEnd: true
                    },
                    meta: {
                      user: {
                        id: 0,
                        name: 'All',
                        color: colors[cid]
                      }
                    }
                  };
                  this.appointments.sort((a, b) => new Date(b.date_created).getTime() - new Date(a.date_created).getTime());
                  if (index || index === 0) {
                    this.events[index] = appEvent;
                  } else {
                    this.events.push(appEvent);
                  }
                  this.refresh.next();
                  if (i + 1 === res.length) {
                    resolve('done');
                  }
                }
              });
            } else {
              let titleText: string;
              if (res[i].summary) {
                titleText = 'New Patient: ' + res[i].summary;
              } else {
                titleText = 'New Patient';
              }
              if (res[i].user_participants.length > 0) {
                for (let y = 0; y < res[i].user_participants.length; y++) {
                  this.getUserCollection(res[i].user_participants[y]).then((userCollection) => {
                    const cid = 1;
                    const appEvent = {
                      id: res[i].id,
                      title: titleText,
                      start: new Date(res[i].start_time),
                      end: new Date(res[i].stop_time),
                      color: colors[cid],
                      draggable: true,
                      resizable: {
                        beforeStart: true,
                        afterEnd: true
                      },
                      meta: {
                        user: {
                          id: res[i].user_participants[y],
                          // @ts-ignore
                          name: userCollection.first_name + ' ' + userCollection.last_name,
                          color: colors[cid]
                        }
                      }
                    };
                    this.appointments.sort((a, b) => new Date(b.date_created).getTime() - new Date(a.date_created).getTime());
                    appEvent.title = titleText + ' by ' + userCollection.first_name + ' ' + userCollection.last_name;
                    if (index || index === 0) {
                      this.events[index] = appEvent;
                    } else {
                      this.events.push(appEvent);
                    }
                    this.refresh.next();
                  });
                  if (i + 1 === res.length) {
                    resolve('done');
                  }
                }
              } else {
                const cid = 1;
                const appEvent = {
                  id: res[i].id,
                  title: titleText,
                  start: new Date(res[i].start_time),
                  end: new Date(res[i].stop_time),
                  color: colors[cid],
                  draggable: true,
                  resizable: {
                    beforeStart: true,
                    afterEnd: true
                  },
                  meta: {
                    user: {
                      id: 0,
                      name: 'All',
                      color: colors[cid]
                    }
                  }
                };
                this.appointments.sort((a, b) => new Date(b.date_created).getTime() - new Date(a.date_created).getTime());
                if (index || index === 0) {
                  this.events[index] = appEvent;
                } else {
                  this.events.push(appEvent);
                }
                this.refresh.next();
                if (i + 1 === res.length) {
                  resolve('done');
                }
              }
            }
          } else {
            let titleText: string;
            if (res[i].summary) {
              titleText = 'Clinic Appointment: ' + res[i].summary;
            } else {
              titleText = 'Clinic Appointment';
            }
            if (res[i].user_participants.length > 0) {
              for (let y = 0; y < res[i].user_participants.length; y++) {
                this.getUserCollection(res[i].user_participants[y]).then((userCollection) => {
                  const cid = 2;
                  const appEvent = {
                    id: res[i].id,
                    title: titleText,
                    start: new Date(res[i].start_time),
                    end: new Date(res[i].stop_time),
                    color: colors[cid],
                    draggable: true,
                    resizable: {
                      beforeStart: true,
                      afterEnd: true
                    },
                    meta: {
                      user: {
                        id: res[i].user_participants[y],
                        // @ts-ignore
                        name: userCollection.first_name + ' ' + userCollection.last_name,
                        color: colors[cid]
                      }
                    }
                  };
                  this.appointments.sort((a, b) => new Date(b.date_created).getTime() - new Date(a.date_created).getTime());
                  appEvent.title = titleText + ' by ' + userCollection.first_name + ' ' + userCollection.last_name;
                  if (index || index === 0) {
                    this.events[index] = appEvent;
                  } else {
                    this.events.push(appEvent);
                  }
                  this.refresh.next();
                });
                if (i + 1 === res.length) {
                  resolve('done');
                }
              }
            } else {
              const cid = 2;
              const appEvent = {
                id: res[i].id,
                title: titleText,
                start: new Date(res[i].start_time),
                end: new Date(res[i].stop_time),
                color: colors[cid],
                draggable: true,
                resizable: {
                  beforeStart: true,
                  afterEnd: true
                },
                meta: {
                  user: {
                    id: 0,
                    name: 'All',
                    color: colors[cid]
                  }
                }
              };
              this.new.sort((a, b) => new Date(b.date_created).getTime() - new Date(a.date_created).getTime());
              if (index || index === 0) {
                this.events[index] = appEvent;
              } else {
                this.events.push(appEvent);
              }
              this.refresh.next();
              if (i + 1 === res.length) {
                resolve('done');
              }
            }
          }
        }
      }
    });
  }

  getClinicUsers() {
    this.api.getClinicItemWithRolesCollection(this.clinicId).subscribe((res) => {
      this.users = res;
      this.getUsersCollection();
    }, err => {
      this.errHandler.handleError(err, 'AppointmentsService, getClinicItemWithRolesCollection');
    });
  }

  getUsersCollection() {
    this.userCollections = [];
    for (let i = 0; i < this.users.length; i++) {
      this.api3.getUserItem(this.clinicId, this.users[i].user_id).subscribe((res) => {
        this.userCollections.push(res);
        if (i + 1 === this.users.length) {
          this.data = this.getDataEnum(this.userCollections);
        }
      }, err => {
        // this.errHandler.handleError(err, 'AppointmentsService, getUserItem');
      });
    }
  }

  getUserCollection(id: string) {
    return new Promise((resolve, reject) => {
      this.api3.getUserItem(this.clinicId, id).subscribe((res) => {
        resolve(res);
      }, err => {
        // this.errHandler.handleError(err, 'AppointmentsService, getUserItem');
        reject();
      });
    });
  }

  getPatient(id: string) {
    return new Promise(((resolve, reject) => {
      this.api2.getPatientItem(id).subscribe((res) => {
        for (const one in res) {
          if (res[one] === null) {
            res[one] = '';
          }
        }
        // @ts-ignore
        if (res.gender === 'Female') {
          res.gender = Patient.GenderEnum.Female;
        } else {
          // @ts-ignore
          if (res.gender === 'Male') {
            res.gender = Patient.GenderEnum.Male;
          }
          resolve(res);
        }
      }, err => {
        reject('error');
      });
    }));
  }

  getDataEnum(user: any) {
    const arr = [];
    for (const s of user) {
      if (s.middle_name && s.first_name && s.last_name) {
        if (s.mobile_phone) {
          if (s.email) {
            arr.push({id: s.id, text: s.first_name + ' ' + s.middle_name + ' ' + s.last_name + ' || ' + s.mobile_phone + ' || ' + s.email});
          } else {
            arr.push({id: s.id, text: s.first_name + ' ' + s.middle_name + ' ' + s.last_name + ' || ' + s.mobile_phone});
          }
        } else if (s.phone) {
          if (s.email) {
            arr.push({id: s.id, text: s.first_name + ' ' + s.middle_name + ' ' + s.last_name + ' || ' + s.phone + ' || ' + s.email});
          } else {
            arr.push({id: s.id, text: s.first_name + ' ' + s.middle_name + ' ' + s.last_name + ' || ' + s.phone});
          }
        } else {
          if (s.email) {
            arr.push({id: s.id, text: s.first_name + ' ' + s.middle_name + ' ' + s.last_name + ' || ' + s.email});
          } else {
            arr.push({id: s.id, text: s.first_name + ' ' + s.middle_name + ' ' + s.last_name});
          }
        }
      } else {
        if (s.mobile_phone) {
          if (s.email) {
            arr.push({id: s.id, text: s.first_name + ' ' + s.last_name + ' || ' + s.mobile_phone + ' || ' + s.email});
          } else {
            arr.push({id: s.id, text: s.first_name + ' ' + s.last_name + ' || ' + s.mobile_phone});
          }
        } else if (s.phone) {
          if (s.email) {
            arr.push({id: s.id, text: s.first_name + ' ' + s.last_name + ' || ' + s.phone + ' || ' + s.email});
          } else {
            arr.push({id: s.id, text: s.first_name + ' ' + s.last_name + ' || ' + s.phone});
          }
        } else {
          if (s.email) {
            arr.push({id: s.id, text: s.first_name + ' ' + s.last_name + ' || ' + s.email});
          } else {
            arr.push({id: s.id, text: s.first_name + ' ' + s.last_name});
          }
        }
      }
    }
    return arr;
  }

  dayClicked({date}: { date: Date }): void {
    if (isSameMonth(date, this.viewDate)) {
      if (
        (isSameDay(this.viewDate, date) && this.activeDayIsOpen === true)
      ) {
        this.activeDayIsOpen = false;
        this.view = 'day';
        this.viewDate = date;
      } else {
        this.activeDayIsOpen = true;
        this.viewDate = date;
      }
    }
  }

  eventTimesChanged({
                      event,
                      newStart,
                      newEnd,
                    }: CalendarEventTimesChangedEvent): void {
    event.start = newStart;
    event.end = newEnd;
    this.updateAppointment = this.getAppointmentById(event.id);
    this.updateAppointment = {
      patient_id: this.updateAppointment.patient_id,
      alarm_ts: new Date(this.updateAppointment.alarm_ts),
      notes: this.updateAppointment.notes,
      start_time: new Date(this.updateAppointment.start_time),
      stop_time: new Date(this.updateAppointment.stop_time),
      summary: this.updateAppointment.summary,
      user_participants: this.updateAppointment.user_participants
    };
    this.handleEvent('Dropped or resized', event);
    this.updateAppointment.start_time = new Date(newStart);
    this.updateAppointment.stop_time = new Date(newEnd);
    for (const i in this.updateAppointment) {
      if (!this.updateAppointment[i]) {
        delete this.updateAppointment[i];
      }
    }
    this.auth.refreshToken('appointments.service eventTimesChanged').then(() => {
      this.api.putClinicItemWithAppointmentItem(this.clinicId, Number(event.id), this.updateAppointment)
        .subscribe((res) => {
        }, err => {
          this.errHandler.handleError(err, 'AppointmentsService, putClinicItemWithAppointmentItem');
        });
    });
    this.refresh.next();
  }

  userChanged({event, newUser}) {
    event.color = newUser.color;
    event.meta.user = newUser;
    this.events = [...this.events];
  }

  handleEvent(action: string, event: CalendarEvent): void {
    this.modalData = {event, action};
    if (action === 'Clicked') {
      this.editingAppId = event.id;
      this.appTitleService = event.title;
      this.route.navigateByUrl('/appointments/update/' + this.editingAppId);
    }
  }

  hourSegmentClicked(date: Date) {
    this.route.navigateByUrl('/appointments/add');
    this.AppServiceTime = date;
  }

  getAppointmentById(id: string | number): AppointmentForGet | null {
    for (const app of this.appointments) {
      if (app.id === id) {
        return app;
      }
    }
    return null;
  }

  sendSms() {
    const start = new Date();
    start.setHours(0, 0, 0, 0);
    const end = new Date();
    end.setHours(23, 59, 59, 999);
    this.auth.refreshToken('appointments.service sendSMS').then(() => {
      this.api.getClinicItemAppointmentsCollection(this.clinicId, end.toISOString(), start.toISOString()).subscribe((res) => {
        for (let i = 0; i < res.length; i++) {
          if (res[i].patient_id) {
            this.api2.getPatientItem(res[i].patient_id).subscribe((patientRes) => {
              if (patientRes.mobile_phone) {
                let gender: string;
                if (patientRes.gender === Patient.GenderEnum.Female) {
                  gender = 'Mrs. ';
                } else if (patientRes.gender === Patient.GenderEnum.Male) {
                  gender = 'Mr. ';
                }
                this.smsService.sendPostRequest('Cloudclinic', patientRes.mobile_phone, 'Dear ' + gender +
                  patientRes.first_name + ',\nPlease be informed that your appointment is today at:' +
                  new Date(res[i].start_time).toLocaleString()).then((smsRes) => {
                  if (smsRes === 'queued') {
                    swal('Success', 'Sms Message Sent to patient ' + patientRes.first_name + ' as an appointment reminder!', 'success');
                  } else {
                    swal('Failed', 'Sms failed to sent to patient ' + patientRes.first_name + '!', 'error');
                  }
                });
              } else {
                swal('error', 'Patient ' + patientRes.first_name + ' has no mobile phone number registered to his records',
                  'error');
              }
            });
          }
        }
      }, err => {
        this.errHandler.handleError(err, 'AppointmentsService, getClinicItemAppointmentsCollection');
      });
    });
  }
}