text: import defaultValue from '../Core/defaultValue.js';
  import defined from '../Core/defined.js';
  import destroyObject from '../Core/destroyObject.js';
  import DeveloperError from '../Core/DeveloperError.js';
  import Event from '../Core/Event.js';
  import CesiumMath from '../Core/Math.js';
  import Rectangle from '../Core/Rectangle.js';
  import when from '../ThirdParty/when.js';
  import ImageryLayer from './ImageryLayer.js';
  
      /**
       * An ordered collection of imagery layers.
       *
       * @alias ImageryLayerCollection
       * @constructor
       *
       * @demo {@link https://sandcastle.cesium.com/index.html?src=Imagery%20Adjustment.html|Cesium Sandcastle Imagery Adjustment Demo}
       * @demo {@link https://sandcastle.cesium.com/index.html?src=Imagery%20Layers%20Manipulation.html|Cesium Sandcastle Imagery Manipulation Demo}
       */
      function ImageryLayerCollection() {
          this._layers = [];
  
          /**
           * An event that is raised when a layer is added to the collection.  Event handlers are passed the layer that
           * was added and the index at which it was added.
           * @type {Event}
           * @default Event()
           */
          this.layerAdded = new Event();
  
          /**
           * An event that is raised when a layer is removed from the collection.  Event handlers are passed the layer that
           * was removed and the index from which it was removed.
           * @type {Event}
           * @default Event()
           */
          this.layerRemoved = new Event();
  
          /**
           * An event that is raised when a layer changes position in the collection.  Event handlers are passed the layer that
           * was moved, its new index after the move, and its old index prior to the move.
           * @type {Event}
           * @default Event()
           */
          this.layerMoved = new Event();
  
          /**
           * An event that is raised when a layer is shown or hidden by setting the
           * {@link ImageryLayer#show} property.  Event handlers are passed a reference to this layer,
           * the index of the layer in the collection, and a flag that is true if the layer is now
           * shown or false if it is now hidden.
           *
           * @type {Event}
           * @default Event()
           */
          this.layerShownOrHidden = new Event();
      }
  
      Object.defineProperties(ImageryLayerCollection.prototype, {
          /**
           * Gets the number of layers in this collection.
           * @memberof ImageryLayerCollection.prototype
           * @type {Number}
           */
          length : {
              get : function() {
                  return this._layers.length;
              }
          }
      });
  
      /**
       * Adds a layer to the collection.
       *
       * @param {ImageryLayer} layer the layer to add.
       * @param {Number} [index] the index to add the layer at.  If omitted, the layer will
       *                         added on top of all existing layers.
       *
       * @exception {DeveloperError} index, if supplied, must be greater than or equal to zero and less than or equal to the number of the layers.
       */
      ImageryLayerCollection.prototype.add = function(layer, index) {
          var hasIndex = defined(index);
  
          //>>includeStart('debug', pragmas.debug);
          if (!defined(layer)) {
              throw new DeveloperError('layer is required.');
          }
          if (hasIndex) {
              if (index < 0) {
                  throw new DeveloperError('index must be greater than or equal to zero.');
              } else if (index > this._layers.length) {
                  throw new DeveloperError('index must be less than or equal to the number of layers.');
              }
          }
          //>>includeEnd('debug');
  
          if (!hasIndex) {
              index = this._layers.length;
              this._layers.push(layer);
          } else {
              this._layers.splice(index, 0, layer);
          }
  
          this._update();
          this.layerAdded.raiseEvent(layer, index);
      };
  
      /**
       * Creates a new layer using the given ImageryProvider and adds it to the collection.
       *
       * @param {ImageryProvider} imageryProvider the imagery provider to create a new layer for.
       * @param {Number} [index] the index to add the layer at.  If omitted, the layer will
       *                         added on top of all existing layers.
       * @returns {ImageryLayer} The newly created layer.
       */
      ImageryLayerCollection.prototype.addImageryProvider = function(imageryProvider, index) {
          //>>includeStart('debug', pragmas.debug);
          if (!defined(imageryProvider)) {
              throw new DeveloperError('imageryProvider is required.');
          }
          //>>includeEnd('debug');
  
          var layer = new ImageryLayer(imageryProvider);
          this.add(layer, index);
          return layer;
      };
  
      /**
       * Removes a layer from this collection, if present.
       *
       * @param {ImageryLayer} layer The layer to remove.
       * @param {Boolean} [destroy=true] whether to destroy the layers in addition to removing them.
       * @returns {Boolean} true if the layer was in the collection and was removed,
       *                    false if the layer was not in the collection.
       */
      ImageryLayerCollection.prototype.remove = function(layer, destroy) {
          destroy = defaultValue(destroy, true);
  
          var index = this._layers.indexOf(layer);
          if (index !== -1) {
              this._layers.splice(index, 1);
  
              this._update();
  
              this.layerRemoved.raiseEvent(layer, index);
  
              if (destroy) {
                  layer.destroy();
              }
  
              return true;
          }
  
          return false;
      };
  
      /**
       * Removes all layers from this collection.
       *
       * @param {Boolean} [destroy=true] whether to destroy the layers in addition to removing them.
       */
      ImageryLayerCollection.prototype.removeAll = function(destroy) {
          destroy = defaultValue(destroy, true);
  
          var layers = this._layers;
          for (var i = 0, len = layers.length; i < len; i++) {
              var layer = layers[i];
              this.layerRemoved.raiseEvent(layer, i);
  
              if (destroy) {
                  layer.destroy();
              }
          }
  
          this._layers = [];
      };
  
      /**
       * Checks to see if the collection contains a given layer.
       *
       * @param {ImageryLayer} layer the layer to check for.
       *
       * @returns {Boolean} true if the collection contains the layer, false otherwise.
       */
      ImageryLayerCollection.prototype.contains = function(layer) {
          return this.indexOf(layer) !== -1;
      };
  
      /**
       * Determines the index of a given layer in the collection.
       *
       * @param {ImageryLayer} layer The layer to find the index of.
       *
       * @returns {Number} The index of the layer in the collection, or -1 if the layer does not exist in the collection.
       */
      ImageryLayerCollection.prototype.indexOf = function(layer) {
          return this._layers.indexOf(layer);
      };
  
      /**
       * Gets a layer by index from the collection.
       *
       * @param {Number} index the index to retrieve.
       *
       * @returns {ImageryLayer} The imagery layer at the given index.
       */
      ImageryLayerCollection.prototype.get = function(index) {
          //>>includeStart('debug', pragmas.debug);
          if (!defined(index)) {
              throw new DeveloperError('index is required.', 'index');
          }
          //>>includeEnd('debug');
  
          return this._layers[index];
      };
  
      function getLayerIndex(layers, layer) {
          //>>includeStart('debug', pragmas.debug);
          if (!defined(layer)) {
              throw new DeveloperError('layer is required.');
          }
          //>>includeEnd('debug');
  
          var index = layers.indexOf(layer);
  
          //>>includeStart('debug', pragmas.debug);
          if (index === -1) {
              throw new DeveloperError('layer is not in this collection.');
          }
          //>>includeEnd('debug');
  
          return index;
      }
  
      function swapLayers(collection, i, j) {
          var arr = collection._layers;
          i = CesiumMath.clamp(i, 0, arr.length - 1);
          j = CesiumMath.clamp(j, 0, arr.length - 1);
  
          if (i === j) {
              return;
          }
  
          var temp = arr[i];
          arr[i] = arr[j];
          arr[j] = temp;
  
          collection._update();
  
          collection.layerMoved.raiseEvent(temp, j, i);
      }
  
      /**
       * Raises a layer up one position in the collection.
       *
       * @param {ImageryLayer} layer the layer to move.
       *
       * @exception {DeveloperError} layer is not in this collection.
       * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
       */
      ImageryLayerCollection.prototype.raise = function(layer) {
          var index = getLayerIndex(this._layers, layer);
          swapLayers(this, index, index + 1);
      };
  
      /**
       * Lowers a layer down one position in the collection.
       *
       * @param {ImageryLayer} layer the layer to move.
       *
       * @exception {DeveloperError} layer is not in this collection.
       * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
       */
      ImageryLayerCollection.prototype.lower = function(layer) {
          var index = getLayerIndex(this._layers, layer);
          swapLayers(this, index, index - 1);
      };
  
      /**
       * Raises a layer to the top of the collection.
       *
       * @param {ImageryLayer} layer the layer to move.
       *
       * @exception {DeveloperError} layer is not in this collection.
       * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
       */
      ImageryLayerCollection.prototype.raiseToTop = function(layer) {
          var index = getLayerIndex(this._layers, layer);
          if (index === this._layers.length - 1) {
              return;
          }
          this._layers.splice(index, 1);
          this._layers.push(layer);
  
          this._update();
  
          this.layerMoved.raiseEvent(layer, this._layers.length - 1, index);
      };
  
      /**
       * Lowers a layer to the bottom of the collection.
       *
       * @param {ImageryLayer} layer the layer to move.
       *
       * @exception {DeveloperError} layer is not in this collection.
       * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
       */
      ImageryLayerCollection.prototype.lowerToBottom = function(layer) {
          var index = getLayerIndex(this._layers, layer);
          if (index === 0) {
              return;
          }
          this._layers.splice(index, 1);
          this._layers.splice(0, 0, layer);
  
          this._update();
  
          this.layerMoved.raiseEvent(layer, 0, index);
      };
  
      var applicableRectangleScratch = new Rectangle();
  
      /**
       * Asynchronously determines the imagery layer features that are intersected by a pick ray.  The intersected imagery
       * layer features are found by invoking {@link ImageryProvider#pickFeatures} for each imagery layer tile intersected
       * by the pick ray.  To compute a pick ray from a location on the screen, use {@link Camera.getPickRay}.
       *
       * @param {Ray} ray The ray to test for intersection.
       * @param {Scene} scene The scene.
       * @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise that resolves to an array of features intersected by the pick ray.
       *                                             If it can be quickly determined that no features are intersected (for example,
       *                                             because no active imagery providers support {@link ImageryProvider#pickFeatures}
       *                                             or because the pick ray does not intersect the surface), this function will
       *                                             return undefined.
       *
       * @example
       * var pickRay = viewer.camera.getPickRay(windowPosition);
       * var featuresPromise = viewer.imageryLayers.pickImageryLayerFeatures(pickRay, viewer.scene);
       * if (!Cesium.defined(featuresPromise)) {
       *     console.log('No features picked.');
       * } else {
       *     Cesium.when(featuresPromise, function(features) {
       *         // This function is called asynchronously when the list if picked features is available.
       *         console.log('Number of features: ' + features.length);
       *         if (features.length > 0) {
       *             console.log('First feature name: ' + features[0].name);
       *         }
       *     });
       * }
       */
      ImageryLayerCollection.prototype.pickImageryLayerFeatures = function(ray, scene) {
          // Find the picked location on the globe.
          var pickedPosition = scene.globe.pick(ray, scene);
          if (!defined(pickedPosition)) {
              return undefined;
          }
  
          var pickedLocation = scene.globe.ellipsoid.cartesianToCartographic(pickedPosition);
  
          // Find the terrain tile containing the picked location.
          var tilesToRender = scene.globe._surface._tilesToRender;
          var pickedTile;
  
          for (var textureIndex = 0; !defined(pickedTile) && textureIndex < tilesToRender.length; ++textureIndex) {
              var tile = tilesToRender[textureIndex];
              if (Rectangle.contains(tile.rectangle, pickedLocation)) {
                  pickedTile = tile;
              }
          }
  
          if (!defined(pickedTile)) {
              return undefined;
          }
  
          // Pick against all attached imagery tiles containing the pickedLocation.
          var imageryTiles = pickedTile.data.imagery;
  
          var promises = [];
          var imageryLayers = [];
          for (var i = imageryTiles.length - 1; i >= 0; --i) {
              var terrainImagery = imageryTiles[i];
              var imagery = terrainImagery.readyImagery;
              if (!defined(imagery)) {
                  continue;
              }
              var provider = imagery.imageryLayer.imageryProvider;
              if (!defined(provider.pickFeatures)) {
                  continue;
              }
  
              if (!Rectangle.contains(imagery.rectangle, pickedLocation)) {
                  continue;
              }
  
              // If this imagery came from a parent, it may not be applicable to its entire rectangle.
              // Check the textureCoordinateRectangle.
              var applicableRectangle = applicableRectangleScratch;
  
              var epsilon = 1 / 1024; // 1/4 of a pixel in a typical 256x256 tile.
              applicableRectangle.west = CesiumMath.lerp(pickedTile.rectangle.west, pickedTile.rectangle.east, terrainImagery.textureCoordinateRectangle.x - epsilon);
              applicableRectangle.east = CesiumMath.lerp(pickedTile.rectangle.west, pickedTile.rectangle.east, terrainImagery.textureCoordinateRectangle.z + epsilon);
              applicableRectangle.south = CesiumMath.lerp(pickedTile.rectangle.south, pickedTile.rectangle.north, terrainImagery.textureCoordinateRectangle.y - epsilon);
              applicableRectangle.north = CesiumMath.lerp(pickedTile.rectangle.south, pickedTile.rectangle.north, terrainImagery.textureCoordinateRectangle.w + epsilon);
              if (!Rectangle.contains(applicableRectangle, pickedLocation)) {
                  continue;
              }
  
              var promise = provider.pickFeatures(imagery.x, imagery.y, imagery.level, pickedLocation.longitude, pickedLocation.latitude);
              if (!defined(promise)) {
                  continue;
              }
  
              promises.push(promise);
              imageryLayers.push(imagery.imageryLayer);
          }
  
          if (promises.length === 0) {
              return undefined;
          }
  
          return when.all(promises, function(results) {
              var features = [];
  
              for (var resultIndex = 0; resultIndex < results.length; ++resultIndex) {
                  var result = results[resultIndex];
                  var image = imageryLayers[resultIndex];
  
                  if (defined(result) && result.length > 0) {
                      for (var featureIndex = 0; featureIndex < result.length; ++featureIndex) {
                          var feature = result[featureIndex];
                          feature.imageryLayer = image;
  
                          // For features without a position, use the picked location.
                          if (!defined(feature.position)) {
                              feature.position = pickedLocation;
                          }
  
                          features.push(feature);
                      }
                  }
              }
  
              return features;
          });
      };
  
      /**
       * Updates frame state to execute any queued texture re-projections.
       *
       * @private
       *
       * @param {FrameState} frameState The frameState.
       */
      ImageryLayerCollection.prototype.queueReprojectionCommands = function(frameState) {
          var layers = this._layers;
          for (var i = 0, len = layers.length; i < len; ++i) {
              layers[i].queueReprojectionCommands(frameState);
          }
      };
  
      /**
       * Cancels re-projection commands queued for the next frame.
       *
       * @private
       */
      ImageryLayerCollection.prototype.cancelReprojections = function() {
          var layers = this._layers;
          for (var i = 0, len = layers.length; i < len; ++i) {
              layers[i].cancelReprojections();
          }
      };
  
      /**
       * Returns true if this object was destroyed; otherwise, false.
       * <br /><br />
       * If this object was destroyed, it should not be used; calling any function other than
       * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
       *
       * @returns {Boolean} true if this object was destroyed; otherwise, false.
       *
       * @see ImageryLayerCollection#destroy
       */
      ImageryLayerCollection.prototype.isDestroyed = function() {
          return false;
      };
  
      /**
       * Destroys the WebGL resources held by all layers in this collection.  Explicitly destroying this
       * object allows for deterministic release of WebGL resources, instead of relying on the garbage
       * collector.
       * <br /><br />
       * Once this object is destroyed, it should not be used; calling any function other than
       * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
       * assign the return value (<code>undefined</code>) to the object as done in the example.
       *
       * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
       *
       *
       * @example
       * layerCollection = layerCollection && layerCollection.destroy();
       *
       * @see ImageryLayerCollection#isDestroyed
       */
      ImageryLayerCollection.prototype.destroy = function() {
          this.removeAll(true);
          return destroyObject(this);
      };
  
      ImageryLayerCollection.prototype._update = function() {
          var isBaseLayer = true;
          var layers = this._layers;
          var layersShownOrHidden;
          var layer;
          var i, len;
          for (i = 0, len = layers.length; i < len; ++i) {
              layer = layers[i];
  
              layer._layerIndex = i;
  
              if (layer.show) {
                  layer._isBaseLayer = isBaseLayer;
                  isBaseLayer = false;
              } else {
                  layer._isBaseLayer = false;
              }
  
              if (layer.show !== layer._show) {
                  if (defined(layer._show)) {
                      if (!defined(layersShownOrHidden)) {
                          layersShownOrHidden = [];
                      }
                      layersShownOrHidden.push(layer);
                  }
                  layer._show = layer.show;
              }
          }
  
          if (defined(layersShownOrHidden)) {
              for (i = 0, len = layersShownOrHidden.length; i < len; ++i) {
                  layer = layersShownOrHidden[i];
                  this.layerShownOrHidden.raiseEvent(layer, layer._layerIndex, layer.show);
              }
          }
      };
  export default ImageryLayerCollection;
  