@kiwicom/smart-faq/src/SmartFAQ/helpers/dateUtils.js

// @flow

import * as React from 'react';
import Translate from '@kiwicom/nitro/lib/components/Translate';

import { LanguageContext } from '../context/Language';
import {
  DEFAULT_LOCALE,
  supportedLanguages,
} from '../../shared/helpers/translationUtils';

export const URGENCY_THRESHOLD = 48;

type Props = {|
  dateString: string,
|};

type CountDownProps = {|
  hoursLeft: number,
|};

type TimeDepartureProps = {|
  mins: number,
  isLayover: boolean,
|};

export const FormatDate = ({ dateString }: Props) => {
  const options = {
    weekday: 'short',
    month: 'short',
    day: 'numeric',
    timeZone: 'UTC',
  };

  return (
    <LanguageContext.Consumer>
      {language => {
        const locale = (supportedLanguages[language] || DEFAULT_LOCALE).replace(
          '_',
          '-',
        );

        return new Date(dateString).toLocaleDateString(locale, options);
      }}
    </LanguageContext.Consumer>
  );
};

export const formatDepartureDate = (dateString: string) => {
  const dateUTC = new Date(dateString);
  const month = dateUTC.getUTCMonth() + 1;
  const day = dateUTC.getUTCDate();
  const year = dateUTC.getUTCFullYear();
  return `${day}/${month}/${year}`;
};

export type FormattedDaysType = {|
  format: 'days',
  daysLeft: number,
|};

const formatNumberDays = (hoursLeft: number): FormattedDaysType => ({
  format: 'days',
  daysLeft: Math.floor(hoursLeft / 24),
});

export type FormattedCountdownType =
  | FormattedDaysType
  | {|
      format: 'hours_minutes',
      hoursLeft: number,
      minutesLeft: number,
    |}
  | {|
      format: 'hours',
      hoursLeft: number,
    |};

export const formatCountDown = ({
  hoursLeft,
}: CountDownProps): FormattedCountdownType => {
  const nhours = Math.floor(hoursLeft);
  const nmins = Math.floor((hoursLeft - nhours) * 60);

  if (hoursLeft < URGENCY_THRESHOLD) {
    return nmins
      ? {
          format: 'hours_minutes',
          hoursLeft: nhours,
          minutesLeft: nmins,
        }
      : {
          format: 'hours',
          hoursLeft: nhours,
        };
  }
  return formatNumberDays(hoursLeft);
};

const translationKeys = {
  layoverMoreThanOneHour: __(
    'smartfaq.single_booking_page.layover.more_than_one_hour',
  ),
  layoverLessThanOneHour: __(
    'smartfaq.single_booking_page.layover.less_than_one_hour',
  ),
  segmentMoreThanOneHour: __(
    'smartfaq.single_booking_page.segment.more_than_one_hour',
  ),
  segmentLessThanOneHour: __(
    'smartfaq.single_booking_page.segment.less_than_one_hour',
  ),
};

export const formatTimeDuration = ({
  mins,
  isLayover,
}: TimeDepartureProps): React.Node => {
  const nhours = Math.floor(mins / 60);
  const nmins = mins - nhours * 60;
  const layoverTime = nhours ? (
    <Translate
      t={translationKeys.layoverMoreThanOneHour}
      values={{ numberHours: nhours, numberMins: nmins }}
    />
  ) : (
    <Translate
      t={translationKeys.layoverLessThanOneHour}
      values={{ numberMins: nmins }}
    />
  );
  const segmentTime = nhours ? (
    <Translate
      t={translationKeys.segmentMoreThanOneHour}
      values={{ numberHours: nhours, numberMins: nmins }}
    />
  ) : (
    <Translate
      t={translationKeys.segmentLessThanOneHour}
      values={{ numberMins: nmins }}
    />
  );

  return isLayover ? layoverTime : segmentTime;
};

export const timeDurationTranslationData = ({
  mins,
  isLayover,
}: TimeDepartureProps): Object => {
  const nhours = Math.floor(mins / 60);
  const nmins = mins - nhours * 60;

  let translationKey = '';
  if (isLayover && nhours) {
    translationKey = translationKeys.layoverMoreThanOneHour;
  }
  if (isLayover && !nhours) {
    translationKey = translationKeys.layoverLessThanOneHour;
  }
  if (!isLayover && nhours) {
    translationKey = translationKeys.segmentMoreThanOneHour;
  }
  if (!isLayover && !nhours) {
    translationKey = translationKeys.segmentLessThanOneHour;
  }

  const translationVariables = nhours
    ? {
        numberHours: nhours,
        numberMins: nmins,
      }
    : {
        numberMins: nmins,
      };

  return { translationKey, translationVariables };
};

export const formatHour = (date: string) => {
  const options = { hour: 'numeric', timeZone: 'UTC', minute: 'numeric' };
  return new Date(date).toLocaleString('en-US', options);
};