import { Component, Input, OnInit } from '@angular/core';
import { Validators } from '@angular/forms';
import { ClientSettingsService } from '@features/client-settings/client-settings.service';
import { FormAudience } from '@features/configure-forms/form.typing';
import { StandardProductConfigurationService } from '@features/platform-admin/standard-product-configuration/standard-product-configuration.service';
import { SignatureService } from '@features/signature/signature.service';
import { TypeaheadSelectOption, TypeSafeFormBuilder, TypeSafeFormGroup } from '@yourcause/common';
import { AnalyticsService, EventType } from '@yourcause/common/analytics';
import { I18nService } from '@yourcause/common/i18n';
import { YCModalComponent } from '@yourcause/common/modals';
import { FormTypes } from '../form.typing';
import { FormsService } from '../services/forms/forms.service';

export interface StartFromFormTemplate {
  name: string;
  description?: string;
  formId: number;
  revisionId: number;
  defaultFormLang: string;
}
export interface CreateEditFormModalResponse {
  formName: string;
  formType: FormTypes;
  defaultFormLang: string;
  description?: string;
  startFromTemplate: StartFromFormTemplate;
  requireSignature: boolean;
  signatureDescription: string;
  revisionId: number;
}

@Component({
  selector: 'gc-create-edit-form-modal',
  templateUrl: './create-edit-form-modal.component.html',
  styleUrls: ['./create-edit-form-modal.component.scss']
})
export class CreateEditFormModalComponent extends YCModalComponent<{
  formGroup: CreateEditFormModalResponse;
  openQuickAddModal: boolean;
}> implements OnInit {
  @Input() formId: number;
  @Input() revisionId: number;
  @Input() formName: string;
  @Input() formType: FormTypes;
  @Input() description: string;
  @Input() defaultFormLang: string;
  @Input() requireSignature: boolean;
  @Input() signatureDescription: string;
  @Input() revisionOptions: TypeaheadSelectOption[] = [];
  @Input() startFromTemplate: StartFromFormTemplate;
  @Input() forceFormType: FormTypes;
  @Input() hasRevisionChanges: boolean;

  formGroup: TypeSafeFormGroup<CreateEditFormModalResponse>;
  langKeys = this.clientSettingsService.selectedLanguages;
  hasInternational = this.clientSettingsService.clientSettings.hasInternational;
  formTypeOptions = this.formService.getFormTypeOptions();
  startFromTemplateOptions: TypeaheadSelectOption<StartFromFormTemplate>[];
  audience: FormAudience;
  audienceDescription = '';
  FormTypes = FormTypes;

  requireSignatureHelp = this.i18n.translate(
    'common:textRequireSignatureFormHelp',
    {},
    `It is recommended to review this feature internally to ensure it meets your organization's legal and / or audit requirements.`
  );

  constructor (
    private formBuilder: TypeSafeFormBuilder,
    private formService: FormsService,
    private clientSettingsService: ClientSettingsService,
    private standardProductService: StandardProductConfigurationService,
    private i18n: I18nService,
    private signatureService: SignatureService,
    private analyticsService: AnalyticsService
  ) {
    super();
  }

  get isEdit () {
    return !!this.formId;
  }

  get revisionUpdateNotAllowed () {
    return this.isEdit && this.hasRevisionChanges;
  }

  ngOnInit () {
    let formName = '';
    let description = '';
    let formType = this.formType || FormTypes.REQUEST;
    let defaultFormLang = null;
    let requireSignature = false;
    let signatureDescription = '';
    let startFromTemplate: StartFromFormTemplate;
    if (this.isEdit) {
      // Edit Logic to get attrs
      formName = this.formName;
      description = this.description;
      defaultFormLang = this.defaultFormLang;
      requireSignature = this.requireSignature;
      signatureDescription = this.signatureDescription;
    } else {
      // Create Logic to get attrs
      if (this.startFromTemplate) {
        formName = this.startFromTemplate.name;
        description = this.startFromTemplate.description;
        formType = this.standardProductService.getFormTypeFromFormId(this.startFromTemplate.formId);
        defaultFormLang = this.startFromTemplate.defaultFormLang;
        signatureDescription = this.signatureService.getDefaultFormSignatureDescription(formType);
      }
      if (this.forceFormType) {
        formType = this.forceFormType;
      }
    }
    this.setFormAudience(formType);
    this.setTemplateOptions(formType);
    if (this.startFromTemplateOptions.length > 0) {
      startFromTemplate = this.startFromTemplate ?
        this.startFromTemplateOptions.find((opt) => {
          return opt.value.formId === this.startFromTemplate.formId &&
            opt.value.revisionId === this.startFromTemplate.revisionId;
        })?.value :
        null;
    }
    this.formGroup = this.formBuilder.group<CreateEditFormModalResponse>({
      formName: [formName, Validators.required],
      formType: [formType, Validators.required],
      defaultFormLang: this.hasInternational ?
        [defaultFormLang, Validators.required] :
        defaultFormLang ?? this.clientSettingsService.defaultLanguage,
      description,
      startFromTemplate,
      requireSignature,
      signatureDescription,
      revisionId: this.revisionId
    });
  }

  setFormAudience (formType: FormTypes) {
    this.audience = this.formService.getAudienceFromFormType(formType);
  }

  setTemplateOptions (formType = this.formGroup?.value.formType) {
    this.audienceDescription = this.audience === FormAudience.APPLICANT ?
      this.i18n.translate(
        'FORMS:textFormDescriptionHelp',
        {},
        'The form description will appear at the top of the form in the applicant portal'
      ) :
      '';
    this.startFromTemplateOptions = this.standardProductService.getFormTemplateOptionsByAudience(
      this.audience,
      formType
    );
    /** If no templates are available, reset startFromTemplate */
    if (
      this.formGroup &&
      this.startFromTemplateOptions.length === 0
    ) {
      this.formGroup.get('startFromTemplate').setValue(null);
    }
  }

  formTypeChanged (formType: FormTypes) {
    const audience = this.formService.getAudienceFromFormType(
      formType
    );
    if (this.audience !== audience) {
      const control = this.formGroup.get('signatureDescription');
      const audienceDescription = this.signatureService.getDefaultFormSignatureDescription(
        formType
      );
      control.setValue(audienceDescription);
    }
    this.setFormAudience(formType);
    this.setTemplateOptions();
  }

  save (openQuickAddModal: boolean) {
    let signatureDescription = this.formGroup.value.requireSignature ?
      this.formGroup.value.signatureDescription :
      '';
    let requireSignature = this.formGroup.value.requireSignature;
    if (
      this.formGroup.value.formType === FormTypes.ELIGIBILITY ||
      this.formGroup.value.formType === FormTypes.ROUTING
    ) {
      signatureDescription = '';
      requireSignature = false;
    }
    this.closeModal.emit({
      formGroup: {
        ...this.formGroup.value,
        requireSignature,
        signatureDescription
      },
      openQuickAddModal
    });
    this.analyticsService.emitEvent({
      eventName: openQuickAddModal ? 'Create form and quick add' : 'Create form',
      eventType: EventType.Click,
      extras: {
        'Is template': !!this.formGroup.value.startFromTemplate,
        'Requires signature': !!requireSignature
      }
    });
  }
}