import { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';
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 { AttachmentsService } from 'src/app/services/attachments.service';
import { Event } from 'src/app/models/event.model';
import { ModalController } from '@ionic/angular';
import { removeDuplicate } from 'src/plugin/removeDuplicate.js'
import { SearchPage } from 'src/app/pages/search/search.page';
import { SearchList } from "src/app/models/search-document";
import {  EventAttachment } from 'src/app/models/attachment.model';

import { ToastService } from 'src/app/services/toast.service';
import { LoginUserRespose } from 'src/app/models/user.model';
import { AuthService } from 'src/app/services/auth.service';

import {DateAdapter} from '@angular/material/core';
import * as _moment from 'moment';
import * as _rollupMoment from 'moment';
import { FormControl } from '@angular/forms';
import { NgxMatDateFormats } from '@angular-material-components/datetime-picker';
import { ThemePalette } from '@angular/material/core';

import { ViewChild } from '@angular/core';
import {  FormGroup, Validators } from '@angular/forms';
import { NGX_MAT_DATE_FORMATS } from '@angular-material-components/datetime-picker';
import { ThemeService } from 'src/app/services/theme.service'
import { ChatMethodsService } from 'src/app/services/chat/chat-methods.service';

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-new-event',
  templateUrl: './new-event.page.html',
  styleUrls: ['./new-event.page.scss'],
  providers: [
    { provide: NGX_MAT_DATE_FORMATS, useValue: CUSTOM_DATE_FORMATS },
  ]
})


export class NewEventPage implements OnInit {

  eventBody: EventBody;
  segment:string = "true";

  public date: any;
  public disabled = false;
  public showSpinners = true;
  public showSeconds = false;
  public touchUi = false;
  public enableMeridian = false;
  public stepHour = 1;
  public stepMinute = 5;
  public stepSecond = 5;
  public color: ThemePalette = 'primary';
  recurringTypes = []
  selectedRecurringType: any;

  @Input() profile:string;
  @Input() roomId:string;
  @Input() selectedSegment: string;
  @Input() selectedDate: Date;
  @Input() taskParticipants: EventPerson[] = [];
  @Input() taskParticipantsCc: any = [];

  @Output() setIntervenient = new EventEmitter<any>();
  @Output() setIntervenientCC = new EventEmitter<any>();

  postEvent: Event;
  @Output() onAddEvent = new EventEmitter<any>();
  @Output() openAttendeesComponent = new EventEmitter<any>();
  @Output() clearContact = new EventEmitter<any>();
  @Output() GoBackEditOrAdd  = new EventEmitter<any>();
  @Output() cloneAllmobileComponent = new EventEmitter<any>();

  documents:SearchList[] = [];

  // minDate: string;

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

  Form: FormGroup;
  validateFrom = false

  public options = [
    { value: true, label: 'True' },
    { value: false, label: 'False' }
  ];

  public listColors = ['primary', 'accent', 'warn'];
  public stepHours = [1, 2, 3, 4, 5];
  public stepMinutes = [1, 5, 10, 15, 20, 25];
  public stepSeconds = [1, 5, 10, 15, 20, 25];

  showLoader = false

  CalendarName;

  constructor(
    private modalController: ModalController,
    private eventService: EventsService,
    private attachmentsService: AttachmentsService,
    private toastService: ToastService,
    private userService: AuthService,
    private dateAdapter: DateAdapter<any>,
    public ThemeService: ThemeService,
    private chatMethodService: ChatMethodsService,
    // private translate: TranslateService
  ) {
    this.dateAdapter.setLocale('pt');
    this.loggeduser = userService.ValidatedUser;
    this.postEvent = new Event();

    this.postEvent.StartDate = new Date()
    this.postEvent.EndDate = new Date(new Date().getTime() + 15 * 60000);
  }

