function getQueryWithRisonParams(
  location: Location,
  pathname: string,
  query: RisonDecoded = {}
) {
  // Preserve current _g and _a
  const currentQuery = toQuery(location.search);
  const decodedG = risonSafeDecode(currentQuery._g);
  const combinedG = { ...DEFAULT_KIBANA_TIME_RANGE, ...decodedG, ...query._g };
  const encodedG = rison.encode(combinedG);
  const encodedA = query._a ? rison.encode(query._a) : '';

  const nextQuery: StringMap = {
    ...query,
    _g: encodedG
  };

  // Preserve kuery for apm links
  const isApmLink = pathname.includes('app/apm') || pathname === '';
  if (currentQuery.kuery && isApmLink) {
    nextQuery.kuery = currentQuery.kuery;
  }

  if (encodedA) {
    nextQuery._a = encodedA;
  }

  return nextQuery;
}

export function moveToDiscover(indexPatternId: string, kbnBaseUrl: string) {
  const _g = rison.encode({});

  // Add the index pattern ID to the appState part of the URL.
  const _a = rison.encode({
    index: indexPatternId,
  });

  const baseUrl = chrome.addBasePath(kbnBaseUrl);
  const hash = `#/discover?_g=${_g}&_a=${_a}`;

  window.location.href = `${baseUrl}${hash}`;
}

function getQueryWithRisonParams(location: Location, query: RisonDecoded = {}) {
  // Preserve current _g and _a
  const currentQuery = toQuery(location.search);
  const decodedG = risonSafeDecode(currentQuery._g);
  const combinedG = { ...DEFAULT_KIBANA_TIME_RANGE, ...decodedG, ...query._g };
  const encodedG = rison.encode(combinedG);
  const encodedA = query._a ? rison.encode(query._a) : '';

  return {
    ...query,
    _g: encodedG,
    _a: encodedA
  };
}

export const createTSVBLink = (
  source: SourceQuery.Query['source']['configuration'] | undefined,
  options: MetricsExplorerOptions,
  series: MetricsExplorerSeries,
  timeRange: MetricsExplorerTimeOptions
) => {
  const appState = {
    filters: [],
    linked: false,
    query: { language: 'kuery', query: '' },
    uiState: {},
    vis: {
      aggs: [],
      params: {
        axis_formatter: 'number',
        axis_position: 'left',
        axis_scale: 'normal',
        id: uuid.v1(),
        default_index_pattern: (source && source.metricAlias) || 'metricbeat-*',
        index_pattern: (source && source.metricAlias) || 'metricbeat-*',
        interval: 'auto',
        series: options.metrics.map(mapMetricToSeries),
        show_grid: 1,
        show_legend: 1,
        time_field: (source && source.fields.timestamp) || '@timestamp',
        type: 'timeseries',
        filter: createFilterFromOptions(options, series),
      },
      title: series.id,
      type: 'metrics',
    },
  };

  const globalState = {
    refreshInterval: { pause: true, value: 0 },
    time: { from: timeRange.from, to: timeRange.to },
  };

  return `../app/kibana#/visualize/create?type=metrics&_g=${encode(globalState)}&_a=${encode(
    appState as any
  )}`;
};

export function getRisonHref({
  location,
  pathname,
  hash,
  query = {}
}: RisonHrefArgs) {
  const currentQuery = toQuery(location.search);
  const nextQuery = {
    ...TIMEPICKER_DEFAULTS,
    ...pick(currentQuery, PERSISTENT_APM_PARAMS),
    ...query
  };

  // Create _g value for non-apm links
  const g = createG(nextQuery);
  const encodedG = rison.encode(g);
  const encodedA = query._a ? rison.encode(query._a) : ''; // TODO: Do we need to url-encode the _a values before rison encoding _a?
  const risonQuery: RisonEncoded = {
    _g: encodedG
  };

  if (encodedA) {
    risonQuery._a = encodedA;
  }

  // don't URI-encode the already-encoded rison
  const search = qs.stringify(risonQuery, undefined, undefined, {
    encodeURIComponent: (v: string) => v
  });

  const href = url.format({
    pathname: chrome.addBasePath(pathname),
    hash: `${hash}?${search}`
  });

  return href;
}

 public toRISON() {
   // Use Angular to remove the private vars, and JSON.stringify to serialize
   return rison.encode(JSON.parse(angular.toJson(this)));
 }

const encodeRisonUrlState = (state: any) => encode(state);