import {Component, OnInit, Input, ElementRef}            from '@angular/core';
import {SimpleChanges, OnChanges}                        from '@angular/core';
import {FormGroup, FormArray, FormBuilder, Validators}   from "@angular/forms";
import {ActivatedRoute, Router}                          from '@angular/router';

import {HelpContentService}                              from "../../../services/help-content.service";
import {CommunityService}                                from "../../../openaireLibrary/connect/community/community.service";
import {SubjectsService}                                 from "../subjects.service"
import {EnvProperties}                                   from '../../../openaireLibrary/utils/properties/env-properties';

import {CommunityInfo}                                   from '../../../openaireLibrary/connect/community/communityInfo';

import {Session}                                         from '../../../openaireLibrary/login/utils/helper.class';
import {LoginErrorCodes}                                 from '../../../openaireLibrary/login/utils/guardHelper.class';

import { concat }                                        from 'rxjs/observable/concat';
@Component({
    selector: 'subjects-edit-form',
    templateUrl: './subjects-edit-form.component.html',
})

export class SubjectsEditFormComponent implements OnInit{

    @Input('group')
    myForm: FormGroup;

    public showLoading: boolean = true;
    public errorMessage: string = '';
    public updateErrorMessage: string = '';

    public successfulSaveMessage: string = '';
    public successfulResetMessage: string = '';

    public hasChanged: boolean = false;

    public res=[];

    params: any;

    public communityId = null;
    public community = null;
    public properties: EnvProperties = null;
    public newsubject ="";
    public edit = null;
    public editSubjectOriginalValue = null;
    public originalSubjects = [];

    constructor (private element: ElementRef,
                 private route: ActivatedRoute,
                 private _router: Router,
                 public _fb: FormBuilder,
                 private _helpContentService: HelpContentService,
                 private _communityService: CommunityService,
                 private _subjectsService: SubjectsService){ }


    ngOnInit() {
        this.route.data.subscribe((data: { envSpecific: EnvProperties }) => {
        this.properties = data.envSpecific;
        this.route.queryParams.subscribe(
            communityId => {
                this.scroll();

                this.communityId = communityId['communityId'];

                if(!Session.isLoggedIn()){
                  this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
                } else {
                  if (this.communityId != null && this.communityId != '') {
                      this.showLoading = true;
                      this.updateErrorMessage = "";
                      this.errorMessage = "";

                      this._communityService.getCommunity(this.properties, this.properties.communityAPI+this.communityId).subscribe (
                        community => {
                              this.community = community;
                              this.params = {community: encodeURIComponent('"' + community.queryId + '"')};
                              this.originalSubjects = [];
                              for (var i = 0; i < this.community.subjects.length; i++) {
                                  this.originalSubjects.push(this.community.subjects[i]);
                              }
                              if (this.community.subjects.length == 0) {
                                this.community.subjects.push("");
                              }
                              this.showLoading = false;
                        },
                        error => this.handleError('System error retrieving community profile', error)
                      );
                  }
                }
            });
        });
    }



  public addSubject() {
    if(!Session.isLoggedIn()){
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
    } else {
          this.community.subjects.push("");
    }
  }

  public removeSubject(i: any) {
    if(!Session.isLoggedIn()){
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
    } else {
          this.community.subjects.splice(i, 1);
    }
  }

  public resetForm(communityId: string) {
    if(!Session.isLoggedIn()){
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
    } else {
      if (communityId != null && communityId != '') {
          this.showLoading = true;
          this.updateErrorMessage = "";
          this.errorMessage = "";

          this._communityService.getCommunity(this.properties, this.properties.communityAPI + communityId).subscribe (
            community => {
                  this.community = community;
                  this.params = {community: encodeURIComponent('"' + community.queryId + '"')};
                  this.showLoading = false;
                  this.handleSuccessfulReset('Form reseted!');
            },
            error => this.handleError('System error retrieving community profile', error)
          );
      }
      this.resetChange();
    }
  }

