/* eslint-disable import/first, import/order */

import { SDK_SCHEMA_ERROR } from '../../helpers';
import {
  mockAggCompassRequests,
  mockDeleteExternalAlias,
} from './helpers/mockCompassRequests';

mockAggCompassRequests();

import api from '../../index';

import {
  CompassExternalAliasInput,
  DeleteCompassComponentExternalAliasInput,
} from '@atlassian/forge-graphql-types';
import {
  EXTERNAL_ALIAS_SOURCE_COMPONENT_NAME,
  EXTERNAL_ALIAS_SOURCE_COMPONENT_PATH_TO_FILE,
} from '../../requests/config-as-code-requests/helpers/createOrUpdateComponent/constants';
// eslint-disable-next-line max-len
import { generateExternalIdWithPrefix } from '../../requests/config-as-code-requests/helpers/createOrUpdateComponent/helpers';
import {
  createExternalAliasesToBeDeleted,
  deleteAliasesByCreateFromYaml,
  isManagedExternalAliasSource,
} from '../../requests/config-as-code-requests/helpers/unlinkComponent/externalAliasManager';
import {
  MOCK_COMPONENT_ID,
  MOCK_COMPONENT_NAME,
  MOCK_COMPONENT_OLD_PATH,
  MOCK_DEDUPLICATION_ID,
  MOCK_EXTERNAL_ALIAS,
  getManagedComponentAliases,
  getMockedComponent,
} from '../fixtures/mocks';

const compassApp = api.compass.asApp();

