/*
 * Copyright (C) 2013 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef TimingCalculations_h
#define TimingCalculations_h

#include "core/animation/AnimationEffectReadOnly.h"
#include "core/animation/Timing.h"
#include "platform/animation/AnimationUtilities.h"
#include "wtf/MathExtras.h"

namespace blink {

static inline double multiplyZeroAlwaysGivesZero(double x, double y) {
  DCHECK(!isNull(x));
  DCHECK(!isNull(y));
  return x && y ? x * y : 0;
}

static inline AnimationEffectReadOnly::Phase calculatePhase(
    double activeDuration,
    double localTime,
    const Timing& specified) {
  DCHECK_GE(activeDuration, 0);
  if (isNull(localTime))
    return AnimationEffectReadOnly::PhaseNone;
  double endTime = specified.startDelay + activeDuration + specified.endDelay;
  if (localTime < std::min(specified.startDelay, endTime))
    return AnimationEffectReadOnly::PhaseBefore;
  if (localTime >= std::min(specified.startDelay + activeDuration, endTime))
    return AnimationEffectReadOnly::PhaseAfter;
  return AnimationEffectReadOnly::PhaseActive;
}

static inline bool isActiveInParentPhase(
    AnimationEffectReadOnly::Phase parentPhase,
    Timing::FillMode fillMode) {
  switch (parentPhase) {
    case AnimationEffectReadOnly::PhaseBefore:
      return fillMode == Timing::FillMode::BACKWARDS ||
             fillMode == Timing::FillMode::BOTH;
    case AnimationEffectReadOnly::PhaseActive:
      return true;
    case AnimationEffectReadOnly::PhaseAfter:
      return fillMode == Timing::FillMode::FORWARDS ||
             fillMode == Timing::FillMode::BOTH;
    default:
      NOTREACHED();
      return false;
  }
}

static inline double calculateActiveTime(
    double activeDuration,
    Timing::FillMode fillMode,
    double localTime,
    AnimationEffectReadOnly::Phase parentPhase,
    AnimationEffectReadOnly::Phase phase,
    const Timing& specified) {
  DCHECK_GE(activeDuration, 0);
  DCHECK_EQ(phase, calculatePhase(activeDuration, localTime, specified));

  switch (phase) {
    case AnimationEffectReadOnly::PhaseBefore:
      if (fillMode == Timing::FillMode::BACKWARDS ||
          fillMode == Timing::FillMode::BOTH)
        return 0;
      return nullValue();
    case AnimationEffectReadOnly::PhaseActive:
      if (isActiveInParentPhase(parentPhase, fillMode))
        return localTime - specified.startDelay;
      return nullValue();
    case AnimationEffectReadOnly::PhaseAfter:
      if (fillMode == Timing::FillMode::FORWARDS ||
          fillMode == Timing::FillMode::BOTH)
        return std::max(
            0.0, std::min(activeDuration, activeDuration + specified.endDelay));
      return nullValue();
    case AnimationEffectReadOnly::PhaseNone:
      DCHECK(isNull(localTime));
      return nullValue();
    default:
      NOTREACHED();
      return nullValue();
  }
}

static inline double calculateScaledActiveTime(double activeDuration,
                                               double activeTime,
                                               double startOffset,
                                               const Timing& specified) {
  DCHECK_GE(activeDuration, 0);
  DCHECK_GE(startOffset, 0);

  if (isNull(activeTime))
    return nullValue();

  DCHECK(activeTime >= 0 && activeTime <= activeDuration);

  if (specified.playbackRate == 0)
    return startOffset;

  if (!std::isfinite(activeTime))
    return std::numeric_limits<double>::infinity();

  return multiplyZeroAlwaysGivesZero(specified.playbackRate < 0
                                         ? activeTime - activeDuration
                                         : activeTime,
                                     specified.playbackRate) +
         startOffset;
}

static inline bool endsOnIterationBoundary(double iterationCount,
                                           double iterationStart) {
  DCHECK(std::isfinite(iterationCount));
  return !fmod(iterationCount + iterationStart, 1);
}

// TODO(crbug.com/630915): Align this function with current Web Animations spec
// text.
static inline double calculateIterationTime(
    double iterationDuration,
    double repeatedDuration,
    double scaledActiveTime,
    double startOffset,
    AnimationEffectReadOnly::Phase phase,
    const Timing& specified) {
  DCHECK_GT(iterationDuration, 0);
  DCHECK_EQ(repeatedDuration, multiplyZeroAlwaysGivesZero(
                                  iterationDuration, specified.iterationCount));

  if (isNull(scaledActiveTime))
    return nullValue();

  DCHECK_GE(scaledActiveTime, 0);
  DCHECK_LE(scaledActiveTime, repeatedDuration + startOffset);

  if (!std::isfinite(scaledActiveTime) ||
      (scaledActiveTime - startOffset == repeatedDuration &&
       specified.iterationCount &&
       endsOnIterationBoundary(specified.iterationCount,
                               specified.iterationStart)))
    return iterationDuration;

  DCHECK(std::isfinite(scaledActiveTime));
  double iterationTime = fmod(scaledActiveTime, iterationDuration);

  // This implements step 3 of
  // http://w3c.github.io/web-animations/#calculating-the-simple-iteration-progress
  if (iterationTime == 0 && phase == AnimationEffectReadOnly::PhaseAfter &&
      repeatedDuration != 0 && scaledActiveTime != 0)
    return iterationDuration;

  return iterationTime;
}

static inline double calculateCurrentIteration(double iterationDuration,
                                               double iterationTime,
                                               double scaledActiveTime,
                                               const Timing& specified) {
  DCHECK_GT(iterationDuration, 0);
  DCHECK(isNull(iterationTime) || iterationTime >= 0);

  if (isNull(scaledActiveTime))
    return nullValue();

  DCHECK_GE(iterationTime, 0);
  DCHECK_LE(iterationTime, iterationDuration);
  DCHECK_GE(scaledActiveTime, 0);

  if (!scaledActiveTime)
    return 0;

  if (iterationTime == iterationDuration)
    return specified.iterationStart + specified.iterationCount - 1;

  return floor(scaledActiveTime / iterationDuration);
}

static inline double calculateDirectedTime(double currentIteration,
                                           double iterationDuration,
                                           double iterationTime,
                                           const Timing& specified) {
  DCHECK(isNull(currentIteration) || currentIteration >= 0);
  DCHECK_GT(iterationDuration, 0);

  if (isNull(iterationTime))
    return nullValue();

  DCHECK_GE(currentIteration, 0);
  DCHECK_GE(iterationTime, 0);
  DCHECK_LE(iterationTime, iterationDuration);

  const bool currentIterationIsOdd = fmod(currentIteration, 2) >= 1;
  const bool currentDirectionIsForwards =
      specified.direction == Timing::PlaybackDirection::NORMAL ||
      (specified.direction == Timing::PlaybackDirection::ALTERNATE_NORMAL &&
       !currentIterationIsOdd) ||
      (specified.direction == Timing::PlaybackDirection::ALTERNATE_REVERSE &&
       currentIterationIsOdd);

  return currentDirectionIsForwards ? iterationTime
                                    : iterationDuration - iterationTime;
}

static inline double calculateTransformedTime(double currentIteration,
                                              double iterationDuration,
                                              double iterationTime,
                                              const Timing& specified) {
  DCHECK(isNull(currentIteration) || currentIteration >= 0);
  DCHECK_GT(iterationDuration, 0);
  DCHECK(isNull(iterationTime) ||
         (iterationTime >= 0 && iterationTime <= iterationDuration));

  double directedTime = calculateDirectedTime(
      currentIteration, iterationDuration, iterationTime, specified);
  if (isNull(directedTime))
    return nullValue();
  if (!std::isfinite(iterationDuration))
    return directedTime;
  double timeFraction = directedTime / iterationDuration;
  DCHECK(timeFraction >= 0 && timeFraction <= 1);
  return multiplyZeroAlwaysGivesZero(
      iterationDuration,
      specified.timingFunction->evaluate(
          timeFraction, accuracyForDuration(iterationDuration)));
}

}  // namespace blink

#endif