 // save(newValue){
 //   this.edit=null;
 //   console.log(this.editSubjectOriginalValue + "-->"+newValue)
 //   if (this.communityId != null && this.communityId != '' && this.editSubjectOriginalValue != newValue) {
 //       this.showLoading = true;
 //       var subjectsToDelete = this.parseUpdatedSubjects([this.editSubjectOriginalValue]);
 //       var subjectsToAdd = this.parseUpdatedSubjects([newValue]);
 //       let obs = concat(this._subjectsService.addSubjects(this.properties.communityAPI+this.communityId+"/subjects", subjectsToAdd),
 //       this._subjectsService.removeSubjects(this.properties.communityAPI+this.communityId+"/subjects", subjectsToDelete));
 //        obs.subscribe(res => {
 //          console.log(res);
 //          this.community.subjects = res[1]["subjects"];
 //          this.originalSubjects = this.community.subjects;
 //          this.handleSuccessfulSave('Subjects updated!')
 //          this.showLoading = false;
 //        });
 //   }
 //   this.editSubjectOriginalValue = null;
 // }
 public getSubjectsExistOnlyInFirst(firstArray: string[], secondArray: string[]): string[] {

   var difference = [];
   for (var i = 0; i < firstArray.length; i++) {
       if (secondArray.indexOf(firstArray[i]) == -1) {
           difference.push(firstArray[i]);
       }

   }
   return difference;

 }
  public updateSubjects() {
    if(!Session.isLoggedIn()){
      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });
    } else {
      if (this.communityId != null && this.communityId != '') {
          this.showLoading = true;
          var subjectsToDeleteAr = this.getSubjectsExistOnlyInFirst(this.originalSubjects, this.community.subjects);
          var subjectsToAddAr = this.getSubjectsExistOnlyInFirst(this.community.subjects, this.originalSubjects);

          var subjectsToDelete = this.parseUpdatedSubjects(subjectsToDeleteAr);
          var subjectsToAdd = this.parseUpdatedSubjects(subjectsToAddAr);
          if(subjectsToAddAr.length > 0 && subjectsToDeleteAr.length > 0){
            let obs = concat(this._subjectsService.addSubjects(this.properties.communityAPI + this.communityId + "/subjects", subjectsToAdd),
            this._subjectsService.removeSubjects(this.properties.communityAPI + this.communityId + "/subjects", subjectsToDelete));
             obs.subscribe(res => {
               if (res["method"] == "delete") {
                this.afterUpdateActions(res);
               }
             },
              error => this.handleUpdateError('System error updating subjects', error)
            );
          }else if (subjectsToAddAr.length > 0){
            this._subjectsService.addSubjects(this.properties.communityAPI + this.communityId +"/subjects", subjectsToAdd).subscribe(res => {
                 this.afterUpdateActions(res);

             },
              error => this.handleUpdateError('System error updating subjects', error)
            );
          }else if (subjectsToDeleteAr.length > 0) {
            this._subjectsService.removeSubjects(this.properties.communityAPI + this.communityId + "/subjects", subjectsToDelete).subscribe(res => {
                 this.afterUpdateActions(res);

             },
              error => this.handleUpdateError('System error updating subjects', error)
            );
          }
          // this._router.navigate(['/manage-subjects'], {queryParams: { "communityId": this.communityId}});

      }
      this.resetChange();
    }
  }
  afterUpdateActions(res){
    this.community.subjects = res["subjects"];
    this.originalSubjects = [];
    for (var i = 0; i < this.community.subjects.length; i++) {
        this.originalSubjects.push(this.community.subjects[i]);
    }
    if (this.community.subjects.length == 0) {
      this.community.subjects.push("");
    }
    this.handleSuccessfulSave('Subjects updated!')
    this.showLoading = false;
  }
  private parseUpdatedSubjects(subjects): {} {
      var parsedSubjects = this.getNonEmptyItems(subjects);
      return parsedSubjects;
  }



  private getNonEmptyItems(data: string[]): string[] {
      let length = data.length;
      let arrayNonEmpty = new Array<string>();

      let j = 0;
      for (let i = 0; i < length; i++) {
          if (this.isEmpty(data[i])) {
          } else if (this.isNonEmpty(data[i])) {
               arrayNonEmpty[j] = data[i];
               j++;
          }
      }
      return arrayNonEmpty;
  }

  private hasFilled(data: any): boolean {
      if (this.isNonEmpty(data) && !this.isEmpty(data)) {
          return true;
      }
      return false;
  }

  private isEmpty(data: string): boolean {
      if (data != undefined && !data.replace(/\s/g, '').length)
          return true;
      else
          return false;
  }

  private isNonEmpty(data: string): boolean {
      if (data != undefined && data != null)
          return true;
      else
          return false;
  }

  private hasValidEmail(data: any): boolean {
      let length = data['managers'].length;

      for (let i = 0; i < length; i++) {
          if (!this.emailValidator(data['managers'][i])){
              // TODO remove console message after final testing
              //console.log("INVALID EMAIL");
              return false;
          }
      }
      // TODO remove console message after final testing
      //console.log("ALL EMAILS ARE VALID");
      return true;
  }

  private emailValidator(email: any): boolean {
      if (email.match("^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,4}$"))
          return true;
      else
          return false;
  }

  private change() {
      this.hasChanged = true;
      this.successfulSaveMessage = '';
      this.successfulResetMessage = '';
  }

  private resetChange() {
      this.hasChanged = false;
  }

  public get form() {
      return this._fb.group({
          _id : '',
          name : ['', Validators.required]
      });
  }

  public reset() {
      this.myForm.patchValue({
          name : '',
          _id : ''
      });
  }

  handleUpdateError(message: string, error) {
      this.updateErrorMessage = message;
      console.log('Server responded: ' +error);

      this.showLoading = false;
  }

  handleError(message: string, error) {
      this.errorMessage = message;
      console.log('Server responded: ' + error);

      this.showLoading = false;
  }

  handleSuccessfulSave(message) {
      this.showLoading = false;
      this.successfulSaveMessage = message;
  }

  handleSuccessfulReset(message) {
      this.showLoading = false;
      this.successfulResetMessage = message;
  }

  trackByFn(index: any, item: any) {
      return index;
  }

  public scroll() {
    if (typeof document !== 'undefined') {
       this.element.nativeElement.scrollIntoView();
    }
  }

}