describe('externalAliasManager', () => {
  const NAME_ALIAS_ID = generateExternalIdWithPrefix(
    MOCK_DEDUPLICATION_ID,
    MOCK_COMPONENT_NAME,
  );
  const OLD_PATH_ALIAS_ID = generateExternalIdWithPrefix(
    MOCK_DEDUPLICATION_ID,
    MOCK_COMPONENT_OLD_PATH,
  );
  const NAME_ALIAS = {
    externalId: NAME_ALIAS_ID,
    externalSource: EXTERNAL_ALIAS_SOURCE_COMPONENT_NAME,
  };
  const PATH_ALIAS = {
    externalId: OLD_PATH_ALIAS_ID,
    externalSource: EXTERNAL_ALIAS_SOURCE_COMPONENT_PATH_TO_FILE,
  };

  beforeEach(() => {
    jest.clearAllMocks();
  });

  describe('isManagedExternalAliasSource', () => {
    it('isManagedExternalAliasSource - True Scenarios', () => {
      const managedAliases = getManagedComponentAliases({});
      managedAliases.map((alias) => {
        expect(isManagedExternalAliasSource(alias.externalSource)).toBeTruthy();
        return {};
      });
    });

    it('isManagedExternalAliasSource - False Scenarios', () => {
      expect(isManagedExternalAliasSource('')).toBeFalsy();
      expect(isManagedExternalAliasSource(null)).toBeFalsy();
      expect(isManagedExternalAliasSource(undefined)).toBeFalsy();
      expect(
        isManagedExternalAliasSource('something-else-as-the-source'),
      ).toBeFalsy();
    });
  });
  describe('createExternalAliasesToBeDeleted', () => {
    test('created array should contain Name and Path external aliases', () => {
      const component = getMockedComponent({
        externalAliases: getManagedComponentAliases({
          path: MOCK_COMPONENT_OLD_PATH,
        }),
      });
      const externalAliases = createExternalAliasesToBeDeleted({
        component,
      });
      // validations
      expect(externalAliases.length).toEqual(2);
      expect(externalAliases).toContainEqual({
        externalId: NAME_ALIAS_ID,
        externalSource: EXTERNAL_ALIAS_SOURCE_COMPONENT_NAME,
      } as CompassExternalAliasInput);
      expect(externalAliases).toContainEqual({
        externalId: OLD_PATH_ALIAS_ID,
        externalSource: EXTERNAL_ALIAS_SOURCE_COMPONENT_PATH_TO_FILE,
      } as CompassExternalAliasInput);
    });

    test('created array should contain OTHER external aliases', () => {
      const component = getMockedComponent({
        externalAliases: getManagedComponentAliases({
          path: MOCK_COMPONENT_OLD_PATH,
        }),
      });
      const externalAliases = createExternalAliasesToBeDeleted({
        component,
        otherExternalAliases: [MOCK_EXTERNAL_ALIAS],
      });
      // validations
      expect(externalAliases.length).toEqual(3);
      expect(externalAliases).toContainEqual({
        externalId: NAME_ALIAS_ID,
        externalSource: EXTERNAL_ALIAS_SOURCE_COMPONENT_NAME,
      } as CompassExternalAliasInput);
      expect(externalAliases).toContainEqual({
        externalId: OLD_PATH_ALIAS_ID,
        externalSource: EXTERNAL_ALIAS_SOURCE_COMPONENT_PATH_TO_FILE,
      } as CompassExternalAliasInput);
      expect(externalAliases).toContainEqual(
        MOCK_EXTERNAL_ALIAS as CompassExternalAliasInput,
      );
    });
  });

  describe('deleteAliasesByCreateFromYaml', () => {
    function setupMockDeleteManagedExternalAlias() {
      mockDeleteExternalAlias.mockResolvedValueOnce({
        errors: [],
        success: true,
        data: {
          externalAlias: NAME_ALIAS,
        },
      });

      mockDeleteExternalAlias.mockResolvedValueOnce({
        errors: [],
        success: true,
        data: {
          externalAlias: PATH_ALIAS,
        },
      });
    }
    function getDeleteCompassComponentExternalAliasInput(
      alias: CompassExternalAliasInput,
    ): DeleteCompassComponentExternalAliasInput {
      return {
        componentId: MOCK_COMPONENT_ID,
        externalAlias: alias,
      } as DeleteCompassComponentExternalAliasInput;
    }
    test('Delete external aliases successfully', async () => {
      // mocks
      const component = getMockedComponent({
        externalAliases: getManagedComponentAliases({
          path: MOCK_COMPONENT_OLD_PATH,
        }),
      });
      setupMockDeleteManagedExternalAlias();
      // method under test
      const deleteExternalAliasState = await deleteAliasesByCreateFromYaml(
        compassApp,
        component,
      );

      // validations
      expect(mockDeleteExternalAlias).toBeCalledWith(
        expect.objectContaining(
          getDeleteCompassComponentExternalAliasInput(NAME_ALIAS),
        ),
      );
      expect(mockDeleteExternalAlias).toBeCalledWith(
        expect.objectContaining(
          getDeleteCompassComponentExternalAliasInput(PATH_ALIAS),
        ),
      );
      expect(mockDeleteExternalAlias).toBeCalledTimes(2);
      expect(deleteExternalAliasState.success).toEqual(true);
      expect(deleteExternalAliasState.errors.length).toEqual(0);
      expect(deleteExternalAliasState.unDeletedAliasCount).toEqual(0);
      expect(deleteExternalAliasState.totalAliasCount).toEqual(2);
    });

    test('Delete external aliases fails', async () => {
      // mocks
      const component = getMockedComponent({
        externalAliases: getManagedComponentAliases({
          path: MOCK_COMPONENT_OLD_PATH,
        }),
      });
      mockDeleteExternalAlias.mockRejectedValue(SDK_SCHEMA_ERROR);

      // validations
      const deleteExternalAliasState = await deleteAliasesByCreateFromYaml(
        compassApp,
        component,
      );
      expect(mockDeleteExternalAlias).toBeCalledWith(
        expect.objectContaining(
          getDeleteCompassComponentExternalAliasInput(NAME_ALIAS),
        ),
      );
      expect(mockDeleteExternalAlias).toBeCalledWith(
        expect.objectContaining(
          getDeleteCompassComponentExternalAliasInput(PATH_ALIAS),
        ),
      );
      expect(mockDeleteExternalAlias).toBeCalledTimes(2);
      expect(deleteExternalAliasState.success).toEqual(false);
      expect(deleteExternalAliasState.errors.length).toEqual(2);
      expect(deleteExternalAliasState.unDeletedAliasCount).toEqual(2);
      expect(deleteExternalAliasState.totalAliasCount).toEqual(2);
    });

    test('Partially deletes external aliases', async () => {
      // mocks
      const component = getMockedComponent({
        externalAliases: getManagedComponentAliases({
          path: MOCK_COMPONENT_OLD_PATH,
        }),
      });
      mockDeleteExternalAlias.mockResolvedValueOnce({
        errors: [],
        success: true,
        data: {
          externalAlias: NAME_ALIAS,
        },
      });
      mockDeleteExternalAlias.mockRejectedValue({
        errors: [SDK_SCHEMA_ERROR],
        success: false,
        data: { externalAlias: null },
      });

      // method under test
      const deleteExternalAliasState = await deleteAliasesByCreateFromYaml(
        compassApp,
        component,
        [MOCK_EXTERNAL_ALIAS],
      );

      // validations
      expect(mockDeleteExternalAlias).toBeCalledWith(
        expect.objectContaining(
          getDeleteCompassComponentExternalAliasInput(NAME_ALIAS),
        ),
      );
      expect(mockDeleteExternalAlias).toBeCalledWith(
        expect.objectContaining(
          getDeleteCompassComponentExternalAliasInput(PATH_ALIAS),
        ),
      );
      expect(mockDeleteExternalAlias).toBeCalledWith(
        expect.objectContaining(
          getDeleteCompassComponentExternalAliasInput(MOCK_EXTERNAL_ALIAS),
        ),
      );
      // 3 calls = 1 call for Name, Path and mocked alias
      expect(mockDeleteExternalAlias).toBeCalledTimes(3);
      expect(deleteExternalAliasState.success).toEqual(false);
      expect(deleteExternalAliasState.errors.length).toEqual(2);
      expect(deleteExternalAliasState.unDeletedAliasCount).toEqual(2);
      expect(deleteExternalAliasState.totalAliasCount).toEqual(3);
    });
  });
});