import { Right } from './../../../../shared/models/right.interface';
import { environment } from './../../../../../environments/environment';
import { USER_RIGHTS } from './../../../../shared/enums/USER_RIGHTS.enum';
import { AuthService } from 'src/app/shared/services/auth.service';
import { CreateVerificationRuleFormValue } from './create-verification-rule-form-value.interface';
import { JournalVerificationsService } from './../../../../shared/services/administration/journal-verifications.service';
import { CapturingVerificationsService } from './../../../../shared/services/administration/capturing-verifications.service';
import { DocumentSubclassificationsService } from 'src/app/shared/services/administration/document-subclassifications.service';
import { IpowerClientsService } from 'src/app/shared/services/administration/ipower-clients.service';
import { CategoriesService } from 'src/app/shared/services/administration/categories.service';
import { DocumentClassificationsService } from 'src/app/shared/services/administration/document-classifications.service';
import { FormBuilder, Validators } from '@angular/forms';
import { DocumentSubclassification } from 'src/app/shared/models/document-subclassification.interface';
import { Component, Input, OnInit } from '@angular/core';
import { CapturingVerification } from '../../../../shared/models/capturing-verification.interface';
import { Category } from '../../../../shared/models/category.interface';
import { IPowerClient } from '../../../../shared/models/ipower-client.interface';
import { JournalVerification } from '../../../../shared/models/journal-verification.interface';
import { VerificationRule } from './../../../../shared/models/verification-rule.interface';
import { DocumentClassification } from '../../../../shared/models/document-classification.interface';
import { ErrorHandlingService } from 'src/app/shared/services/error-handling/error-handling.service';
import { Observable } from 'rxjs';

@Component({
  selector: 'app-verification-rule-form',
  templateUrl: './verification-rule-form.component.html',
  styleUrls: ['./verification-rule-form.component.scss']
})
export class VerificationRuleFormComponent implements OnInit {

  /*
    * Inputs
    */
  @Input() dialogLayout: boolean = false;   // Controls .scss classes to allow for better dispay in a dialog.
  @Input() requiredFields: string[] | boolean = false;  // True/False indicates that all/none are required. String[] specifies the form controls required.
  @Input() displayValidationMessagesEvenIfPristine: boolean = false;  // Serves for manually treating the controls as dirty.
  @Input() excludedFormControls: string[];  // Specifies the form controls to be removed and NOT displayed.

  /*
   * Reactive Form
   */
  verificationRuleForm = this.fb.group({
    documentClassification: [null],
    ipowerName: [null],
    ipowerCode: [null],
    categoryName: [null],
    categoryCode: [null],
    subCategoryCode: [null],   // This actually represents the complete DocumentSubclassification object.
    confidenceLevelMinThreshold: [null],
    capturingVerification: [null],
    journalVerification: [null],
    alteryxRoutineId: [null],
    verificationRuleStatus: [true],
    template: [null]
  });
  initiallySetFormValue: VerificationRule;
  editMode: boolean = false;

  /*
   * Other Variables
   */
  documentClassificationsList: DocumentClassification[];

  categoryNameSuggestions: string[];
  categoryCodeSuggestions: string[];
  categorySuggestions: Category[];
  selectedCategory: Category;

  iPowerClientNameSuggestions: string[];
  iPowerClientCodeSuggestions: string[];
  iPowerClientSuggestions: IPowerClient[];
  selectedIPowerClient: IPowerClient;

  capturingVerificationsList: CapturingVerification[];
  journalVerificationsList: JournalVerification[];

  documentSubclassificationsList: DocumentSubclassification[];
  availableDocumentSubclassifications: DocumentSubclassification[];
  subCategoryCodeDisabled: boolean = true;

  /*
   * Constructor & Initialisers
   */
  constructor(
    private fb: FormBuilder,
    private documentClassificationsService: DocumentClassificationsService,
    private categoriesService: CategoriesService,
    private iPowerClientsService: IpowerClientsService,
    private documentSubclassificationsService: DocumentSubclassificationsService,
    private capturingVerificationsService: CapturingVerificationsService,
    private journalVerificationsService: JournalVerificationsService,
    private authService: AuthService,
    private errorHandlingService: ErrorHandlingService

  ) { }

  ngOnInit(): void {
    this.initData();
    this.initValidators()
    this.excludeFields();
  }

