import { Component, OnInit, ViewChild } from '@angular/core';
import { ModalController, NavParams } from '@ionic/angular';
import { Event } from 'src/app/models/event.model'
import { EventBody } from 'src/app/models/eventbody.model';
import { EventPerson } from 'src/app/models/eventperson.model';
import { EventsService } from 'src/app/services/events.service';
import { DiscartExpedientModalPage } from '../../discart-expedient-modal/discart-expedient-modal.page';
import { AttachmentsService } from 'src/app/services/attachments.service';
import { SearchPage } from 'src/app/pages/search/search.page';
import { SearchList } from 'src/app/models/search-document';
import { LoginUserRespose } from 'src/app/models/user.model';
import { AuthService } from 'src/app/services/auth.service';
import { AttendeesPageModal } from 'src/app/pages/events/attendees/attendees.page';
import { ToastService } from 'src/app/services/toast.service';
import { FormControl, FormGroup, Validators } from '@angular/forms';
import * as _moment from 'moment';
import * as _rollupMoment from 'moment';
import { NgxMatDateFormats } from '@angular-material-components/datetime-picker';
import { NGX_MAT_DATE_FORMATS } from '@angular-material-components/datetime-picker';
import { ThemeService } from 'src/app/services/theme.service'
import { SessionStore } from 'src/app/store/session.service';
import { RoleIdService } from 'src/app/services/role-id.service';
import { HttpErrorHandle } from 'src/app/services/http-error-handle.service';
import { environment } from 'src/environments/environment';


const moment = _rollupMoment || _moment;

const CUSTOM_DATE_FORMATS: NgxMatDateFormats = {
  parse: {
    dateInput: "YYYY-MMMM-DD HH:mm"
  },
  display: {
    dateInput: "DD MMM YYYY H:mm",
    monthYearLabel: "MMM YYYY",
    dateA11yLabel: "LL",
    monthYearA11yLabel: "MMMM YYYY"
  }
}

@Component({
  selector: 'app-book-meeting-modal',
  templateUrl: './book-meeting-modal.page.html',
  styleUrls: ['./book-meeting-modal.page.scss'],
  providers: [
    { provide: NGX_MAT_DATE_FORMATS, useValue: CUSTOM_DATE_FORMATS },
  ]
})

export class BookMeetingModalPage implements OnInit {

  public date: any;
  public disabled = false;
  public showSpinners = true;
  public showSeconds = false;
  public touchUi = false;
  public enableMeridian = false;
  public minDate = new Date();
  public ionicMinDate = new Date().toISOString().slice(0, 10)

  // curent timestamp + 15 minutes
  public endMinDate = new Date(new Date().getTime() + 15 * 60000);

  public stepHour = 1;
  public stepMinute = 15;
  public stepSecond = 5;

  public dateControlStart = new FormControl(moment("DD MM YYYY hh"));
  public dateControlEnd = new FormControl(moment("DD MM YYYY hh"));
  CalendarNamesOptions = ['Oficial', 'Pessoal']

  Form: FormGroup;
  validateFrom = false
  recurringTypes = [];
  Occurrence: Date = new Date()
  EventRecurrenceType = '-1'

  showLoader = false

  get dateStart() {
    return this.dateControlStart.value;
  }

  get dateEnd() {
    return this.dateControlEnd.value;
  }

  @ViewChild('picker') picker: any;
  @ViewChild('fim') fim: any;
  @ViewChild('inicio') inicio: any;
  @ViewChild('picker1') picker1: any;

  task: any;
  fulltask: any;

  taskParticipants: EventPerson[];
  taskParticipantsCc: EventPerson[] = [];

  taskDocId: string;
  loadedAttachments: any;
  documents: SearchList[] = [];

  adding: "intervenient" | "CC" = "intervenient";

  postData: Event;
  eventBody: EventBody;
  eventAttendees: EventPerson[];

  formLocationSatus: boolean = false;
  showAttendees = false;
  emptyTextDescription = "Selecionar intervenientes";

  CalendarName

  sessionStore = SessionStore;
  environment = environment

