export const buildPipeline = async (
  vis: Vis,
  params: { searchSource: SearchSource; timeRange?: any }
) => {
  const { searchSource } = params;
  const { indexPattern } = vis;
  const query = searchSource.getField('query');
  const filters = searchSource.getField('filter');
  const visState = vis.getCurrentState();
  const uiState = vis.getUiState();

  // context
  let pipeline = `kibana | kibana_context `;
  if (query) {
    pipeline += prepareJson('query', query);
  }
  if (filters) {
    pipeline += prepareJson('filters', filters);
  }
  if (vis.savedSearchId) {
    pipeline += prepareString('savedSearchId', vis.savedSearchId);
  }
  pipeline += '| ';

  // request handler
  if (vis.type.requestHandler === 'courier') {
    pipeline += `esaggs
    ${prepareString('index', indexPattern.id)}
    metricsAtAllLevels=${vis.isHierarchical()}
    partialRows=${vis.type.requiresPartialRows || vis.params.showPartialRows || false}
    ${prepareJson('aggConfigs', visState.aggs)} | `;
  }

  const schemas = getSchemas(vis, params.timeRange);
  if (buildPipelineVisFunction[vis.type.name]) {
    pipeline += buildPipelineVisFunction[vis.type.name](visState, schemas, uiState);
  } else if (vislibCharts.includes(vis.type.name)) {
    const visConfig = visState.params;
    visConfig.dimensions = await buildVislibDimensions(vis, params);

    pipeline += `vislib ${prepareJson('visConfig', visState.params)}`;
  } else {
    pipeline += `visualization type='${vis.type.name}'
    ${prepareJson('visConfig', visState.params)}
    metricsAtAllLevels=${vis.isHierarchical()}
    partialRows=${vis.type.requiresPartialRows || vis.params.showPartialRows || false} `;
    if (indexPattern) {
      pipeline += `${prepareString('index', indexPattern.id)}`;
    }
  }

  return pipeline;
};

export const getTableAggs = (vis: Vis): AggConfig[] => {
  if (!vis.aggs || !vis.aggs.getResponseAggs) {
    return [];
  }
  const columns = tabifyGetColumns(vis.aggs.getResponseAggs(), !vis.isHierarchical());
  return columns.map((c: any) => c.aggConfig);
};

export const getSchemas = (vis: Vis): Schemas => {
  let cnt = 0;
  const schemas: Schemas = {
    metric: [],
  };
  const responseAggs = vis.aggs.getResponseAggs();
  const isHierarchical = vis.isHierarchical();
  const metrics = responseAggs.filter((agg: AggConfig) => agg.type.type === 'metrics');
  responseAggs.forEach((agg: AggConfig) => {
    if (!agg.enabled) {
      return;
    }
    let schemaName = agg.schema ? agg.schema.name || agg.schema : null;
    if (typeof schemaName === 'object') {
      schemaName = null;
    }
    if (!schemaName) {
      return;
    }
    if (schemaName === 'split') {
      schemaName = `split_${agg.params.row ? 'row' : 'column'}`;
    }
    if (!schemas[schemaName]) {
      schemas[schemaName] = [];
    }
    if (!isHierarchical || agg.type.type !== 'metrics') {
      schemas[schemaName].push(cnt++);
    }
    if (isHierarchical && agg.type.type !== 'metrics') {
      metrics.forEach(() => {
        schemas.metric.push(cnt++);
      });
    }
  });
  return schemas;
};

export const getSchemas = (vis: Vis, timeRange?: any): Schemas => {
  const createFormat = (agg: AggConfig): SchemaFormat => {
    const format: SchemaFormat = agg.params.field ? agg.params.field.format.toJSON() : {};
    const formats: any = {
      date_range: () => ({ id: 'string' }),
      percentile_ranks: () => ({ id: 'percent' }),
      count: () => ({ id: 'number' }),
      cardinality: () => ({ id: 'number' }),
      date_histogram: () => ({
        id: 'date',
        params: {
          pattern: agg.buckets.getScaledDateFormat(),
        },
      }),
      terms: () => ({
        id: 'terms',
        params: {
          id: format.id,
          otherBucketLabel: agg.params.otherBucketLabel,
          missingBucketLabel: agg.params.missingBucketLabel,
          ...format.params,
        },
      }),
      range: () => ({
        id: 'range',
        params: { id: format.id, ...format.params },
      }),
    };

    return formats[agg.type.name] ? formats[agg.type.name]() : format;
  };

  const createSchemaConfig = (accessor: number, agg: AggConfig): SchemaConfig => {
    if (agg.type.name === 'date_histogram') {
      agg.params.timeRange = timeRange;
      setBounds(agg, true);
    }

    const hasSubAgg = [
      'derivative',
      'moving_avg',
      'serial_diff',
      'cumulative_sum',
      'sum_bucket',
      'avg_bucket',
      'min_bucket',
      'max_bucket',
    ].includes(agg.type.name);

    const format = createFormat(
      hasSubAgg ? agg.params.customMetric || agg.aggConfigs.byId[agg.params.metricAgg] : agg
    );

    const params: SchemaConfigParams = {};

    if (agg.type.name === 'geohash_grid') {
      params.precision = agg.params.precision;
      params.useGeocentroid = agg.params.useGeocentroid;
    }

    return {
      accessor,
      format,
      params,
      aggType: agg.type.name,
    };
  };

  let cnt = 0;
  const schemas: Schemas = {
    metric: [],
  };
  const responseAggs = vis.aggs.getResponseAggs().filter((agg: AggConfig) => agg.enabled);
  const isHierarchical = vis.isHierarchical();
  const metrics = responseAggs.filter((agg: AggConfig) => agg.type.type === 'metrics');
  responseAggs.forEach((agg: AggConfig) => {
    if (!agg.enabled) {
      cnt++;
      return;
    }
    let skipMetrics = false;
    let schemaName = agg.schema ? agg.schema.name || agg.schema : null;
    if (typeof schemaName === 'object') {
      schemaName = null;
    }
    if (!schemaName) {
      if (agg.type.name === 'geo_centroid') {
        schemaName = 'geo_centroid';
      } else {
        cnt++;
        return;
      }
    }
    if (schemaName === 'split') {
      schemaName = `split_${agg.params.row ? 'row' : 'column'}`;
      skipMetrics = responseAggs.length - metrics.length > 1;
    }
    if (!schemas[schemaName]) {
      schemas[schemaName] = [];
    }
//.........这里部分代码省略.........