/*
 * Copyright 2015, Yahoo Inc.
 * Copyrights licensed under the New BSD License.
 * See the accompanying LICENSE file for terms.
 */
import * as React from 'react';
import {Context} from './injectIntl';
import {FormatRelativeTimeOptions} from '../types';
import {Unit} from '@formatjs/intl-relativetimeformat';
import {invariantIntlContext} from '../utils';
import {invariant} from '@formatjs/intl-utils';
const MINUTE = 60;
const HOUR = 60 * 60;
const DAY = 60 * 60 * 24;

function selectUnit(seconds: number): Unit {
  const absValue = Math.abs(seconds);

  if (absValue < MINUTE) {
    return 'second';
  }

  if (absValue < HOUR) {
    return 'minute';
  }

  if (absValue < DAY) {
    return 'hour';
  }

  return 'day';
}

function getDurationInSeconds(unit?: Unit): number {
  switch (unit) {
    case 'second':
      return 1;
    case 'minute':
      return MINUTE;
    case 'hour':
      return HOUR;
    default:
      return DAY;
  }
}

function valueToSeconds(value?: number, unit?: Unit): number {
  if (!value) {
    return 0;
  }
  switch (unit) {
    case 'second':
      return value;
    case 'minute':
      return value * MINUTE;
    default:
      return value * HOUR;
  }
}

export interface Props extends FormatRelativeTimeOptions {
  value?: number;
  unit?: Unit;
  updateIntervalInSeconds?: number;
  children?(value: string): React.ReactChild;
}

interface State {
  prevUnit?: Unit;
  prevValue?: number;
  currentValueInSeconds: number;
}

const INCREMENTABLE_UNITS: Unit[] = ['second', 'minute', 'hour'];
function canIncrement(unit: Unit = 'second'): boolean {
  return INCREMENTABLE_UNITS.includes(unit);
}

export class FormattedRelativeTime extends React.PureComponent<Props, State> {
  // Public for testing
  _updateTimer: any = null;
  static displayName = 'FormattedRelativeTime';
  static defaultProps: Pick<Props, 'unit' | 'value'> = {
    value: 0,
    unit: 'second',
  };
  state: State = {
    prevUnit: this.props.unit,
    prevValue: this.props.value,
    currentValueInSeconds: canIncrement(this.props.unit)
      ? valueToSeconds(this.props.value, this.props.unit)
      : 0,
  };

  constructor(props: Props) {
    super(props);
    invariant(
      !props.updateIntervalInSeconds ||
        !!(props.updateIntervalInSeconds && canIncrement(props.unit)),
      'Cannot schedule update with unit longer than hour'
    );
  }

  scheduleNextUpdate(
    {updateIntervalInSeconds, unit}: Props,
    {currentValueInSeconds}: State
  ): void {
    clearTimeout(this._updateTimer);
    this._updateTimer = null;
    // If there's no interval and we cannot increment this unit, do nothing
    if (!updateIntervalInSeconds || !canIncrement(unit)) {
      return;
    }
    // Figure out the next interesting time
    const nextValueInSeconds = currentValueInSeconds - updateIntervalInSeconds;
    const nextUnit = selectUnit(nextValueInSeconds);
    // We've reached the max auto incrementable unit, don't schedule another update
    if (nextUnit === 'day') {
      return;
    }

    const unitDuration = getDurationInSeconds(nextUnit);
    const remainder = nextValueInSeconds % unitDuration;
    const prevInterestingValueInSeconds = nextValueInSeconds - remainder;
    const nextInterestingValueInSeconds =
      prevInterestingValueInSeconds >= currentValueInSeconds
        ? prevInterestingValueInSeconds - unitDuration
        : prevInterestingValueInSeconds;
    const delayInSeconds = Math.abs(
      nextInterestingValueInSeconds - currentValueInSeconds
    );

    this._updateTimer = setTimeout(
      () =>
        this.setState({
          currentValueInSeconds: nextInterestingValueInSeconds,
        }),
      delayInSeconds * 1e3
    );
  }

  componentDidMount(): void {
    this.scheduleNextUpdate(this.props, this.state);
  }

  componentDidUpdate(): void {
    this.scheduleNextUpdate(this.props, this.state);
  }

  componentWillUnmount(): void {
    clearTimeout(this._updateTimer);
    this._updateTimer = null;
  }

  static getDerivedStateFromProps(
    props: Props,
    state: State
  ): Partial<State> | null {
    if (props.unit !== state.prevUnit || props.value !== state.prevValue) {
      return {
        prevValue: props.value,
        prevUnit: props.unit,
        currentValueInSeconds: canIncrement(props.unit)
          ? valueToSeconds(props.value, props.unit)
          : 0,
      };
    }
    return null;
  }

  render(): JSX.Element {
    return (
      <Context.Consumer>
        {(intl): React.ReactNode => {
          invariantIntlContext(intl);

          const {formatRelativeTime, textComponent: Text} = intl;
          const {children, value, unit, updateIntervalInSeconds} = this.props;
          const {currentValueInSeconds} = this.state;
          let currentValue = value || 0;
          let currentUnit = unit;

          if (
            canIncrement(unit) &&
            typeof currentValueInSeconds === 'number' &&
            updateIntervalInSeconds
          ) {
            currentUnit = selectUnit(currentValueInSeconds);
            const unitDuration = getDurationInSeconds(currentUnit);
            currentValue = Math.round(currentValueInSeconds / unitDuration);
          }

          const formattedRelativeTime = formatRelativeTime(
            currentValue,
            currentUnit,
            {
              ...this.props,
            }
          );

          if (typeof children === 'function') {
            return children(formattedRelativeTime);
          }
          if (Text) {
            return <Text>{formattedRelativeTime}</Text>;
          }
          return formattedRelativeTime;
        }}
      </Context.Consumer>
    );
  }
}

export default FormattedRelativeTime;