import { CompassEventType } from '@atlassian/forge-graphql-types';
import './helpers/mockRequestAtlassian';
import api from '../../index';
import {
  MOCK_CLOUD_ID,
  MOCK_ERROR_MESSAGE,
  MOCK_ERROR_TYPE,
  MOCK_EXTERNAL_EVENT_SOURCE_ID,
  MOCK_QUERY_ERROR,
} from '../fixtures/mocks';
import { mockRequestGraph } from './helpers/requestMocks';
import { GRAPHQL_GATEWAY_SOURCE } from '../../helpers/constants';

const compassApp = api.compass.asApp();

// @ts-ignore
const requestGraphSpy = jest.spyOn(compassApp.api, 'requestGraph');

describe('getEventSource', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  describe('error handling', () => {
    test('transforms GqlErrors', async () => {
      mockRequestGraph(requestGraphSpy, [
        {
          message: MOCK_ERROR_MESSAGE,
          extensions: {
            errorSource: GRAPHQL_GATEWAY_SOURCE,
            classification: MOCK_ERROR_TYPE,
          },
        },
      ]);
      const resp = await compassApp.getEventSource({
        cloudId: MOCK_CLOUD_ID,
        eventType: CompassEventType.Deployment,
        externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
      });

      expect(resp.success).toBeFalsy();
      expect(resp.errors.length).toEqual(1);
      expect(resp).toMatchInlineSnapshot(`
        Object {
          "data": Object {
            "eventSource": null,
          },
          "errors": Array [
            Object {
              "errorSource": "GRAPHQL_GATEWAY",
              "errorType": "MockErrorType",
              "message": "Mock error message",
            },
          ],
          "success": false,
        }
      `);
    });

    test('transforms event source QueryErrors', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          eventSource: MOCK_QUERY_ERROR,
        },
      } as any);
      const resp = await compassApp.getEventSource({
        cloudId: MOCK_CLOUD_ID,
        eventType: CompassEventType.Deployment,
        externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
      });

      expect(resp.success).toBeFalsy();
      expect(resp.errors.length).toEqual(1);
      expect(resp).toMatchInlineSnapshot(`
        Object {
          "data": Object {
            "eventSource": null,
          },
          "errors": Array [
            Object {
              "errorSource": "GRAPHQL_GATEWAY",
              "errorType": "MockErrorType",
              "message": "Mock error message",
              "statusCode": 500,
            },
          ],
          "success": false,
        }
      `);
    });

    test('transforms event source events QueryErrors', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          eventSource: {
            events: MOCK_QUERY_ERROR,
          },
        },
      } as any);
      const resp = await compassApp.getEventSource({
        cloudId: MOCK_CLOUD_ID,
        eventType: CompassEventType.Deployment,
        externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
        options: {
          includeEvents: true,
        },
      });

      expect(resp.success).toBeFalsy();
      expect(resp.errors.length).toEqual(1);
      expect(resp).toMatchInlineSnapshot(`
        Object {
          "data": Object {
            "eventSource": null,
          },
          "errors": Array [
            Object {
              "errorSource": "GRAPHQL_GATEWAY",
              "errorType": "MockErrorType",
              "message": "Mock error message",
              "statusCode": 500,
            },
          ],
          "success": false,
        }
      `);
    });
  });

  test('transforms successful event source result', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        eventSource: {
          externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
          events: {
            pageInfo: {
              hasNextPage: false,
            },
            nodes: [
              {
                displayName: '#1',
              },
            ],
          },
        },
      },
    } as any);

    const resp = await compassApp.getEventSource({
      cloudId: MOCK_CLOUD_ID,
      eventType: CompassEventType.Deployment,
      externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
      options: {
        includeEvents: true,
      },
    });

    expect(resp).toMatchInlineSnapshot(`
      Object {
        "data": Object {
          "eventSource": Object {
            "events": Object {
              "nodes": Array [
                Object {
                  "displayName": "#1",
                },
              ],
              "pageInfo": Object {
                "hasNextPage": false,
              },
            },
            "externalEventSourceId": "mock-external-event-source-id",
          },
        },
        "errors": Array [],
        "success": true,
      }
    `);
  });

  test('handles event query input', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        eventSource: {
          externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
          events: {
            pageInfo: {
              hasNextPage: false,
            },
            nodes: [
              {
                displayName: '#1',
              },
            ],
          },
        },
      },
    } as any);

    const resp = await compassApp.getEventSource({
      cloudId: MOCK_CLOUD_ID,
      eventType: CompassEventType.Deployment,
      externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
      options: {
        includeEvents: true,
        eventsQuery: {
          first: 10,
          after: 'somecursor',
          timeParameters: {
            endAt: '2022-01-29T00:55:29.795Z',
          },
        },
      },
    });

    expect(requestGraphSpy.mock.calls).toMatchSnapshot();
    expect(resp).toMatchInlineSnapshot(`
      Object {
        "data": Object {
          "eventSource": Object {
            "events": Object {
              "nodes": Array [
                Object {
                  "displayName": "#1",
                },
              ],
              "pageInfo": Object {
                "hasNextPage": false,
              },
            },
            "externalEventSourceId": "mock-external-event-source-id",
          },
        },
        "errors": Array [],
        "success": true,
      }
    `);
  });

  test('does not include events unless specified', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        eventSource: {
          externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
        },
      },
    } as any);

    await compassApp.getEventSource({
      cloudId: MOCK_CLOUD_ID,
      eventType: CompassEventType.Deployment,
      externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
    });

    expect(requestGraphSpy).toHaveBeenCalledWith(
      expect.anything(),
      {
        cloudId: MOCK_CLOUD_ID,
        eventType: CompassEventType.Deployment,
        externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
        includeEvents: false,
        eventsQuery: {},
      },
      expect.anything(),
    );
  });

  test('errors if component cannot be transformed', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      invalid_response: 'hello world',
    } as any);

    const resp = await compassApp.getEventSource({
      cloudId: MOCK_CLOUD_ID,
      eventType: CompassEventType.Deployment,
      externalEventSourceId: MOCK_EXTERNAL_EVENT_SOURCE_ID,
    });

    expect(resp).toMatchInlineSnapshot(`
      Object {
        "data": Object {
          "eventSource": null,
        },
        "errors": Array [
          Object {
            "errorSource": "FORGE_GRAPHQL",
            "errorType": "INTERNAL_SERVER_ERROR",
            "message": "The compass catalog schema has changed. Try upgrading SDK package version.",
            "statusCode": 500,
          },
        ],
        "success": false,
      }
    `);
  });
});