export const escapeQueryValue = (val: number | string = ''): string | number => {
  if (isString(val)) {
    return val.replace(/"/g, '\\"');
  }

  return val;
};

 Object.keys(sources).reduce<DetailItem[]>((accumulator, source) => {
   const item = get(source, sources);
   if (Array.isArray(item) || isString(item) || isNumber(item)) {
     const field = path ? `${path}.${source}` : source;
     category = field.split('.')[0];
     if (isEmpty(category) && baseCategoryFields.includes(category)) {
       category = 'base';
     }
     return [
       ...accumulator,
       {
         category,
         field,
         values: item,
         originalValue: item,
       } as DetailItem,
     ];
   } else if (isObject(item)) {
     return [
       ...accumulator,
       ...getDataFromHits(item, category || source, path ? `${path}.${source}` : source),
     ];
   }
   return accumulator;
 }, []);

export function ID(gpmlElement) {
  if (gpmlElement.hasOwnProperty("ID")) {
    const { ID } = gpmlElement;
    return isString(ID) ? ID : ID.content;
  } else {
    return gpmlElement.Xref.ID;
  }
}

const convertToNumber = (value: object | number | boolean | string): number => {
  if (isNumber(value)) {
    return value;
  } else if (isString(value)) {
    return parseFloat(value);
  } else {
    return NaN;
  }
};

export const addFieldToTimelineColumns = ({
  upsertColumn = timelineActions.upsertColumn,
  browserFields,
  dispatch,
  result,
}: AddFieldToTimelineColumnsParams): void => {
  const timeline = getTimelineIdFromDestination(result);
  const fieldId = getFieldIdFromDraggable(result);
  const allColumns = getAllFieldsByName(browserFields);
  const column = allColumns[fieldId];

  if (column != null) {
    dispatch(
      upsertColumn({
        column: {
          category: column.category,
          columnHeaderType: 'not-filtered',
          description: isString(column.description) ? column.description : undefined,
          example: isString(column.example) ? column.example : undefined,
          id: fieldId,
          type: column.type,
          width: DEFAULT_COLUMN_MIN_WIDTH,
        },
        id: timeline,
        index: result.destination != null ? result.destination.index : 0,
      })
    );
  } else {
    // create a column definition, because it doesn't exist in the browserFields:
    dispatch(
      upsertColumn({
        column: {
          columnHeaderType: 'not-filtered',
          id: fieldId,
          width: DEFAULT_COLUMN_MIN_WIDTH,
        },
        id: timeline,
        index: result.destination != null ? result.destination.index : 0,
      })
    );
  }
};

export const parseFilterQuery = (filterQuery: string): JsonObject => {
  try {
    if (filterQuery && isString(filterQuery) && !isEmpty(filterQuery)) {
      const parsedFilterQuery = JSON.parse(filterQuery);
      if (
        !parsedFilterQuery ||
        !isPlainObject(parsedFilterQuery) ||
        Array.isArray(parsedFilterQuery)
      ) {
        throw new Error('expected value to be an object');
      }
      return parsedFilterQuery;
    }
    return {};
  } catch (err) {
    throw new UserInputError(`Failed to parse query: ${err}`, {
      query: filterQuery,
      originalError: err,
    });
  }
};

 *  serialize: gets invoked when serializing the result to send it back to a client.
 *
 *  parseValue: gets invoked to parse client input that was passed through variables.
 *
 *  parseLiteral: gets invoked to parse client input that was passed inline in the query.
 */

export const toNumberArrayScalar = new GraphQLScalarType({
  name: 'NumberArray',
  description: 'Represents value in detail item from the timeline who wants to more than one type',
  serialize(value): number[] | null {
    if (value == null) {
      return null;
    } else if (Array.isArray(value)) {
      return convertArrayToNumber(value) as number[];
    } else if (isBoolean(value) || isString(value) || isObject(value)) {
      return [convertToNumber(value)];
    }
    return [value];
  },
  parseValue(value) {
    return value;
  },
  parseLiteral(ast) {
    switch (ast.kind) {
      case Kind.INT:
        return ast.value;
      case Kind.FLOAT:
        return ast.value;
      case Kind.STRING:
        return parseFloat(ast.value);