text: import defaultValue from "../Core/defaultValue.js";
  import defined from "../Core/defined.js";
  import DeveloperError from "../Core/DeveloperError.js";
  import Event from "../Core/Event.js";
  import JulianDate from "../Core/JulianDate.js";
  import CesiumMath from "../Core/Math.js";
  import ModelAnimation from "./ModelAnimation.js";
  import ModelAnimationLoop from "./ModelAnimationLoop.js";
  import ModelAnimationState from "./ModelAnimationState.js";
  
  /**
   * A collection of active model animations.  Access this using {@link Model#activeAnimations}.
   *
   * @alias ModelAnimationCollection
   * @internalConstructor
   * @class
   *
   * @see Model#activeAnimations
   */
  function ModelAnimationCollection(model) {
    /**
     * The event fired when an animation is added to the collection.  This can be used, for
     * example, to keep a UI in sync.
     *
     * @type {Event}
     * @default new Event()
     *
     * @example
     * model.activeAnimations.animationAdded.addEventListener(function(model, animation) {
     *   console.log('Animation added: ' + animation.name);
     * });
     */
    this.animationAdded = new Event();
  
    /**
     * The event fired when an animation is removed from the collection.  This can be used, for
     * example, to keep a UI in sync.
     *
     * @type {Event}
     * @default new Event()
     *
     * @example
     * model.activeAnimations.animationRemoved.addEventListener(function(model, animation) {
     *   console.log('Animation removed: ' + animation.name);
     * });
     */
    this.animationRemoved = new Event();
  
    this._model = model;
    this._scheduledAnimations = [];
    this._previousTime = undefined;
  }
  
  Object.defineProperties(ModelAnimationCollection.prototype, {
    /**
     * The number of animations in the collection.
     *
     * @memberof ModelAnimationCollection.prototype
     *
     * @type {Number}
     * @readonly
     */
    length: {
      get: function () {
        return this._scheduledAnimations.length;
      },
    },
  });
  
  function add(collection, index, options) {
    var model = collection._model;
    var animations = model._runtime.animations;
    var animation = animations[index];
    var scheduledAnimation = new ModelAnimation(options, model, animation);
    collection._scheduledAnimations.push(scheduledAnimation);
    collection.animationAdded.raiseEvent(model, scheduledAnimation);
    return scheduledAnimation;
  }
  
  /**
   * Creates and adds an animation with the specified initial properties to the collection.
   * <p>
   * This raises the {@link ModelAnimationCollection#animationAdded} event so, for example, a UI can stay in sync.
   * </p>
   *
   * @param {Object} options Object with the following properties:
   * @param {String} [options.name] The glTF animation name that identifies the animation. Must be defined if <code>options.index</code> is <code>undefined</code>.
   * @param {Number} [options.index] The glTF animation index that identifies the animation. Must be defined if <code>options.name</code> is <code>undefined</code>.
   * @param {JulianDate} [options.startTime] The scene time to start playing the animation.  When this is <code>undefined</code>, the animation starts at the next frame.
   * @param {Number} [options.delay=0.0] The delay, in seconds, from <code>startTime</code> to start playing.
   * @param {JulianDate} [options.stopTime] The scene time to stop playing the animation.  When this is <code>undefined</code>, the animation is played for its full duration.
   * @param {Boolean} [options.removeOnStop=false] When <code>true</code>, the animation is removed after it stops playing.
   * @param {Number} [options.multiplier=1.0] Values greater than <code>1.0</code> increase the speed that the animation is played relative to the scene clock speed; values less than <code>1.0</code> decrease the speed.
   * @param {Boolean} [options.reverse=false] When <code>true</code>, the animation is played in reverse.
   * @param {ModelAnimationLoop} [options.loop=ModelAnimationLoop.NONE] Determines if and how the animation is looped.
   * @returns {ModelAnimation} The animation that was added to the collection.
   *
   * @exception {DeveloperError} Animations are not loaded.  Wait for the {@link Model#readyPromise} to resolve.
   * @exception {DeveloperError} options.name must be a valid animation name.
   * @exception {DeveloperError} options.index must be a valid animation index.
   * @exception {DeveloperError} Either options.name or options.index must be defined.
   * @exception {DeveloperError} options.multiplier must be greater than zero.
   *
   * @example
   * // Example 1. Add an animation by name
   * model.activeAnimations.add({
   *   name : 'animation name'
   * });
   *
   * // Example 2. Add an animation by index
   * model.activeAnimations.add({
   *   index : 0
   * });
   *
   * @example
   * // Example 3. Add an animation and provide all properties and events
   * var startTime = Cesium.JulianDate.now();
   *
   * var animation = model.activeAnimations.add({
   *   name : 'another animation name',
   *   startTime : startTime,
   *   delay : 0.0,                          // Play at startTime (default)
   *   stopTime : Cesium.JulianDate.addSeconds(startTime, 4.0, new Cesium.JulianDate()),
   *   removeOnStop : false,                 // Do not remove when animation stops (default)
   *   multiplier : 2.0,                        // Play at double speed
   *   reverse : true,                       // Play in reverse
   *   loop : Cesium.ModelAnimationLoop.REPEAT      // Loop the animation
   * });
   *
   * animation.start.addEventListener(function(model, animation) {
   *   console.log('Animation started: ' + animation.name);
   * });
   * animation.update.addEventListener(function(model, animation, time) {
   *   console.log('Animation updated: ' + animation.name + '. glTF animation time: ' + time);
   * });
   * animation.stop.addEventListener(function(model, animation) {
   *   console.log('Animation stopped: ' + animation.name);
   * });
   */
  ModelAnimationCollection.prototype.add = function (options) {
    options = defaultValue(options, defaultValue.EMPTY_OBJECT);
  
    var model = this._model;
    var animations = model._runtime.animations;
  
    //>>includeStart('debug', pragmas.debug);
    if (!defined(animations)) {
      throw new DeveloperError(
        "Animations are not loaded.  Wait for Model.readyPromise to resolve."
      );
    }
    if (!defined(options.name) && !defined(options.index)) {
      throw new DeveloperError(
        "Either options.name or options.index must be defined."
      );
    }
  
    if (defined(options.multiplier) && options.multiplier <= 0.0) {
      throw new DeveloperError("options.multiplier must be greater than zero.");
    }
    if (
      defined(options.index) &&
      (options.index >= animations.length || options.index < 0)
    ) {
      throw new DeveloperError("options.index must be a valid animation index.");
    }
    //>>includeEnd('debug');
  
    if (defined(options.index)) {
      return add(this, options.index, options);
    }
  
    // Find the index of the animation with the given name
    var index;
    var length = animations.length;
    for (var i = 0; i < length; ++i) {
      if (animations[i].name === options.name) {
        index = i;
        break;
      }
    }
  
    //>>includeStart('debug', pragmas.debug);
    if (!defined(index)) {
      throw new DeveloperError("options.name must be a valid animation name.");
    }
    //>>includeEnd('debug');
  
    return add(this, index, options);
  };
  
  /**
   * Creates and adds an animation with the specified initial properties to the collection
   * for each animation in the model.
   * <p>
   * This raises the {@link ModelAnimationCollection#animationAdded} event for each model so, for example, a UI can stay in sync.
   * </p>
   *
   * @param {Object} [options] Object with the following properties:
   * @param {JulianDate} [options.startTime] The scene time to start playing the animations.  When this is <code>undefined</code>, the animations starts at the next frame.
   * @param {Number} [options.delay=0.0] The delay, in seconds, from <code>startTime</code> to start playing.
   * @param {JulianDate} [options.stopTime] The scene time to stop playing the animations.  When this is <code>undefined</code>, the animations are played for its full duration.
   * @param {Boolean} [options.removeOnStop=false] When <code>true</code>, the animations are removed after they stop playing.
   * @param {Number} [options.multiplier=1.0] Values greater than <code>1.0</code> increase the speed that the animations play relative to the scene clock speed; values less than <code>1.0</code> decrease the speed.
   * @param {Boolean} [options.reverse=false] When <code>true</code>, the animations are played in reverse.
   * @param {ModelAnimationLoop} [options.loop=ModelAnimationLoop.NONE] Determines if and how the animations are looped.
   * @returns {ModelAnimation[]} An array of {@link ModelAnimation} objects, one for each animation added to the collection.  If there are no glTF animations, the array is empty.
   *
   * @exception {DeveloperError} Animations are not loaded.  Wait for the {@link Model#readyPromise} to resolve.
   * @exception {DeveloperError} options.multiplier must be greater than zero.
   *
   * @example
   * model.activeAnimations.addAll({
   *   multiplier : 0.5,                        // Play at half-speed
   *   loop : Cesium.ModelAnimationLoop.REPEAT      // Loop the animations
   * });
   */
  ModelAnimationCollection.prototype.addAll = function (options) {
    options = defaultValue(options, defaultValue.EMPTY_OBJECT);
  
    //>>includeStart('debug', pragmas.debug);
    if (!defined(this._model._runtime.animations)) {
      throw new DeveloperError(
        "Animations are not loaded.  Wait for Model.readyPromise to resolve."
      );
    }
  
    if (defined(options.multiplier) && options.multiplier <= 0.0) {
      throw new DeveloperError("options.multiplier must be greater than zero.");
    }
    //>>includeEnd('debug');
  
    var scheduledAnimations = [];
    var model = this._model;
    var animations = model._runtime.animations;
    var length = animations.length;
    for (var i = 0; i < length; ++i) {
      scheduledAnimations.push(add(this, i, options));
    }
    return scheduledAnimations;
  };
  
  /**
   * Removes an animation from the collection.
   * <p>
   * This raises the {@link ModelAnimationCollection#animationRemoved} event so, for example, a UI can stay in sync.
   * </p>
   * <p>
   * An animation can also be implicitly removed from the collection by setting {@link ModelAnimation#removeOnStop} to
   * <code>true</code>.  The {@link ModelAnimationCollection#animationRemoved} event is still fired when the animation is removed.
   * </p>
   *
   * @param {ModelAnimation} animation The animation to remove.
   * @returns {Boolean} <code>true</code> if the animation was removed; <code>false</code> if the animation was not found in the collection.
   *
   * @example
   * var a = model.activeAnimations.add({
   *   name : 'animation name'
   * });
   * model.activeAnimations.remove(a); // Returns true
   */
  ModelAnimationCollection.prototype.remove = function (animation) {
    if (defined(animation)) {
      var animations = this._scheduledAnimations;
      var i = animations.indexOf(animation);
      if (i !== -1) {
        animations.splice(i, 1);
        this.animationRemoved.raiseEvent(this._model, animation);
        return true;
      }
    }
  
    return false;
  };
  
  /**
   * Removes all animations from the collection.
   * <p>
   * This raises the {@link ModelAnimationCollection#animationRemoved} event for each
   * animation so, for example, a UI can stay in sync.
   * </p>
   */
  ModelAnimationCollection.prototype.removeAll = function () {
    var model = this._model;
    var animations = this._scheduledAnimations;
    var length = animations.length;
  
    this._scheduledAnimations = [];
  
    for (var i = 0; i < length; ++i) {
      this.animationRemoved.raiseEvent(model, animations[i]);
    }
  };
  
  /**
   * Determines whether this collection contains a given animation.
   *
   * @param {ModelAnimation} animation The animation to check for.
   * @returns {Boolean} <code>true</code> if this collection contains the animation, <code>false</code> otherwise.
   */
  ModelAnimationCollection.prototype.contains = function (animation) {
    if (defined(animation)) {
      return this._scheduledAnimations.indexOf(animation) !== -1;
    }
  
    return false;
  };
  
  /**
   * Returns the animation in the collection at the specified index.  Indices are zero-based
   * and increase as animations are added.  Removing an animation shifts all animations after
   * it to the left, changing their indices.  This function is commonly used to iterate over
   * all the animations in the collection.
   *
   * @param {Number} index The zero-based index of the animation.
   * @returns {ModelAnimation} The animation at the specified index.
   *
   * @example
   * // Output the names of all the animations in the collection.
   * var animations = model.activeAnimations;
   * var length = animations.length;
   * for (var i = 0; i < length; ++i) {
   *   console.log(animations.get(i).name);
   * }
   */
  ModelAnimationCollection.prototype.get = function (index) {
    //>>includeStart('debug', pragmas.debug);
    if (!defined(index)) {
      throw new DeveloperError("index is required.");
    }
    //>>includeEnd('debug');
  
    return this._scheduledAnimations[index];
  };
  
  function animateChannels(runtimeAnimation, localAnimationTime) {
    var channelEvaluators = runtimeAnimation.channelEvaluators;
    var length = channelEvaluators.length;
    for (var i = 0; i < length; ++i) {
      channelEvaluators[i](localAnimationTime);
    }
  }
  
  var animationsToRemove = [];
  
  function createAnimationRemovedFunction(
    modelAnimationCollection,
    model,
    animation
  ) {
    return function () {
      modelAnimationCollection.animationRemoved.raiseEvent(model, animation);
    };
  }
  
  /**
   * @private
   */
  ModelAnimationCollection.prototype.update = function (frameState) {
    var scheduledAnimations = this._scheduledAnimations;
    var length = scheduledAnimations.length;
  
    if (length === 0) {
      // No animations - quick return for performance
      this._previousTime = undefined;
      return false;
    }
  
    if (JulianDate.equals(frameState.time, this._previousTime)) {
      // Animations are currently only time-dependent so do not animate when paused or picking
      return false;
    }
    this._previousTime = JulianDate.clone(frameState.time, this._previousTime);
  
    var animationOccured = false;
    var sceneTime = frameState.time;
    var model = this._model;
  
    for (var i = 0; i < length; ++i) {
      var scheduledAnimation = scheduledAnimations[i];
      var runtimeAnimation = scheduledAnimation._runtimeAnimation;
  
      if (!defined(scheduledAnimation._computedStartTime)) {
        scheduledAnimation._computedStartTime = JulianDate.addSeconds(
          defaultValue(scheduledAnimation.startTime, sceneTime),
          scheduledAnimation.delay,
          new JulianDate()
        );
      }
  
      if (!defined(scheduledAnimation._duration)) {
        scheduledAnimation._duration =
          runtimeAnimation.stopTime * (1.0 / scheduledAnimation.multiplier);
      }
  
      var startTime = scheduledAnimation._computedStartTime;
      var duration = scheduledAnimation._duration;
      var stopTime = scheduledAnimation.stopTime;
  
      // [0.0, 1.0] normalized local animation time
      var delta =
        duration !== 0.0
          ? JulianDate.secondsDifference(sceneTime, startTime) / duration
          : 0.0;
  
      // Clamp delta to stop time, if defined.
      if (
        duration !== 0.0 &&
        defined(stopTime) &&
        JulianDate.greaterThan(sceneTime, stopTime)
      ) {
        delta = JulianDate.secondsDifference(stopTime, startTime) / duration;
      }
  
      var pastStartTime = delta >= 0.0;
  
      // Play animation if
      // * we are after the start time or the animation is being repeated, and
      // * before the end of the animation's duration or the animation is being repeated, and
      // * we did not reach a user-provided stop time.
  
      var repeat =
        scheduledAnimation.loop === ModelAnimationLoop.REPEAT ||
        scheduledAnimation.loop === ModelAnimationLoop.MIRRORED_REPEAT;
  
      var play =
        (pastStartTime || (repeat && !defined(scheduledAnimation.startTime))) &&
        (delta <= 1.0 || repeat) &&
        (!defined(stopTime) || JulianDate.lessThanOrEquals(sceneTime, stopTime));
  
      // If it IS, or WAS, animating...
      if (play || scheduledAnimation._state === ModelAnimationState.ANIMATING) {
        // STOPPED -> ANIMATING state transition?
        if (play && scheduledAnimation._state === ModelAnimationState.STOPPED) {
          scheduledAnimation._state = ModelAnimationState.ANIMATING;
          if (scheduledAnimation.start.numberOfListeners > 0) {
            frameState.afterRender.push(scheduledAnimation._raiseStartEvent);
          }
        }
  
        // Truncate to [0.0, 1.0] for repeating animations
        if (scheduledAnimation.loop === ModelAnimationLoop.REPEAT) {
          delta = delta - Math.floor(delta);
        } else if (
          scheduledAnimation.loop === ModelAnimationLoop.MIRRORED_REPEAT
        ) {
          var floor = Math.floor(delta);
          var fract = delta - floor;
          // When even use (1.0 - fract) to mirror repeat
          delta = floor % 2 === 1.0 ? 1.0 - fract : fract;
        }
  
        if (scheduledAnimation.reverse) {
          delta = 1.0 - delta;
        }
  
        var localAnimationTime = delta * duration * scheduledAnimation.multiplier;
        // Clamp in case floating-point roundoff goes outside the animation's first or last keyframe
        localAnimationTime = CesiumMath.clamp(
          localAnimationTime,
          runtimeAnimation.startTime,
          runtimeAnimation.stopTime
        );
  
        animateChannels(runtimeAnimation, localAnimationTime);
  
        if (scheduledAnimation.update.numberOfListeners > 0) {
          scheduledAnimation._updateEventTime = localAnimationTime;
          frameState.afterRender.push(scheduledAnimation._raiseUpdateEvent);
        }
        animationOccured = true;
  
        if (!play) {
          // ANIMATING -> STOPPED state transition?
          scheduledAnimation._state = ModelAnimationState.STOPPED;
          if (scheduledAnimation.stop.numberOfListeners > 0) {
            frameState.afterRender.push(scheduledAnimation._raiseStopEvent);
          }
  
          if (scheduledAnimation.removeOnStop) {
            animationsToRemove.push(scheduledAnimation);
          }
        }
      }
    }
  
    // Remove animations that stopped
    length = animationsToRemove.length;
    for (var j = 0; j < length; ++j) {
      var animationToRemove = animationsToRemove[j];
      scheduledAnimations.splice(
        scheduledAnimations.indexOf(animationToRemove),
        1
      );
      frameState.afterRender.push(
        createAnimationRemovedFunction(this, model, animationToRemove)
      );
    }
    animationsToRemove.length = 0;
  
    return animationOccured;
  };
  export default ModelAnimationCollection;
  