  constructor(
    private modalController: ModalController,
    private navParams: NavParams,
    private attachmentsService: AttachmentsService,
    public calendarService: EventsService,
    private toastService: ToastService,
    public ThemeService: ThemeService,
    public eventService: EventsService,
    public RoleIdService: RoleIdService,
    private httpErroHandle: HttpErrorHandle


  ) {
    this.taskParticipants = [];

    this.task = this.navParams.get('task');
    this.fulltask = this.navParams.get('fulltask');

    console.log('fulltask', this.fulltask)

    if(this.fulltask?.Documents) {
      this.documents = this.fulltask.Documents
    }

    this.postData = new Event();
    this.eventBody = { BodyType: "1", Text: "" };
    this.postData.Body = this.eventBody;

    this.postData.Subject = this.task.Folio;
    this.postData.CalendarName = "Oficial";

    let startDate = this.roundTimeQuarterHour()
    this.dateControlStart = new FormControl(moment(startDate));
    this.dateControlEnd = new FormControl(moment(this.roundTimeQuarterHourPlus15(startDate)));

    this.postData.Category = 'Reunião'

    if (!this.CalendarName) {
      if (this.eventService.calendarNamesAry.includes('Meu calendario')) {
        this.CalendarName = 'Meu calendario';
        // console.log(this.eventService.calendarNamesAry)
      } else {
        this.CalendarName = this.eventService.calendarNamesAry[0]
      }
    }

    if (this.taskParticipants.length == 0) {
      this.taskParticipants = [
        // {
        //   EmailAddress: SessionStore.user.Email,
        //   IsRequired: true,
        //   Name: SessionStore.user.FullName,
        //   UserType: "GD"
        // }
      ]
    }

    this.changeAgenda();
  }

  ngOnInit() {
    // console.log('TEsTEROLE',this.eventService.calendarNamesAry)
    this.adding = "intervenient";
    this.getAttachments();
    this.setDefaultTime()
    this.getRecurrenceTypes();

  }


  ngOnDestroy() {
    clearInterval(this.myInterval)
  }

  myInterval = setInterval(() => {
    document.querySelectorAll('.ngx-mat-timepicker input').forEach((e :any) => {
      if(e) {
        e.disabled = true;
      }
    })
  }, 1000);

  getRecurrenceTypes() {
    this.calendarService.getRecurrenceTypes().subscribe(res => {
      this.recurringTypes = res;
    });
  }


  changeAgenda() {

    setTimeout(() => {

      if (this.calendarService.calendarNamesType[this.CalendarName]?.['Oficial'] && this.calendarService.calendarNamesType[this.CalendarName]?.['Pessoal']) {

        this.CalendarNamesOptions = ['Oficial', 'Pessoal']
      } else if (this.calendarService.calendarNamesType[this.CalendarName]?.['Oficial']) {

        this.CalendarNamesOptions = ['Oficial']
        this.postData.CalendarName = 'Oficial'
      } else if (this.calendarService.calendarNamesType[this.CalendarName]?.['Pessoal']) {

        this.CalendarNamesOptions = ['Pessoal']
        this.postData.CalendarName = 'Pessoal'
      } else {

        this.CalendarNamesOptions = ['Oficial', 'Pessoal']
      }
    }, 50)

  }

  setDefaultTime() {
    this.postData.StartDate = this.roundTimeQuarterHour();
    this.postData.EndDate = this.roundTimeQuarterHourPlus15(this.postData.StartDate);
  }

  getAttachments() {
    this.attachmentsService.getAttachmentsBySerial(this.task.SerialNumber).subscribe(res => {
      this.loadedAttachments = res;
    });
  }

  close() {
    this.modalController.dismiss(null);
  }

  goBack() {
    this.modalController.dismiss(null);
    window.history.back();
  }


  runValidation() {
    this.validateFrom = true
  }

  get dateValid() {
    return new Date(this.dateControlStart.value).getTime() < new Date(this.dateControlEnd.value).getTime() ? 'ok' : null
  }

