import {
  BuiltinMetricDefinitions,
  DataProviderEventTypes,
} from '@atlassian/forge-graphql-types';
import {
  DataProviderError,
  DataProviderResponse,
} from '../../builders/data-provider-response';
import {
  MOCK_DATA_PROVIDER_ALERT_EVENT,
  MOCK_DATA_PROVIDER_BUILD_EVENT,
  MOCK_DATA_PROVIDER_CUSTOM_EVENT,
  MOCK_DATA_PROVIDER_DEPLOYMENT_EVENT,
  MOCK_DATA_PROVIDER_FLAG_EVENT,
  MOCK_DATA_PROVIDER_INCIDENT_EVENT,
  MOCK_DATA_PROVIDER_LIFECYCLE_EVENT,
  MOCK_DATA_PROVIDER_PULL_REQUEST_EVENT,
  MOCK_DATA_PROVIDER_PUSH_EVENT,
  MOCK_DATA_PROVIDER_VULNERABILITY_EVENT,
} from '../fixtures/mocks';

describe('data provider class tests', () => {
  it('can build a response', () => {
    const dp = new DataProviderResponse('test123', {
      eventTypes: [],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    });
    expect(dp.build()).toMatchSnapshot();
  });

  it('can create empty event and metric sources', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.BUILDS],
      builtInMetricDefinitions: [BuiltinMetricDefinitions.BUILD_SUCCESS_RATE],
      customMetricDefinitions: [],
    }).build();
    expect(response.metrics).toEqual({
      builtIn: {
        'ari:cloud:compass::metric-definition/builtin/build-success-rate': {
          initialValue: null,
        },
      },
    });
    expect(response.events).toEqual({
      builds: {
        initialValues: null,
      },
    });
  });

  it('can pass in buildInMetricDefinition object', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [],
      builtInMetricDefinitions: [
        { name: BuiltinMetricDefinitions.BUILD_SUCCESS_RATE, derived: false },
      ],
      customMetricDefinitions: [],
    }).build();
    expect(response.metrics).toEqual({
      builtIn: {
        'ari:cloud:compass::metric-definition/builtin/build-success-rate': {
          derived: false,
          initialValue: null,
        },
      },
    });
  });

  it('can create derived metric source', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.BUILDS],
      builtInMetricDefinitions: [
        { name: BuiltinMetricDefinitions.BUILD_SUCCESS_RATE, derived: true },
      ],
      customMetricDefinitions: [],
    }).build();
    expect(response.metrics).toEqual({
      builtIn: {
        'ari:cloud:compass::metric-definition/builtin/build-success-rate': {
          initialValue: null,
          derived: true,
        },
      },
    });
  });

  it('can supply alert event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.ALERTS],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addAlerts([MOCK_DATA_PROVIDER_ALERT_EVENT])
      .build();
    expect(response.events).toEqual({
      alerts: {
        initialValues: [MOCK_DATA_PROVIDER_ALERT_EVENT],
      },
    });
  });

  it('can supply build event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.BUILDS],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addBuilds([MOCK_DATA_PROVIDER_BUILD_EVENT])
      .build();
    expect(response.events).toEqual({
      builds: {
        initialValues: [MOCK_DATA_PROVIDER_BUILD_EVENT],
      },
    });
  });

  it('can supply custom event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.CUSTOM],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addCustomEvents([MOCK_DATA_PROVIDER_CUSTOM_EVENT])
      .build();
    expect(response.events).toEqual({
      custom: {
        initialValues: [MOCK_DATA_PROVIDER_CUSTOM_EVENT],
      },
    });
  });

  it('can supply deployment event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.DEPLOYMENTS],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addDeployments([MOCK_DATA_PROVIDER_DEPLOYMENT_EVENT])
      .build();
    expect(response.events).toEqual({
      deployments: {
        initialValues: [MOCK_DATA_PROVIDER_DEPLOYMENT_EVENT],
      },
    });
  });

  it('can supply flag event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.FLAGS],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addFlags([MOCK_DATA_PROVIDER_FLAG_EVENT])
      .build();
    expect(response.events).toEqual({
      flags: {
        initialValues: [MOCK_DATA_PROVIDER_FLAG_EVENT],
      },
    });
  });

  it('can supply incident event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.INCIDENTS],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addIncidents([MOCK_DATA_PROVIDER_INCIDENT_EVENT])
      .build();
    expect(response.events).toEqual({
      incidents: {
        initialValues: [MOCK_DATA_PROVIDER_INCIDENT_EVENT],
      },
    });
  });

  it('can supply lifecycle event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.LIFECYCLES],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addLifecycles([MOCK_DATA_PROVIDER_LIFECYCLE_EVENT])
      .build();
    expect(response.events).toEqual({
      lifecycles: {
        initialValues: [MOCK_DATA_PROVIDER_LIFECYCLE_EVENT],
      },
    });
  });

  it('can supply push event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.PUSH],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addPushEvents([MOCK_DATA_PROVIDER_PUSH_EVENT])
      .build();
    expect(response.events).toEqual({
      pushes: {
        initialValues: [MOCK_DATA_PROVIDER_PUSH_EVENT],
      },
    });
  });

  it('can supply pull request event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.PULL_REQUESTS],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addPullRequestEvents([MOCK_DATA_PROVIDER_PULL_REQUEST_EVENT])
      .build();
    expect(response.events).toEqual({
      pullRequests: {
        initialValues: [MOCK_DATA_PROVIDER_PULL_REQUEST_EVENT],
      },
    });
  });

  it('can supply vulnerability event data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.VULNERABILITIES],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addVulnerabilityEvents([MOCK_DATA_PROVIDER_VULNERABILITY_EVENT])
      .build();
    expect(response.events).toEqual({
      vulnerabilities: {
        initialValues: [MOCK_DATA_PROVIDER_VULNERABILITY_EVENT],
      },
    });
  });

  it('can supply built in metric data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [],
      builtInMetricDefinitions: [BuiltinMetricDefinitions.BUILD_SUCCESS_RATE],
      customMetricDefinitions: [],
    })
      .addBuiltInMetricValue(BuiltinMetricDefinitions.BUILD_SUCCESS_RATE, 0.5)
      .build();
    expect(response.metrics).toEqual({
      builtIn: {
        'ari:cloud:compass::metric-definition/builtin/build-success-rate': {
          initialValue: 0.5,
        },
      },
    });
  });

  it('throws error if initialValue is supplied for derived metric', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [],
      builtInMetricDefinitions: [
        { name: BuiltinMetricDefinitions.BUILD_SUCCESS_RATE, derived: true },
      ],
      customMetricDefinitions: [],
    });

    expect(() => {
      response.addBuiltInMetricValue(
        BuiltinMetricDefinitions.BUILD_SUCCESS_RATE,
        0.5,
      );
    }).toThrow(DataProviderError);
  });

  it('can supply custom metric data', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [
        {
          name: 'testMetric',
          description: 'hello',
          format: { suffix: '%' },
        },
      ],
    })
      .addCustomMetricValue('testMetric', 1)
      .build();
    expect(response.metrics).toEqual({
      custom: [
        {
          name: 'testMetric',
          description: 'hello',
          format: { suffix: '%' },
          initialValue: 1,
        },
      ],
    });
  });

  it('throws an error if the custom metric was not defined', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    });
    expect(() => {
      response.addCustomMetricValue('testMetric', 1);
    }).toThrow(DataProviderError);
  });

  it('throws an error if the built in metric was not defined', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    });
    expect(() => {
      response.addBuiltInMetricValue(
        BuiltinMetricDefinitions.BUILD_SUCCESS_RATE,
        1,
      );
    }).toThrow(DataProviderError);
  });

  it('can supply multiple event types', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [
        DataProviderEventTypes.BUILDS,
        DataProviderEventTypes.ALERTS,
        DataProviderEventTypes.LIFECYCLES,
      ],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    })
      .addBuilds([MOCK_DATA_PROVIDER_BUILD_EVENT])
      .addLifecycles([
        MOCK_DATA_PROVIDER_LIFECYCLE_EVENT,
        MOCK_DATA_PROVIDER_LIFECYCLE_EVENT,
      ])
      .build();
    expect(response.events).toEqual({
      builds: {
        initialValues: [MOCK_DATA_PROVIDER_BUILD_EVENT],
      },
      alerts: {
        initialValues: null,
      },
      lifecycles: {
        initialValues: [
          MOCK_DATA_PROVIDER_LIFECYCLE_EVENT,
          MOCK_DATA_PROVIDER_LIFECYCLE_EVENT,
        ],
      },
    });
  });

  it('throws an error if the event type was not defined', () => {
    const response = new DataProviderResponse('test123', {
      eventTypes: [],
      builtInMetricDefinitions: [],
      customMetricDefinitions: [],
    });
    expect(() => {
      response.addBuilds([MOCK_DATA_PROVIDER_BUILD_EVENT]);
    }).toThrow(DataProviderError);
  });

  it('can populate the placeholders', () => {
    const dp = new DataProviderResponse('test123', {
      eventTypes: [DataProviderEventTypes.BUILDS],
      builtInMetricDefinitions: [BuiltinMetricDefinitions.BUILD_SUCCESS_RATE],
      customMetricDefinitions: [],
    });
    const firstResponse = dp.build();
    expect(firstResponse.metrics.builtIn).toEqual({
      'ari:cloud:compass::metric-definition/builtin/build-success-rate': {
        initialValue: null,
      },
    });
    expect(firstResponse.events).toEqual({
      builds: {
        initialValues: null,
      },
    });

    dp.addBuilds([MOCK_DATA_PROVIDER_BUILD_EVENT]);
    dp.addBuiltInMetricValue(BuiltinMetricDefinitions.BUILD_SUCCESS_RATE, 0.5);

    const response = dp.build();
    expect(response.events).toEqual({
      builds: {
        initialValues: [MOCK_DATA_PROVIDER_BUILD_EVENT],
      },
    });
    expect(response.metrics.builtIn).toEqual({
      'ari:cloud:compass::metric-definition/builtin/build-success-rate': {
        initialValue: 0.5,
      },
    });
  });
});