// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//     You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//     See the License for the specific language governing permissions and
// limitations under the License.
(function (shared, scope, testing) {
  var disassociate = function (effect) {
    effect._animation = undefined;

    if (effect instanceof window.SequenceEffect || effect instanceof window.GroupEffect) {
      for (var i = 0; i < effect.children.length; i++) {
        disassociate(effect.children[i]);
      }
    }
  };

  scope.removeMulti = function (effects) {
    var oldParents = [];

    for (var i = 0; i < effects.length; i++) {
      var effect = effects[i];

      if (effect._parent) {
        if (oldParents.indexOf(effect._parent) == -1) {
          oldParents.push(effect._parent);
        }

        effect._parent.children.splice(effect._parent.children.indexOf(effect), 1);

        effect._parent = null;
        disassociate(effect);
      } else if (effect._animation && effect._animation.effect == effect) {
        effect._animation.cancel();

        effect._animation.effect = new KeyframeEffect(null, []);

        if (effect._animation._callback) {
          effect._animation._callback._animation = null;
        }

        effect._animation._rebuildUnderlyingAnimation();

        disassociate(effect);
      }
    }

    for (i = 0; i < oldParents.length; i++) {
      oldParents[i]._rebuild();
    }
  };

  function KeyframeList(effectInput) {
    this._frames = shared.normalizeKeyframes(effectInput);
  }

  scope.KeyframeEffect = function (target, effectInput, timingInput, id) {
    this.target = target;
    this._parent = null;
    timingInput = shared.numericTimingToObject(timingInput);
    this._timingInput = shared.cloneTimingInput(timingInput);
    this._timing = shared.normalizeTimingInput(timingInput);
    this.timing = shared.makeTiming(timingInput, false, this);
    this.timing._effect = this;

    if (typeof effectInput == 'function') {
      shared.deprecated('Custom KeyframeEffect', '2015-06-22', 'Use KeyframeEffect.onsample instead.');
      this._normalizedKeyframes = effectInput;
    } else {
      this._normalizedKeyframes = new KeyframeList(effectInput);
    }

    this._keyframes = effectInput;
    this.activeDuration = shared.calculateActiveDuration(this._timing);
    this._id = id;
    return this;
  };

  scope.KeyframeEffect.prototype = {
    getFrames: function () {
      if (typeof this._normalizedKeyframes == 'function') return this._normalizedKeyframes;
      return this._normalizedKeyframes._frames;
    },

    set onsample(callback) {
      if (typeof this.getFrames() == 'function') {
        throw new Error('Setting onsample on custom effect KeyframeEffect is not supported.');
      }

      this._onsample = callback;

      if (this._animation) {
        this._animation._rebuildUnderlyingAnimation();
      }
    },

    get parent() {
      return this._parent;
    },

    clone: function () {
      if (typeof this.getFrames() == 'function') {
        throw new Error('Cloning custom effects is not supported.');
      }

      var clone = new KeyframeEffect(this.target, [], shared.cloneTimingInput(this._timingInput), this._id);
      clone._normalizedKeyframes = this._normalizedKeyframes;
      clone._keyframes = this._keyframes;
      return clone;
    },
    remove: function () {
      scope.removeMulti([this]);
    }
  };
  var originalElementAnimate = Element.prototype.animate;

  Element.prototype.animate = function (effectInput, options) {
    var id = '';

    if (options && options.id) {
      id = options.id;
    }

    return scope.timeline._play(new scope.KeyframeEffect(this, effectInput, options, id));
  };

  var nullTarget = document.createElementNS('http://www.w3.org/1999/xhtml', 'div');

  scope.newUnderlyingAnimationForKeyframeEffect = function (keyframeEffect) {
    if (keyframeEffect) {
      var target = keyframeEffect.target || nullTarget;
      var keyframes = keyframeEffect._keyframes;

      if (typeof keyframes == 'function') {
        keyframes = [];
      }

      var options = keyframeEffect._timingInput;
      options.id = keyframeEffect._id;
    } else {
      var target = nullTarget;
      var keyframes = [];
      var options = 0;
    }

    return originalElementAnimate.apply(target, [keyframes, options]);
  }; // TODO: Remove this once we remove support for custom KeyframeEffects.


  scope.bindAnimationForKeyframeEffect = function (animation) {
    if (animation.effect && typeof animation.effect._normalizedKeyframes == 'function') {
      scope.bindAnimationForCustomEffect(animation);
    }
  };

  var pendingGroups = [];

  scope.awaitStartTime = function (groupAnimation) {
    if (groupAnimation.startTime !== null || !groupAnimation._isGroup) return;

    if (pendingGroups.length == 0) {
      requestAnimationFrame(updatePendingGroups);
    }

    pendingGroups.push(groupAnimation);
  };

  function updatePendingGroups() {
    var updated = false;

    while (pendingGroups.length) {
      var group = pendingGroups.shift();

      group._updateChildren();

      updated = true;
    }

    return updated;
  }

  var originalGetComputedStyle = window.getComputedStyle;
  Object.defineProperty(window, 'getComputedStyle', {
    configurable: true,
    enumerable: true,
    value: function () {
      scope.timeline._updateAnimationsPromises();

      var result = originalGetComputedStyle.apply(this, arguments);
      if (updatePendingGroups()) result = originalGetComputedStyle.apply(this, arguments);

      scope.timeline._updateAnimationsPromises();

      return result;
    }
  });
  window.KeyframeEffect = scope.KeyframeEffect;

  window.Element.prototype.getAnimations = function () {
    return document.timeline.getAnimations().filter(function (animation) {
      return animation.effect !== null && animation.effect.target == this;
    }.bind(this));
  };
})(webAnimationsShared, webAnimationsNext, webAnimationsTesting);