  injectValidation() {

    this.Form = new FormGroup({
      Subject: new FormControl(this.postData.Subject, [
        Validators.required,
        // Validators.minLength(4)
      ]),
      Location: new FormControl(this.postData.Location, [
        Validators.required,
      ]),
      CalendarName: new FormControl(this.postData.CalendarName, [
        Validators.required
      ]),
      Date: new FormControl(this.dateValid, [
        Validators.required
      ]),
      participantes: new FormControl(this.taskParticipants, [
        Validators.required
      ]),
      Categories: new FormControl(this.postData.Category, [
        Validators.required
      ]),

    })
  }

  async saveTask() {

    if (SessionStore.user.Profile != 'PR') {
      this.injectValidation()
      this.runValidation()
      if (this.Form.invalid) return false
    }

    let Attendees = this.taskParticipants.concat(this.taskParticipantsCc);

    this.eventBody = {
      BodyType: '1',
      Text: this.postData.Body.Text,
    }
    let postData = {
      EventId: '',
      Subject: this.postData.Subject,
      Body: this.eventBody,
      Location: this.postData.Location,
      CalendarId: '',
      CalendarName: this.postData.CalendarName,
      StartDate: this.dateStart,
      EndDate: this.dateEnd,
      EventType: 'Reunião',
      Attendees: Attendees,
      IsMeeting: false,
      IsRecurring: false,
      AppointmentState: 0,
      TimeZone: 'UTC',
      Organizer: null,
      Category: 'Reunião',
      HasAttachments: true,
      EventRecurrence: {
        Type: this.EventRecurrenceType,
        LastOccurrence: this.Occurrence
      },
      Attachments: []
    }

    const DocumentToSave = this.documents.map((e: any) => {
      console.log('ASSUNTO', e.Assunto)
      return {
        ApplicationId: e.ApplicationType || e.ApplicationId,
        Source: 1,
        SourceId:  e.Id || e.DocId || e.SourceId,
        SourceName:e.Assunto,
        Description: e.Assunto,
        Stakeholders: e.EntidadeOrganicaNome
      }
    });

    postData.Attachments = DocumentToSave;



    if (this.task.FsId == '8') {
      const loader = this.toastService.loading()

      try {
        const CalendarId = this.selectedCalendarId()
        await this.calendarService.genericPostExpedientEvent(this.task.DocId, postData, "", this.task.SerialNumber, this.task.FsId, CalendarId).toPromise();

        this.modalController.dismiss();
        this.httpErroHandle.httpsSucessMessagge('Marcar Reunião')

      } catch (error) {
        this.httpErroHandle.httpStatusHandle(error)
      }
      finally {
        loader.remove()
      }


    }
    else if (this.task.FsId == '361') {
      console.log('361')
      const loader = this.toastService.loading()
      try {

        const CalendarId = this.selectedCalendarId()
        console.log({ CalendarId })
        await this.calendarService.genericCreateTaskEvent(this.task.FolderID | this.task.FolderId, postData, "", this.task.SerialNumber, this.task.FsId, CalendarId).toPromise();

        this.close();
        this.httpErroHandle.httpsSucessMessagge('Marcar Reunião')

      } catch (error) {
        this.httpErroHandle.httpStatusHandle(error)
      } finally {
        loader.remove()
      }
    }
    else {
      this.toastService._successMessage('Não é possível marcar a reunião de momento');
    }

  }




  selectedCalendarId() {

    if (this.calendarService.calendarNamesType[this.CalendarName]?.['Oficial'] && this.postData.CalendarName == 'Oficial') {
      return this.calendarService.calendarNamesType[this.CalendarName]['OficialId']

    } else if (this.calendarService.calendarNamesType[this.CalendarName]?.['Pessoal'] && this.postData.CalendarName == 'Pessoal') {

      return this.calendarService.calendarNamesType[this.CalendarName]['PessoalId']

    } else {
      return '11:11'
    }
  }

