/// <reference path="../../compass-requests.ts"/>

import {
  ApiPayload,
  ComponentPayload,
  GqlError,
  MutationError,
  SdkError,
  UpdateCompassComponent,
  UpdateCompassComponentInput,
  UpdateComponentOptions,
} from '@atlassian/forge-graphql-types';
import { CompassRequests } from '../../compass-requests';
import {
  hasChanged,
  mapGqlErrors,
  mapMutationErrors,
  parsingResponseError,
} from '../../helpers';
import {
  fgqlActionSubjects,
  fgqlActions,
  fgqlSources,
} from '../../helpers/analyticTypes';

declare module '../../compass-requests' {
  interface CompassRequests {
    updateBaseComponent(
      input: UpdateCompassComponentInput & { options?: UpdateComponentOptions },
    ): Promise<ApiPayload<ComponentPayload>>;
  }
}

CompassRequests.prototype.updateBaseComponent =
  async function updateBaseComponent(this: CompassRequests, input) {
    let component = null;
    let gqlErrors: Array<GqlError>;
    let mutationErrors: Array<MutationError>;
    let errorsResp: Array<SdkError> = [];
    let data;

    try {
      const { id, name, description, ownerId, fields, customFields } = input;

      const { data: componentData } = await this.getComponent({
        componentId: id,
        options: {
          includeCustomFields: true,
        },
      });

      const currentComponent = componentData.component;

      const analyticHeaders: Record<string, string> = {};

      if (input.options?.updatedFromFile) {
        const updatedFromFileMetadata = {
          action: fgqlActions.updated,
          actionSubject: fgqlActionSubjects.component,
          actionSubjectId: id,
          source: fgqlSources.configAsCode,
        } as Record<string, string>;

        if (hasChanged(name, currentComponent?.name)) {
          updatedFromFileMetadata.name = 'true';
        }

        if (hasChanged(description, currentComponent?.description)) {
          updatedFromFileMetadata.description = 'true';
        }

        if (hasChanged(ownerId, currentComponent?.ownerId)) {
          updatedFromFileMetadata.ownerId = 'true';
        }

        if (hasChanged(fields, currentComponent?.fields)) {
          updatedFromFileMetadata.fields = 'true';
        }

        if (hasChanged(customFields, currentComponent?.customFields)) {
          updatedFromFileMetadata.customFields = 'true';
        }

        analyticHeaders.updatedFromFile = JSON.stringify(
          updatedFromFileMetadata,
        );
      }

      const resp = await this.api.requestGraph(
        UpdateCompassComponent,
        { input },
        'updateBaseComponent',
        analyticHeaders,
      );

      ({ errors: gqlErrors, data } = await resp.json());
      errorsResp = errorsResp.concat(mapGqlErrors(gqlErrors));
      ({
        updateComponent: {
          errors: mutationErrors,
          componentDetails: component,
        },
      } = data.compass);
      errorsResp = errorsResp.concat(mapMutationErrors(mutationErrors));
    } catch (e) {
      if (errorsResp.length === 0) {
        errorsResp.push(parsingResponseError(e));
      }
    }

    return {
      errors: errorsResp,
      success: errorsResp.length === 0,
      data: { component },
    };
  };