export type DateInterval = {
  start: string | Date;
  end: string | Date;
};

export type Range = {
  min: number;
  max: number;
};

export const searchOr = (
  fields: string[],
  search?: string,
  mode = 'insensitive',
) => {
  if (!search) {
    return [];
  }

  if (!fields?.length) {
    return [];
  }

  return fields.map((field) => ({
    [field]: {
      contains: search,
    },
  }));
};

export const fieldEquals = (field: string, value?: string) => {
  if (!value) {
    return {};
  }

  return {
    [field]: {
      equals: value,
    },
  };
};

export const isInInterval = (interval?: DateInterval) => {
  if (!interval || (!interval?.start && !interval?.end)) {
    return undefined;
  }

  return {
    gte: interval.start ? new Date(interval.start).toISOString() : undefined,
    lte: interval.end ? new Date(interval.end).toISOString() : undefined,
  };
};

export const isInNumericInterval = (interval?: Range) => {
  if (!interval || !interval?.min || !interval?.max) {
    return undefined;
  }

  return {
    gte: interval.min,
    lte: interval.max,
  };
};

export const fieldIsInInterval = (field: string, interval?: DateInterval) => {
  const intervalIsIn = isInInterval(interval);

  if (!intervalIsIn) {
    return {};
  }

  return {
    [field]: isInInterval(interval),
  };
};

export const isIn = <T = string>(
  values: T[] | undefined,
): { in: Array<T> } | undefined => {
  if (!values || values.length === 0) {
    return undefined;
  }

  return {
    in: values,
  };
};