  async addParticipants() {

    this.adding = "intervenient";

    if (window.innerWidth <= 801) {
      const modal = await this.modalController.create({
        component: AttendeesPageModal,
        componentProps: {
          adding: this.adding,
          taskParticipants: this.taskParticipants,
          taskParticipantsCc: this.taskParticipantsCc
        },
        cssClass: 'modal modal-desktop',
        backdropDismiss: false
      });



      modal.onDidDismiss().then((data) => {

        if (data) {
          data = data['data'];

          const newAttendees: EventPerson[] = data['taskParticipants'];
          const newAttendeesCC: EventPerson[] = data['taskParticipantsCc'];

          this.setIntervenient(newAttendees);
          this.setIntervenientCC(newAttendeesCC);
        }
      }, (error) => {
        console.log(error)
      });

      await modal.present();

    } else {
      this.showAttendees = true;
    }
  }

  openLastOccurrence() {
    let input: any = document.querySelector('#last-occurrence')
    if (input) {
      input.click()
    }
  }

  async addParticipantsCc() {

    this.adding = "CC";

    if (window.innerWidth <= 800) {
      const modal = await this.modalController.create({
        component: AttendeesPageModal,
        componentProps: {
          adding: this.adding,
          taskParticipants: this.taskParticipants,
          taskParticipantsCc: this.taskParticipantsCc
        },
        cssClass: 'modal modal-desktop',
        backdropDismiss: false
      });

      await modal.present();

      modal.onDidDismiss().then((data) => {

        if (data) {
          data = data['data'];

          const newAttendees: EventPerson[] = data['taskParticipants'];
          const newAttendeesCC: EventPerson[] = data['taskParticipantsCc'];

          this.setIntervenient(newAttendees);
          this.setIntervenientCC(newAttendeesCC);
        }
      }, (error) => {
        console.log(error)
      });
    } else {
      this.showAttendees = true;
    }
  }

  async distartExpedientModal() {
    const modal = await this.modalController.create({
      component: DiscartExpedientModalPage,
      componentProps: {
        serialNumber: this.task.SerialNumber,
      },
      cssClass: 'discart-expedient-modal',
      backdropDismiss: false
    });


    modal.onDidDismiss().then(
      () => { }
      , (error) => {
        console.log(error)
      })
    await modal.present();
  }

  async getDoc() {
    const modal = await this.modalController.create({
      component: SearchPage,
      cssClass: 'modal-width-100-width-background modal',
      componentProps: {
        type: 'AccoesPresidenciais & ArquivoDespachoElect',
        showSearchInput: true,
        select: true
      }
    });
    await modal.present();
    modal.onDidDismiss().then((res) => {
      if (res) {
        const data = res.data;
        this.documents.push(data.selected);
        console.log(this.documents)
      }
    }, (error) => {
      console.log(error)
    });
  }

  removeAttachment(index: number) {
    this.documents = this.documents.filter((e, i) => index != i);
  }

  validateFormInputs() {
    let formLocation = this.postData.Location.trim();
    if (!this.postData.Location && formLocation.length <= 0) {
      this.formLocationSatus = true;
    }
  }

  dynamicSetIntervenient({ taskParticipants, taskParticipantsCc }) {
    this.taskParticipants = taskParticipants;
    this.taskParticipantsCc = taskParticipantsCc;
  }

  setIntervenient(data) {
    this.taskParticipants = data;
  }

  setIntervenientCC(data) {
    this.taskParticipantsCc = data;
  }


  roundTimeQuarterHour(timeToReturn = new Date()) {
    let date = timeToReturn || new Date();
    const minutes = date.getMinutes();
    date.setSeconds(0);

    if (minutes % 15 != 0) {

      if (minutes > 45) {
        date.setMinutes(60)
      } else if (minutes > 30) {
        date.setMinutes(45)
      } else if (minutes > 15) {
        date.setMinutes(30)
      } else if (minutes > 0) {
        date.setMinutes(15)
      }

    }

    return date
  }

  roundTimeQuarterHourPlus15(date: Date) {
    const _date = new Date(date);
    const minutes = _date.getMinutes();
    _date.setMinutes(minutes + 15)
    return _date
  }



  setStartDate() {
    this.postData.StartDate = this.roundTimeQuarterHour();
  }

  setEndDate() {
    this.postData.EndDate = this.postData.StartDate;
  }

}