  initData() {
    this.documentClassificationsService.getAll().subscribe(
      value => this.documentClassificationsList = value,
      err => this.errorHandlingService.showHttpResponseError(err)
    );

    // This is NOT the list of Subclassifications used for the dropdown.
    this.documentSubclassificationsService.getAll().subscribe(
      value => this.documentSubclassificationsList = value,
      err => this.errorHandlingService.showHttpResponseError(err)
    );

    this.journalVerificationsService.getJournalVerifications().subscribe(
      values => this.journalVerificationsList = values,
      err => this.errorHandlingService.showHttpResponseError(err)
    );

    this.capturingVerificationsService.getCapturingVerifications().subscribe(
      values => this.capturingVerificationsList = values,
      err => this.errorHandlingService.showHttpResponseError(err)
    );
  }

  // TODO: Have this mechanism offer the use of custom validators too.
  initValidators() {

    if (!this.requiredFields) { return; }

    // In a true/false case.
    if (typeof this.requiredFields == 'boolean') {
      // If true, enable the required validator for all controls.
      if (this.requiredFields) {
        Object.keys(this.verificationRuleForm.controls).forEach(key => this.verificationRuleForm.controls[key].setValidators(Validators.required));
      }

      // If false, do nothing.
      return;
    }

    // If it was a string array, enable the validators for all provided field-names.
    (<string[]>this.requiredFields).forEach(field => this.verificationRuleForm.controls[field].setValidators(Validators.required))
  }

  excludeFields() {
    if (!this.excludedFormControls) { return; }
    this.excludedFormControls.forEach(field => this.verificationRuleForm.removeControl(field));
  }

  /*
   * Auto-suggest & Auto-complete Category
   */
  autosuggestCategoryName(event) {

    if (!event.query || event.query.length < 3) {
      this.categoryNameSuggestions = [];
      return;
    }

    let classId = this.verificationRuleForm.get('documentClassification').value ? this.verificationRuleForm.get('documentClassification').value.classificationId : null;
    this.categoriesService.autosuggestCategoryName(event.query, classId).subscribe(
      (values: Category[]) => {
        let temp: string[] = [];
        this.categorySuggestions = values;
        values.map(val => temp.push(val.categoryName));
        this.categoryNameSuggestions = temp
      },
      err => this.errorHandlingService.showHttpResponseError(err)
    );
  }

  autosuggestCategoryCode(event) {

    if (event.query.length < 3) {
      this.categoryCodeSuggestions = [];
      return;
    }

    let classId = this.verificationRuleForm.get('documentClassification').value ? this.verificationRuleForm.get('documentClassification').value.classificationId : null;
    this.categoriesService.autosuggestCategoryCode(event.query, classId).subscribe(
      (values: Category[]) => {
        let temp: string[] = [];
        this.categorySuggestions = values;
        values.map(val => temp.push(val.categoryCode));
        this.categoryCodeSuggestions = temp
      },
      err => this.errorHandlingService.showHttpResponseError(err)
    );
  }

  categoryNameSelected(name: string) {
    this.selectedCategory = this.categorySuggestions.find(cat => cat.categoryName == name);
    this.verificationRuleForm.get('categoryCode').patchValue(this.selectedCategory.categoryCode);
    this.verificationRuleForm.updateValueAndValidity();
  }

  categoryCodeSelected(code: string) {
    this.selectedCategory = this.categorySuggestions.find(cat => cat.categoryCode == code);
    this.verificationRuleForm.get('categoryName').patchValue(this.selectedCategory.categoryName);
    this.verificationRuleForm.updateValueAndValidity();
  }

  // /*
  //  * Auto-suggest & Auto-complete IPower Client
  //  */
  // /*
  //  * Rights-check Warning:
  //  * If we are NOT in editMode (and are thus on "addMode"), we should only suggest clients for which we actually CAN add a new rule.
  //  * Note:
  //  * I know that if on editMode the client-input is disabled and thus this check is redundant,
  //  * but I think it is better to work with as an abstract perspective as possible, not entailing business logic that may either be unrelated or prone to changes.
  //  */
  // autosuggestIPowerClientName(event) {

  //   if (!event.query || event.query.length < 3) {
  //     this.iPowerClientNameSuggestions = [];
  //     return;
  //   }