  ngOnInit() {

    this.CalendarName = this.loggeduser.Profile;

    this.getRecurrenceTypes();
    if(!this.restoreTemporaryData()){
      // clear
      this.eventBody = { BodyType : "1", Text : ""};
      this.postEvent.Body = this.eventBody;

      /*  console.log(this.profile); */

      let selectedStartdDate = this.selectedDate;
      let selectedEndDate = new Date(this.selectedDate);
      /* Set + 30minutes to seleted datetime */
      selectedEndDate.setMinutes(this.selectedDate.getMinutes() + 30) ;


      if(this.selectedSegment != "Combinada"){
        this.postEvent ={
          EventId: '',
          Subject: '',
          Body: this.eventBody,
          Location: '',
          CalendarId: '',
          CalendarName: 'Oficial',
          StartDate: selectedStartdDate,
          EndDate: new Date(selectedEndDate),
          EventType: 'Reunião',
          Attendees: null,
          IsMeeting: false,
          IsRecurring: false,
          AppointmentState: 0,
          TimeZone: '',
          Organizer: '',
          Category: 'Reunião',
          HasAttachments: false,
          EventRecurrence: {Type:'-1'},
        };
      }
      else{
        this.postEvent ={
          EventId: '',
          Subject: '',
          Body: this.eventBody,
          Location: '',
          CalendarId: '',
          CalendarName: 'Oficial',
          StartDate: selectedStartdDate,
          EndDate: new Date(selectedEndDate),
          EventType: 'Reunião',
          Attendees: null,
          IsMeeting: false,
          IsRecurring: false,
          AppointmentState: 0,
          TimeZone: '',
          Organizer: '',
          Category: 'Reunião',
          HasAttachments: false,
          EventRecurrence: {Type:'-1'},
        };
      }

      if(this.postEvent.Attendees != null) {
        this.postEvent.Attendees.forEach(e =>{
          if(e.IsRequired) {
            this.taskParticipants.push(e);
          } else {
            this.taskParticipantsCc.push(e);
          }
        })
      }
      this.taskParticipants = removeDuplicate(this.taskParticipants);
      this.taskParticipantsCc = removeDuplicate(this.taskParticipantsCc);

      this.setIntervenient.emit(this.taskParticipants);
      this.setIntervenientCC.emit(this.taskParticipantsCc);
    }


    this.date = new Date(2021,9,4,5,6,7);

    this.injectValidation();

  }

  runValidation() {
    this.validateFrom  = true;
    if(new Date(this.postEvent.StartDate).getTime() > new Date(this.postEvent.EndDate).getTime()){
      this.toastService._badRequest("A data de fim não pode ser inferior a data de início do evento")
    }
  }

  injectValidation() {

    if (typeof(this.postEvent.EventRecurrence.Type) == 'number') {
      const str: any = this.postEvent.EventRecurrence.Type.toString()
      this.postEvent.EventRecurrence.Type = str
    }

    this.Form = new FormGroup({
      Subject: new FormControl(this.postEvent.Subject, [
        Validators.required,
        // Validators.minLength(4)
      ]),
      Location: new FormControl(this.postEvent.Location, [
        Validators.required,
      ]),
      CalendarName: new FormControl(this.postEvent.CalendarName),
      Categories: new FormControl(this.postEvent.Category, [
        Validators.required
      ]),
      dateStart: new FormControl(this.postEvent.StartDate, [
        Validators.required
      ]),
      dateEnd: new FormControl(this.postEvent.EndDate, [
        Validators.required
      ]),
      dateOccurrence: new FormControl(this.postEvent.EventRecurrence.Type.toString() == '-1' ? ['ok']: this.postEvent.EventRecurrence.LastOccurrence, [
        Validators.required
      ]),
      participantes: new FormControl(this.taskParticipants, [
        // Validators.required
      ]),
      Date: new FormControl( new Date(this.postEvent.StartDate).getTime() < new Date(this.postEvent.EndDate).getTime() ? 'ok': null,[
        Validators.required
      ]),
    })

  }


  openInicio() {
    let input: any = document.querySelector('#new-inicio')
    if(input) {
      console.log(input)
      input.click()
    }
  }

