"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ActiveAlerts = void 0;
exports.useFetchActiveAlerts = useFetchActiveAlerts;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _reactQuery = require("@tanstack/react-query");
var _common = require("@kbn/rule-registry-plugin/common");
var _sloSchema = require("@kbn/slo-schema");
var _kibana_react = require("../../utils/kibana_react");
var _query_key_factory = require("./query_key_factory");
/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License
 * 2.0; you may not use this file except in compliance with the Elastic License
 * 2.0.
 */

class ActiveAlerts {
  constructor(initialData) {
    (0, _defineProperty2.default)(this, "data", new Map());
    if (initialData) {
      Object.keys(initialData).forEach(key => this.data.set(key, initialData[key]));
    }
  }
  set(slo, value) {
    var _slo$instanceId;
    this.data.set(`${slo.id}|${(_slo$instanceId = slo.instanceId) !== null && _slo$instanceId !== void 0 ? _slo$instanceId : _sloSchema.ALL_VALUE}`, value);
  }
  get(slo) {
    var _slo$instanceId2;
    return this.data.get(`${slo.id}|${(_slo$instanceId2 = slo.instanceId) !== null && _slo$instanceId2 !== void 0 ? _slo$instanceId2 : _sloSchema.ALL_VALUE}`);
  }
  has(slo) {
    var _slo$instanceId3;
    return this.data.has(`${slo.id}|${(_slo$instanceId3 = slo.instanceId) !== null && _slo$instanceId3 !== void 0 ? _slo$instanceId3 : _sloSchema.ALL_VALUE}`);
  }
  delete(slo) {
    var _slo$instanceId4;
    return this.data.delete(`${slo.id}|${(_slo$instanceId4 = slo.instanceId) !== null && _slo$instanceId4 !== void 0 ? _slo$instanceId4 : _sloSchema.ALL_VALUE}`);
  }
  clear() {
    return this.data.clear();
  }
}
exports.ActiveAlerts = ActiveAlerts;
const EMPTY_ACTIVE_ALERTS_MAP = new ActiveAlerts();
function useFetchActiveAlerts({
  sloIdsAndInstanceIds = []
}) {
  const {
    http
  } = (0, _kibana_react.useKibana)().services;
  const {
    isInitialLoading,
    isLoading,
    isError,
    isSuccess,
    isRefetching,
    data
  } = (0, _reactQuery.useQuery)({
    queryKey: _query_key_factory.sloKeys.activeAlert(sloIdsAndInstanceIds),
    queryFn: async ({
      signal
    }) => {
      try {
        const response = await http.post(`${_common.BASE_RAC_ALERTS_API_PATH}/find`, {
          body: JSON.stringify({
            feature_ids: ['slo'],
            size: 0,
            query: {
              bool: {
                filter: [{
                  range: {
                    '@timestamp': {
                      gte: 'now-5m/m'
                    }
                  }
                }, {
                  term: {
                    'kibana.alert.rule.rule_type_id': 'slo.rules.burnRate'
                  }
                }, {
                  term: {
                    'kibana.alert.status': 'active'
                  }
                }],
                should: sloIdsAndInstanceIds.map(([sloId, instanceId]) => ({
                  bool: {
                    filter: [{
                      term: {
                        'slo.id': sloId
                      }
                    }, {
                      term: {
                        'slo.instanceId': instanceId
                      }
                    }]
                  }
                })),
                minimum_should_match: 1
              }
            },
            aggs: {
              perSloId: {
                multi_terms: {
                  size: sloIdsAndInstanceIds.length,
                  terms: [{
                    field: 'slo.id'
                  }, {
                    field: 'slo.instanceId'
                  }]
                }
              }
            }
          }),
          signal
        });
        const activeAlertsData = response.aggregations.perSloId.buckets.reduce((acc, bucket) => {
          var _bucket$doc_count;
          return {
            ...acc,
            [bucket.key_as_string]: (_bucket$doc_count = bucket.doc_count) !== null && _bucket$doc_count !== void 0 ? _bucket$doc_count : 0
          };
        }, {});
        return new ActiveAlerts(activeAlertsData);
      } catch (error) {
        // ignore error
      }
    },
    refetchOnWindowFocus: false,
    enabled: Boolean(sloIdsAndInstanceIds.length)
  });
  return {
    data: isInitialLoading ? EMPTY_ACTIVE_ALERTS_MAP : data !== null && data !== void 0 ? data : EMPTY_ACTIVE_ALERTS_MAP,
    isLoading: isInitialLoading || isLoading || isRefetching,
    isSuccess,
    isError
  };
}