import { CompassQuerySortOrder } from '@atlassian/forge-graphql-types';
import './helpers/mockRequestAtlassian';
import api from '../../index';
import {
  MOCK_CLOUD_ID,
  MOCK_COMPONENT_AGG_WITHOUT_LINKS,
  MOCK_ERROR_MESSAGE,
  MOCK_ERROR_TYPE,
  MOCK_QUERY_ERROR,
  MOCK_SEARCH_PAGEINFO,
} 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('searchComponents', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  test('transforms GqlErrors', async () => {
    mockRequestGraph(requestGraphSpy, [
      {
        message: MOCK_ERROR_MESSAGE,
        extensions: {
          errorSource: GRAPHQL_GATEWAY_SOURCE,
          classification: MOCK_ERROR_TYPE,
        },
      },
    ]);
    const resp = await compassApp.searchComponents({
      cloudId: MOCK_CLOUD_ID,
    });

    expect(resp).toMatchSnapshot();
  });

  test('transform component QueryErrors', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        searchComponents: MOCK_QUERY_ERROR,
      },
    } as any);
    const resp = await compassApp.searchComponents({
      cloudId: MOCK_CLOUD_ID,
    });

    expect(resp).toMatchSnapshot();
  });

  test('transform component metricSources QueryErrors', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        searchComponents: {
          metricSources: MOCK_QUERY_ERROR,
        },
      },
    } as any);
    const resp = await compassApp.searchComponents({
      cloudId: MOCK_CLOUD_ID,
    });

    expect(resp).toMatchSnapshot();
  });

  test('transform successful component result', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        searchComponents: {
          nodes: [
            {
              component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
            },
          ],
          pageInfo: MOCK_SEARCH_PAGEINFO,
        },
      },
    } as any);

    const resp = await compassApp.searchComponents({
      cloudId: MOCK_CLOUD_ID,
    });

    expect(resp).toMatchSnapshot();
  });

  test('handle null and not null components in result', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        searchComponents: {
          nodes: [
            {
              component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
            },
            {
              component: null,
            },
          ],
          pageInfo: MOCK_SEARCH_PAGEINFO,
        },
      },
    } as any);

    const resp = await compassApp.searchComponents({
      cloudId: MOCK_CLOUD_ID,
    });

    expect(resp).toMatchSnapshot();
  });

  test('handle just a null component in result', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        searchComponents: {
          nodes: [
            {
              component: null,
            },
          ],
          pageInfo: MOCK_SEARCH_PAGEINFO,
        },
      },
    } as any);

    const resp = await compassApp.searchComponents({
      cloudId: MOCK_CLOUD_ID,
    });

    expect(resp).toMatchSnapshot();
  });

  test('handle query input', async () => {
    mockRequestGraph(requestGraphSpy, [], {
      compass: {
        searchComponents: {
          nodes: [
            {
              component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
            },
          ],
          pageInfo: MOCK_SEARCH_PAGEINFO,
        },
      },
    } as any);

    const resp = await compassApp.searchComponents({
      cloudId: MOCK_CLOUD_ID,
      query: {
        fieldFilters: [
          {
            name: 'type',
            filter: {
              eq: 'SERVICE',
            },
          },
        ],
        first: 100,
        sort: [
          {
            name: 'title',
            order: CompassQuerySortOrder.Asc,
          },
        ],
      },
    });

    expect(resp).toMatchSnapshot();
  });

  describe('accepts optional args', () => {
    test('accepts includeLinks', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          searchComponents: {
            nodes: [
              {
                component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
              },
            ],
            pageInfo: MOCK_SEARCH_PAGEINFO,
          },
        },
      } as any);

      await compassApp.searchComponents({
        cloudId: MOCK_CLOUD_ID,
        options: {
          includeLinks: true,
        },
      });
      expect(requestGraphSpy.mock.calls[0][1]).toMatchSnapshot();
    });

    test('accepts includeEventSources', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          searchComponents: {
            nodes: [
              {
                component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
              },
            ],
            pageInfo: MOCK_SEARCH_PAGEINFO,
          },
        },
      } as any);

      await compassApp.searchComponents({
        cloudId: MOCK_CLOUD_ID,
        options: {
          includeEventSources: true,
        },
      });
      expect(requestGraphSpy.mock.calls[0][1]).toMatchSnapshot();
    });

    test('accepts includeMetricSources', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          searchComponents: {
            nodes: [
              {
                component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
              },
            ],
            pageInfo: MOCK_SEARCH_PAGEINFO,
          },
        },
      } as any);

      await compassApp.searchComponents({
        cloudId: MOCK_CLOUD_ID,
        options: {
          includeMetricSources: true,
        },
      });
      expect(requestGraphSpy.mock.calls[0][1]).toMatchSnapshot();
    });

    test('accepts incudeCustomFields', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          searchComponents: {
            nodes: [
              {
                component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
              },
            ],
            pageInfo: MOCK_SEARCH_PAGEINFO,
          },
        },
      } as any);

      await compassApp.searchComponents({
        cloudId: MOCK_CLOUD_ID,
        options: {
          includeCustomFields: true,
        },
      });
      expect(requestGraphSpy.mock.calls[0][1]).toMatchSnapshot();
    });

    test('accepts includeCustomFieldOptions', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          searchComponents: {
            nodes: [
              {
                component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
              },
            ],
            pageInfo: MOCK_SEARCH_PAGEINFO,
          },
        },
      } as any);

      await compassApp.searchComponents({
        cloudId: MOCK_CLOUD_ID,
        options: {
          includeCustomFieldOptions: true,
        },
      });
      expect(requestGraphSpy.mock.calls[0][1]).toMatchSnapshot();
    });

    test('accepts includeExternalAliases', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          searchComponents: {
            nodes: [
              {
                component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
              },
            ],
            pageInfo: MOCK_SEARCH_PAGEINFO,
          },
        },
      } as any);

      await compassApp.searchComponents({
        cloudId: MOCK_CLOUD_ID,
        options: {
          includeExternalAliases: true,
        },
      });
      expect(requestGraphSpy.mock.calls[0][1]).toMatchInlineSnapshot(`
        Object {
          "cloudId": "a0000000-b000-c000-d000-e00000000000",
          "includeCustomFieldOptions": false,
          "includeCustomFields": false,
          "includeEventSources": false,
          "includeExternalAliases": true,
          "includeLinks": false,
          "includeMetricSources": false,
          "query": undefined,
        }
      `);
    });

    test('accepts all options', async () => {
      mockRequestGraph(requestGraphSpy, [], {
        compass: {
          searchComponents: {
            nodes: [
              {
                component: MOCK_COMPONENT_AGG_WITHOUT_LINKS,
              },
            ],
            pageInfo: MOCK_SEARCH_PAGEINFO,
          },
        },
      } as any);

      await compassApp.searchComponents({
        cloudId: MOCK_CLOUD_ID,
        options: {
          includeLinks: true,
          includeEventSources: true,
          includeMetricSources: true,
          includeExternalAliases: true,
          includeCustomFields: true,
          includeCustomFieldOptions: true,
        },
      });
      expect(requestGraphSpy.mock.calls[0][1]).toMatchSnapshot();
    });
  });

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

    const resp = await compassApp.searchComponents({
      cloudId: MOCK_CLOUD_ID,
    });

    expect(resp).toMatchSnapshot();
  });
});