  openFim() {
    let input: any = document.querySelector('#new-fim')
    if(input) {
      input.click()
    }
  }

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

  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);
      }
    });
  }

  close(){

    this.deleteTemporaryData();
    this.cloneAllmobileComponent.emit();
    this.clearContact.emit();
    this.setIntervenient.emit([]);
    this.setIntervenientCC.emit([]);
  }

  getRecurrenceTypes() {
    this.eventService.getRecurrenceTypes().subscribe(res=>{
      console.log(res);
      this.recurringTypes = res;
    });
  }

  onSelectedRecurringChanged(ev:any){
    console.log(ev);
    if(ev.length > 1){
      console.log(ev.filter(data => data != '-1'));
      this.postEvent.EventRecurrence.Type = ev.filter(data => data != '-1');
    }
    if(ev.length == 0){
      this.postEvent.EventRecurrence.Type = "-1";
    }
  }



  async save() {

    this.injectValidation()
    this.runValidation()

    if(this.Form.invalid) {
      console.log('not passed')
      return false
    }

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

    if(this.documents.length >= 0) {
      this.postEvent.HasAttachments = true;
    }

    if(this.postEvent.EventRecurrence.Type == undefined) {
      this.postEvent.EventRecurrence.Type = '-1'
    }

    if(this.loggeduser.Profile == 'MDGPR') {

      this.showLoader = true;
      console.log(this.postEvent);
      let loader = this.toastService.loading();
      console.log(this.postEvent);
      this.eventService.postEventMd(this.postEvent, this.postEvent.CalendarName).subscribe(
        async (id) => {
          loader.remove()
          this.showLoader = false
          const eventId: any = id;
          const DocumentToSave: EventAttachment[] = this.documents.map((e) => {
            return {
              SourceTitle: e.Assunto,
              ParentId: eventId,
              Source: '1',
              SourceId: e.Id,
              ApplicationId: e.ApplicationType.toString(),
              Id: '',
              Link: '',
              SerialNumber: ''
            };
          });
          await DocumentToSave.forEach((attachments, i) => {
            this.attachmentsService.setEventAttachmentById(attachments).subscribe((res) =>{
              if(DocumentToSave.length == (i+1)){
                this.afterSave();
              }
            });
          });
          if(DocumentToSave.length == 0){
            this.afterSave();
          }
          this.toastService._successMessage('Evento criado');
          let data = {
            "subject": this.postEvent.Subject,
            "start": this.postEvent.StartDate,
            "end": this.postEvent.EndDate,
            "venue": this.postEvent.Location,
            "id": id,
          }
          this.chatMethodService.sendMessage(this.roomId,data);
        },
        error => {
          loader.remove()
          this.showLoader = false
          this.toastService._badRequest('Evento não criado')
      });

    }
    else if(this.CalendarName == 'PR') {
      console.log('PR - Aqui');
      console.log(this.postEvent);
      this.eventService.postEventPr(this.postEvent, this.postEvent.CalendarName).subscribe(
        (id) => {
          console.log(id);

          const eventId: any =  id;

          const DocumentToSave: EventAttachment[] = this.documents.map((e) => {
            return {
              SourceTitle: e.Assunto,
              ParentId: eventId,
              Source: '1',
              SourceId: e.Id,
              ApplicationId: e.ApplicationType.toString(),
              Id: '',
              Link: '',
              SerialNumber: ''
            };
          });

          DocumentToSave.forEach((attachments, i) => {
            this.attachmentsService.setEventAttachmentById(attachments).subscribe((res) =>{
              if(DocumentToSave.length == (i+1)){
                this.afterSave();
              }
            });
          });

          if(DocumentToSave.length == 0){
            this.afterSave();
          }
          this.toastService.successMessage('Evento criado')
        });
    }
  }

  afterSave() {
    this.deleteTemporaryData();

    this.onAddEvent.emit(this.postEvent);
    this.GoBackEditOrAdd.emit();

    this.setIntervenient.emit([]);
    this.setIntervenientCC.emit([]);
  }

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

  }

  async addParticipants() {

    this.saveTemporaryData();

    this.openAttendeesComponent.emit({
      type: "intervenient"
    });

    this.clearContact.emit();
  }

  async addParticipantsCc() {

    this.saveTemporaryData();

    this.openAttendeesComponent.emit({
      type: "CC"
    });

    this.clearContact.emit();
  }

  saveTemporaryData() {
    window['temp.path:/home/agenda/new-event.component.ts'] = {
      postEvent: this.postEvent,
      eventBody: this.eventBody,
      segment: this.segment
    }
  }

  /**
   *
   * @description o pipeline já esta a funcionar tuda vez que nos fazer push na branch master e test o pipeline executa os teste, mas agora os teste temos que melhora para testar a app em tudos os pontos
   *              o pipeline já está a funcionar toda vez que nos fazer um push na branch master ou teste o pipeline executa os testes, mas agora os testes temos que melhorar para testar a app em todos os pontos
   */
  restoreTemporaryData(): boolean {


    const restoredData =  window['temp.path:/home/agenda/new-event.component.ts']

    if(JSON.stringify(restoredData) != "{}" && undefined != restoredData) {
      this.postEvent = restoredData.postEvent
      this.eventBody = restoredData.eventBody
      this.segment = restoredData.segment

      // restore dater for date and hours picker

      return true;
    } else {

      return false;
    }
  }

  deleteTemporaryData(){
    window['temp.path:/home/agenda/new-event.component.ts'] = {}
  }

}