  //   // If the user has the right to preview all rules (B01), we use the endpoint that returns all iPowerClients,
  //   // otherwise, the one that checks for the user's User_Access too. Whether the user can see ANY rule has already been handled by the 'search' button.
  //   let endpointToSubscribeTo: Observable<IPowerClient[]> = USER_RIGHTS.B01.isGrantedToUser(
  //     this.authService.userRights.find(rbc => rbc.client.id == environment.globalRightsClientID)?.rights
  //   )
  //     ? this.iPowerClientsService.getClientsByNameOnly(event.query)
  //     : this.iPowerClientsService.getClientsByNameDistinct(event.query);

  //   endpointToSubscribeTo.subscribe(
  //     (values: IPowerClient[]) => {

  //       // ***See comment at method level***
  //       if (!this.editMode) {
  //         values = values.filter(client => USER_RIGHTS.B03.isGrantedToUser(
  //           this.authService.userRights.find(rdc => rdc.client.id == client.id)?.rights
  //         ));
  //       }

  //       let temp: string[] = [];
  //       this.iPowerClientSuggestions = values;
  //       values.map(val => temp.push(val.name));
  //       this.iPowerClientNameSuggestions = temp
  //     },
  //     err => this.errorHandlingService.showHttpResponseError(err)
  //   );
  // }

  // /*
  //  * Rights-check Warning:
  //  * If we are NOT in editMode (and are thus on "addMode"), we should only suggest clients for which we actually CAN add a new rule.
  //  * Note:
  //  * I know that if on editMode the client-input is disabled and thus this check is redundant,
  //  * but I think it is better to work with as an abstract perspective as possible, not entailing business logic that may either be unrelated or prone to changes.
  //  */
  // autosuggestIPowerClientCode(event) {

  //   if (event.query.length < 3) {
  //     this.iPowerClientCodeSuggestions = [];
  //     return;
  //   }

  //   // If the user has the right to preview all rules (B01), we use the endpoint that returns all iPowerClients,
  //   // otherwise, the one that checks for the user's User_Access too. Whether the user can see ANY rule has already been handled by the 'search' button.
  //   let endpointToSubscribeTo: Observable<IPowerClient[]> = USER_RIGHTS.B01.isGrantedToUser(
  //     this.authService.userRights.find(rbc => rbc.client.id == environment.globalRightsClientID)?.rights
  //   )
  //     ? this.iPowerClientsService.getClientsByCodeOnly(event.query): null;

  //   endpointToSubscribeTo.subscribe(
  //     (values: IPowerClient[]) => {

  //       // ***See comment at method level***
  //       if (!this.editMode) {
  //         values = values;
  //       }

  //       let temp: string[] = [];
  //       this.iPowerClientSuggestions = values;
  //       values.map(val => temp.push(val.clientCode));
  //       this.iPowerClientCodeSuggestions = temp
  //     },
  //     err => this.errorHandlingService.showHttpResponseError(err)
  //   );
  // }


   /*
  * Auto-suggest & Auto-complete IPower Client
  */
 autosuggestIPowerClientName(event): void {

  if (!event.query || event.query.length < 3) {
    this.iPowerClientNameSuggestions = [];
    return;
  }

  this.iPowerClientsService.getClientsByNameOnly(event.query).subscribe(
    (values: IPowerClient[]) => {
      this.iPowerClientSuggestions = values;

      const temp: string[] = [];
      values.map(val => temp.push(val.name));
      this.iPowerClientNameSuggestions = temp;
    },
    err => this.errorHandlingService.showHttpResponseError(err)
  );
}

  autosuggestIPowerClientCode(event): void {

    if (event.query.length < 3) {
      this.iPowerClientCodeSuggestions = [];
      return;
    }

    this.iPowerClientsService.getClientsByCodeOnly(event.query).subscribe(
      (values: IPowerClient[]) => {
        this.iPowerClientSuggestions = values;

        const temp: string[] = [];
        values.map(val => temp.push(val.clientCode));
        this.iPowerClientCodeSuggestions = temp;
      },
      err => this.errorHandlingService.showHttpResponseError(err)
    );
  }

  iPowerClientNameSelected(name: string) {
    this.selectedIPowerClient = this.iPowerClientSuggestions.find(client => client.name == name);
    this.verificationRuleForm.get('ipowerCode').patchValue(this.selectedIPowerClient.clientCode);
    this.verificationRuleForm.updateValueAndValidity();
  }

  iPowerClientCodeSelected(code: string) {
    this.selectedIPowerClient = this.iPowerClientSuggestions.find(client => client.clientCode == code);
    this.verificationRuleForm.get('ipowerName').patchValue(this.selectedIPowerClient.name);
    this.verificationRuleForm.updateValueAndValidity();
  }

