"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SeriesType = void 0;
exports.registerLensFunction = registerLensFunction;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _eui = require("@elastic/eui");
var _common = require("@kbn/field-formats-plugin/common");
var _lensEmbeddableUtils = require("@kbn/lens-embeddable-utils");
var _react = _interopRequireWildcard(require("react"));
var _useAsync = _interopRequireDefault(require("react-use/lib/useAsync"));
var _i18n = require("@kbn/i18n");
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
/*
 * 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.
 */
let SeriesType;
exports.SeriesType = SeriesType;
(function (SeriesType) {
  SeriesType["Bar"] = "bar";
  SeriesType["Line"] = "line";
  SeriesType["Area"] = "area";
  SeriesType["BarStacked"] = "bar_stacked";
  SeriesType["AreaStacked"] = "area_stacked";
  SeriesType["BarHorizontal"] = "bar_horizontal";
  SeriesType["BarPercentageStacked"] = "bar_percentage_stacked";
  SeriesType["AreaPercentageStacked"] = "area_percentage_stacked";
  SeriesType["BarHorizontalPercentageStacked"] = "bar_horizontal_percentage_stacked";
})(SeriesType || (exports.SeriesType = SeriesType = {}));
function Lens({
  indexPattern,
  xyDataLayer,
  start,
  end,
  lens,
  dataViews
}) {
  const formulaAsync = (0, _useAsync.default)(() => {
    return lens.stateHelperApi();
  }, [lens]);
  const dataViewAsync = (0, _useAsync.default)(() => {
    return dataViews.create({
      id: indexPattern,
      title: indexPattern,
      timeFieldName: '@timestamp'
    });
  }, [indexPattern]);
  const [isSaveModalOpen, setIsSaveModalOpen] = (0, _react.useState)(false);
  if (!formulaAsync.value || !dataViewAsync.value) {
    return /*#__PURE__*/_react.default.createElement(_eui.EuiLoadingSpinner, null);
  }
  const attributes = new _lensEmbeddableUtils.LensAttributesBuilder({
    visualization: new _lensEmbeddableUtils.XYChart({
      layers: [xyDataLayer],
      formulaAPI: formulaAsync.value.formula,
      dataView: dataViewAsync.value
    })
  }).build();
  const lensEmbeddableInput = {
    id: indexPattern,
    attributes,
    timeRange: {
      from: start,
      to: end,
      mode: 'relative'
    }
  };
  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_eui.EuiFlexGroup, {
    direction: "column"
  }, /*#__PURE__*/_react.default.createElement(_eui.EuiFlexItem, {
    grow: false
  }, /*#__PURE__*/_react.default.createElement(_eui.EuiFlexGroup, {
    direction: "row",
    gutterSize: "s",
    justifyContent: "flexEnd"
  }, /*#__PURE__*/_react.default.createElement(_eui.EuiFlexItem, {
    grow: false
  }, /*#__PURE__*/_react.default.createElement(_eui.EuiButton, {
    iconType: "lensApp",
    onClick: () => {
      lens.navigateToPrefilledEditor(lensEmbeddableInput);
    }
  }, _i18n.i18n.translate('xpack.observabilityAiAssistant.lensFunction.openInLens', {
    defaultMessage: 'Open in Lens'
  }))), /*#__PURE__*/_react.default.createElement(_eui.EuiFlexItem, {
    grow: false
  }, /*#__PURE__*/_react.default.createElement(_eui.EuiButton, {
    iconType: "save",
    onClick: () => {
      setIsSaveModalOpen(() => true);
    }
  }, _i18n.i18n.translate('xpack.observabilityAiAssistant.lensFunction.save', {
    defaultMessage: 'Save'
  }))))), /*#__PURE__*/_react.default.createElement(_eui.EuiFlexItem, null, /*#__PURE__*/_react.default.createElement(lens.EmbeddableComponent, (0, _extends2.default)({}, lensEmbeddableInput, {
    style: {
      height: 240
    }
  })))), isSaveModalOpen ? /*#__PURE__*/_react.default.createElement(lens.SaveModalComponent, {
    initialInput: lensEmbeddableInput,
    onClose: () => {
      setIsSaveModalOpen(() => false);
    }
  }) : null);
}
function registerLensFunction({
  service,
  registerFunction,
  pluginsStart
}) {
  registerFunction({
    name: 'lens',
    contexts: ['core'],
    description: "Use this function to create custom visualizations, using Lens, that can be saved to dashboards. This function does not return data to the assistant, it only shows it to the user. When using this function, make sure to use the recall function to get more information about how to use it, with how you want to use it. Make sure the query also contains information about the user's request. The visualisation is displayed to the user above your reply, DO NOT try to generate or display an image yourself.",
    descriptionForUser: 'Use this function to create custom visualizations, using Lens, that can be saved to dashboards.',
    parameters: {
      type: 'object',
      additionalProperties: false,
      properties: {
        layers: {
          type: 'array',
          items: {
            type: 'object',
            additionalProperties: false,
            properties: {
              label: {
                type: 'string'
              },
              formula: {
                type: 'string',
                description: 'The formula for calculating the value, e.g. sum(my_field_name). Query the knowledge base to get more information about the syntax and available formulas.'
              },
              filter: {
                type: 'string',
                description: 'A KQL query that will be used as a filter for the series'
              },
              format: {
                type: 'object',
                additionalProperties: false,
                properties: {
                  id: {
                    type: 'string',
                    description: 'How to format the value. When using duration, make sure the value is seconds OR is converted to seconds using math functions. Ask the user for clarification in which unit the value is stored, or derive it from the field name.',
                    enum: [_common.FIELD_FORMAT_IDS.BYTES, _common.FIELD_FORMAT_IDS.CURRENCY, _common.FIELD_FORMAT_IDS.DURATION, _common.FIELD_FORMAT_IDS.NUMBER, _common.FIELD_FORMAT_IDS.PERCENT, _common.FIELD_FORMAT_IDS.STRING]
                  }
                },
                required: ['id']
              }
            },
            required: ['label', 'formula', 'format']
          }
        },
        breakdown: {
          type: 'object',
          additionalProperties: false,
          properties: {
            field: {
              type: 'string'
            }
          },
          required: ['field']
        },
        indexPattern: {
          type: 'string'
        },
        seriesType: {
          type: 'string',
          enum: [SeriesType.Area, SeriesType.AreaPercentageStacked, SeriesType.AreaStacked, SeriesType.Bar, SeriesType.BarHorizontal, SeriesType.BarHorizontalPercentageStacked, SeriesType.BarPercentageStacked, SeriesType.BarStacked, SeriesType.Line]
        },
        start: {
          type: 'string',
          description: 'The start of the time range, in Elasticsearch datemath'
        },
        end: {
          type: 'string',
          description: 'The end of the time range, in Elasticsearch datemath'
        }
      },
      required: ['layers', 'indexPattern', 'start', 'end']
    }
  }, async () => {
    return {
      content: {}
    };
  }, ({
    arguments: {
      layers,
      indexPattern,
      breakdown,
      seriesType,
      start,
      end
    }
  }) => {
    const xyDataLayer = new _lensEmbeddableUtils.XYDataLayer({
      data: layers.map(layer => {
        var _layer$filter;
        return {
          type: 'formula',
          value: layer.formula,
          label: layer.label,
          format: layer.format,
          filter: {
            language: 'kql',
            query: (_layer$filter = layer.filter) !== null && _layer$filter !== void 0 ? _layer$filter : ''
          }
        };
      }),
      options: {
        seriesType,
        breakdown: breakdown ? {
          type: 'top_values',
          params: {
            size: 10
          },
          field: breakdown.field
        } : undefined
      }
    });
    return /*#__PURE__*/_react.default.createElement(Lens, {
      indexPattern: indexPattern,
      xyDataLayer: xyDataLayer,
      start: start,
      end: end,
      lens: pluginsStart.lens,
      dataViews: pluginsStart.dataViews
    });
  });
}