import { PfeActionsService, PfeBusinessService } from '@allianz/ngx-pfe';
import { HttpClient } from '@angular/common/http';
import { Injectable, inject } from '@angular/core';
import {
  CORE_FORMS_BACKEND_INTEGRATION_PLUGIN_OPTIONS,
  CoreFormsBackendIntegrationPluginOptions
} from './backend-integration-plugin.module';

@Injectable()
export class BackendIntegrationPlugin {
  private readonly pfeActionService = inject(PfeActionsService);
  private readonly pfeBusinessService = inject(PfeBusinessService);
  private readonly http = inject(HttpClient);
  private options = inject<CoreFormsBackendIntegrationPluginOptions>(
    CORE_FORMS_BACKEND_INTEGRATION_PLUGIN_OPTIONS
  );

  registerActions() {
    this.pfeActionService.registerAction(
      'CORE_FORMS_BACKEND_INTEGRATION',
      this.sendFormDataCoreFormsBackend.bind(this)
    );
  }

  private sendFormDataCoreFormsBackend(): Promise<void> {
    const { talyTurnstileFormfieldId, talyPrefix } = this.options;
    if (!talyTurnstileFormfieldId) {
      throw new Error(
        'Please specify the id of the field containing the Turnstile via the talyTurnstileFormfieldId in the plugin options'
      );
    }
    if (!talyPrefix) {
      throw new Error(
        'Please specify the talyPrefix of the relevant dynamic form ids in the options'
      );
    }

    const fields = this.getCoreFormsState(talyPrefix);

    const turnstileToken = fields?.[talyTurnstileFormfieldId];

    if (!turnstileToken || typeof turnstileToken !== 'string') {
      throw new Error('Could not find the turnstile token in the form');
    }

    delete fields[talyTurnstileFormfieldId];

    return this.postFormData(turnstileToken, fields);
  }

  private postFormData(
    turnstileToken: string,
    fieldsForBackend: Record<string, unknown>
  ): Promise<void> {
    const { formId, tenant, site, instance, referrer } = this.options;
    if (!formId || !tenant || !site || !instance || !referrer) {
      throw new Error(
        'Please specify the formId, tenant, site, instance and referrer in the options'
      );
    }

    const url = 'https://forms.di-api.allianz.com/prd/forms';
    const data = JSON.stringify({
      version: 1,
      formId,
      tenant,
      site,
      instance,
      referrer,
      fields: fieldsForBackend,
      turnstileCaptcha: {
        cfturnstileresponse: turnstileToken
      },
      captchaType: 'turnstile'
    });

    const options = {
      hostname: 'forms.di-api.allianz.com',
      port: 443,
      path: '/prd/forms',
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        accept: 'application/json'
      }
    };

    return new Promise<void>((resolve) => {
      this.http.post<{ message: string }>(url, data, options).subscribe({
        next: (response) => {
          this.pfeBusinessService.storeValueByExpression(
            '$.coreFormSubmissionSuccessful',
            response.message === 'successful'
          );
          resolve();
        },
        error: () => {
          this.pfeBusinessService.storeValueByExpression('$.coreFormSubmissionSuccessful', false);
          resolve();
        }
      });
    });
  }

  private getCoreFormsState(prefix: string): Record<string, unknown> {
    const pfeState = this.pfeBusinessService.getFullState();

    return Object.entries(pfeState)
      .filter(([formKey]) => formKey.startsWith(prefix)) // Filter keys that start with the prefix
      .filter(([, formfields]) => typeof formfields === 'object' && formfields !== null)
      .reduce<Record<string, unknown>>((relevantFields, [, formfields]) => {
        Object.entries(formfields).forEach(([formfieldKey, formfieldValue]) => {
          if (relevantFields[formfieldKey]) {
            console.warn(
              `The form field with id "${formfieldKey}" is present in more than one form with prefix "${prefix}". Please provide a unique id for each field.`
            );
            return;
          }
          if (formfieldValue !== null) {
            relevantFields[formfieldKey] = formfieldValue;
          }
        });
        return relevantFields;
      }, {});
  }
}