  /*
   * Other Methods
   */
  documentClassificationSelected(selection) {
    this.availableDocumentSubclassifications = this.documentSubclassificationsList.filter(element => element.documentClassification.classificationId == selection.value.classificationId);
    this.verificationRuleForm.get('subCategoryCode').setValue(this.availableDocumentSubclassifications[0]);
    this.subCategoryCodeDisabled = false;
  }

  /*
   * Utility Methods
   */
  initiateEditMode() {
    // let controlsToDisableInEditMode = ['documentClassification', 'ipowerName', 'ipowerCode', 'categoryName', 'categoryCode', 'subCategoryCode']
    // controlsToDisableInEditMode.forEach(ctrl => this.verificationRuleForm.get(ctrl).disable());
  }


  // Auto-suggest inputs  - We have to ensure our reactive form holds values that represent the selectedCategory, otherwise truncate it.
  syncSelectedCategory() {

    // Ιf our form has no value, truncate the selectedCategory either way.
    if (!this.verificationRuleForm.get('categoryName').value && !this.verificationRuleForm.get('categoryCode').value) {
      this.selectedCategory = null;
      return;
    }

    // If both or either of our form's values match the selectedCategory's and the other one doesn't have a value, all is good.
    // Just sync the values in case one is missing. Otherwise truncate the selectedCategory.
    if (
      this.verificationRuleForm.get('categoryName').value == this.selectedCategory.categoryName
      || this.verificationRuleForm.get('categoryCode').value == this.selectedCategory.categoryCode
    ) {
      this.selectedCategory.categoryName = this.verificationRuleForm.get('categoryName').value;
      this.selectedCategory.categoryCode = this.verificationRuleForm.get('categoryCode').value;
    }

    // If both our values were different from the selectedCategory's, truncate it. This is an extremely abnormal scenario.
    else {
      console.error('WARNING - syncSelectedCategory()', 'Both of our form\'s values were different from the selectedCategory\'s.');
      this.selectedCategory = null;
      this.verificationRuleForm.get('categoryName').setValue('');
      this.verificationRuleForm.get('categoryCode').setValue('');
      this.verificationRuleForm.updateValueAndValidity();
    }
  }

  // Auto-suggest inputs  - We have to ensure our reactive form holds values that represent the selectedIPowerClient, otherwise truncate it.
  syncSelectedIPowerClient() {

    // Ιf our form has no value, truncate the selectedIPowerClient either way.
    if (!this.verificationRuleForm.get('ipowerName').value && !this.verificationRuleForm.get('ipowerCode').value) {
      this.selectedIPowerClient = null;
      return;
    }

    // If both or either of our form's values match the selectedIPowerClient's and the other one doesn't have a value, all is good.
    // Just sync the values in case one is missing. Otherwise truncate the selectedIPowerClient.
    if (
      this.verificationRuleForm.get('ipowerName').value == this.selectedIPowerClient.name
      || this.verificationRuleForm.get('ipowerCode').value == this.selectedIPowerClient.clientCode
    ) {
      this.selectedIPowerClient.name = this.verificationRuleForm.get('ipowerName').value;
      this.selectedIPowerClient.clientCode = this.verificationRuleForm.get('ipowerCode').value;
    }

    // If both our values were different from the selectedIPowerClient's, truncate it. This is an extremely abnormal scenario.
    else {
      console.error('WARNING - syncSelectedIPowerClient()', 'Both of our form\'s values were different from the selectedIPowerClient\'s.');
      this.selectedIPowerClient = null;
      this.verificationRuleForm.get('ipowerName').setValue('');
      this.verificationRuleForm.get('ipowerCode').setValue('');
      this.verificationRuleForm.updateValueAndValidity();
    }
  }

  /*
   * Rights-check Methods
   */
  canEditRuleStatus(): boolean {
    if (this.initiallySetFormValue) {
      return this.authService.userHasRightForClient(USER_RIGHTS.B06, environment.globalRightsClientID);
    }
    return false;
  }

  // canEditConfidenceLevel(): boolean {
  //   if (this.initiallySetFormValue) {
  //     return this.authService.userHasRightForClient(USER_RIGHTS.B07, this.initiallySetFormValue.client.id);
  //   }
  //   return false;
  // }

  /*
   * API methods
   */
  public resetForm(): void {
    this.verificationRuleForm.reset();
    this.selectedCategory = null;
    this.selectedIPowerClient = null;
    this.editMode = null;
  }

  public formValue(): CreateVerificationRuleFormValue {

    // We keep track of those two using object-variables separate from our ReactiveForm.
    // Thus, we now have to make sure the ReactiveForm really has values that match those objects, before we forward them.
    // Also, keep in mind that our auto-suggest inputs limit the user in choosing one of their values.
    this.syncSelectedCategory();
    this.syncSelectedIPowerClient();

    let formValue: CreateVerificationRuleFormValue = {
      id: this.initiallySetFormValue ? this.initiallySetFormValue.id : null,
      confidenceLevelMinThreshold: this.verificationRuleForm.get('confidenceLevelMinThreshold').value,
      clientId: this.selectedIPowerClient ? this.selectedIPowerClient.id : null,
      categoryId: this.selectedCategory ? this.selectedCategory.id : null,
      // The backend only requires the subcategory's name, and not the whole object. Don't ask me.
      subCategoryCode: this.verificationRuleForm.get('subCategoryCode').value ? this.verificationRuleForm.get('subCategoryCode').value['subclassificationName'] : '',
      capturingVerification: this.verificationRuleForm.get('capturingVerification').value,
      journalVerification: this.verificationRuleForm.get('journalVerification').value,
      alteryxRoutineId: this.verificationRuleForm.get('alteryxRoutineId').value,
      template: this.verificationRuleForm.get('template').value,

      // Convert 'verificationRuleStatus' from boolean to string.
      verificationRuleStatus: this.verificationRuleForm.get('verificationRuleStatus').value ? 'Enabled' : 'Disabled'
    };

    return formValue;
  }

  public setValue(value: VerificationRule): void {
    if (!value) {
      return;
    }

    this.editMode = true;
    this.initiateEditMode();

    this.initiallySetFormValue = value

    // If a documentClassification is already selected, enable the subclassification dropdown.
    this.subCategoryCodeDisabled = !value.docClassificationCategory;

    this.verificationRuleForm.get('documentClassification').setValue(value.docClassificationCategory);
    // Having set the documentClassification -and provided there was one- we must also set the availableDocumentSubclassifications.
    this.availableDocumentSubclassifications = this.documentSubclassificationsList.filter(element =>
      element.documentClassification.classificationId == value.docClassificationCategory.classificationId
    );

    this.verificationRuleForm.get('ipowerName').setValue(value.client.name);
    this.verificationRuleForm.get('ipowerCode').setValue(value.client.clientCode);
    this.selectedIPowerClient = value.client;

    this.verificationRuleForm.get('categoryName').setValue(value.template.category.categoryName);
    this.verificationRuleForm.get('categoryCode').setValue(value.template.category.categoryCode);
    this.selectedCategory = value.template.category;

    this.verificationRuleForm.get('confidenceLevelMinThreshold').setValue(value.confidenceLevelMinThreshold);
    this.verificationRuleForm.get('capturingVerification').setValue(value.capturingVerification);
    this.verificationRuleForm.get('journalVerification').setValue(value.journalVerification);
    this.verificationRuleForm.get('alteryxRoutineId').setValue(value.alteryxRoutineId);
    this.verificationRuleForm.get('template').setValue(value.template);

    // Convert 'verificationRuleStatus' from string to boolean.
    this.verificationRuleForm.get('verificationRuleStatus').setValue(value.verificationRuleStatus.trim().toLowerCase() == 'enabled');

    // To set the subcategory/subclassification we also have to make sure the documentClassification is the same.
    // WARNING: Since we have enabled the [forceSelection] option of the <p-autoComplete>,
    // if the availableDocumentSubclassifications are not set, documentSubclassification won't be displayed.
    this.verificationRuleForm.get('subCategoryCode').setValue(
      this.documentSubclassificationsList.find(subClass =>
        subClass.subclassificationName == value.template.subCategoryCode && subClass.documentClassification.classificationId == value.docClassificationCategory.classificationId
      )
    );

    this.verificationRuleForm.updateValueAndValidity();
  }

  public isValid(): boolean {
    return this.verificationRuleForm.valid;
  }

  public initForCreation() {
    this.editMode = false;
    this.verificationRuleForm.get('verificationRuleStatus').setValue(true); // The default value in creation mode.
    this.verificationRuleForm.get('template').setValidators(null);  // 'template' is not required during the creation.
  }
}