text: import Color from "../Core/Color.js";
  import defaultValue from "../Core/defaultValue.js";
  import defined from "../Core/defined.js";
  import Event from "../Core/Event.js";
  import GeographicTilingScheme from "../Core/GeographicTilingScheme.js";
  import when from "../ThirdParty/when.js";
  
  /**
   * @typedef {Object} TileCoordinatesImageryProvider.ConstructorOptions
   *
   * Initialization options for the TileCoordinatesImageryProvider constructor
   *
   * @property {TilingScheme} [tilingScheme=new GeographicTilingScheme()] The tiling scheme for which to draw tiles.
   * @property {Ellipsoid} [ellipsoid] The ellipsoid.  If the tilingScheme is specified,
   *                    this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
   *                    parameter is specified, the WGS84 ellipsoid is used.
   * @property {Color} [color=Color.YELLOW] The color to draw the tile box and label.
   * @property {Number} [tileWidth=256] The width of the tile for level-of-detail selection purposes.
   * @property {Number} [tileHeight=256] The height of the tile for level-of-detail selection purposes.
   */
  
  /**
   * An {@link ImageryProvider} that draws a box around every rendered tile in the tiling scheme, and draws
   * a label inside it indicating the X, Y, Level coordinates of the tile.  This is mostly useful for
   * debugging terrain and imagery rendering problems.
   *
   * @alias TileCoordinatesImageryProvider
   * @constructor
   *
   * @param {TileCoordinatesImageryProvider.ConstructorOptions} [options] Object describing initialization options
   */
  function TileCoordinatesImageryProvider(options) {
    options = defaultValue(options, defaultValue.EMPTY_OBJECT);
  
    this._tilingScheme = defined(options.tilingScheme)
      ? options.tilingScheme
      : new GeographicTilingScheme({ ellipsoid: options.ellipsoid });
    this._color = defaultValue(options.color, Color.YELLOW);
    this._errorEvent = new Event();
    this._tileWidth = defaultValue(options.tileWidth, 256);
    this._tileHeight = defaultValue(options.tileHeight, 256);
    this._readyPromise = when.resolve(true);
  
    /**
     * The default alpha blending value of this provider, with 0.0 representing fully transparent and
     * 1.0 representing fully opaque.
     *
     * @type {Number|undefined}
     * @default undefined
     */
    this.defaultAlpha = undefined;
  
    /**
     * The default alpha blending value on the night side of the globe of this provider, with 0.0 representing fully transparent and
     * 1.0 representing fully opaque.
     *
     * @type {Number|undefined}
     * @default undefined
     */
    this.defaultNightAlpha = undefined;
  
    /**
     * The default alpha blending value on the day side of the globe of this provider, with 0.0 representing fully transparent and
     * 1.0 representing fully opaque.
     *
     * @type {Number|undefined}
     * @default undefined
     */
    this.defaultDayAlpha = undefined;
  
    /**
     * The default brightness of this provider.  1.0 uses the unmodified imagery color.  Less than 1.0
     * makes the imagery darker while greater than 1.0 makes it brighter.
     *
     * @type {Number|undefined}
     * @default undefined
     */
    this.defaultBrightness = undefined;
  
    /**
     * The default contrast of this provider.  1.0 uses the unmodified imagery color.  Less than 1.0 reduces
     * the contrast while greater than 1.0 increases it.
     *
     * @type {Number|undefined}
     * @default undefined
     */
    this.defaultContrast = undefined;
  
    /**
     * The default hue of this provider in radians. 0.0 uses the unmodified imagery color.
     *
     * @type {Number|undefined}
     * @default undefined
     */
    this.defaultHue = undefined;
  
    /**
     * The default saturation of this provider. 1.0 uses the unmodified imagery color. Less than 1.0 reduces the
     * saturation while greater than 1.0 increases it.
     *
     * @type {Number|undefined}
     * @default undefined
     */
    this.defaultSaturation = undefined;
  
    /**
     * The default gamma correction to apply to this provider.  1.0 uses the unmodified imagery color.
     *
     * @type {Number|undefined}
     * @default undefined
     */
    this.defaultGamma = undefined;
  
    /**
     * The default texture minification filter to apply to this provider.
     *
     * @type {TextureMinificationFilter}
     * @default undefined
     */
    this.defaultMinificationFilter = undefined;
  
    /**
     * The default texture magnification filter to apply to this provider.
     *
     * @type {TextureMagnificationFilter}
     * @default undefined
     */
    this.defaultMagnificationFilter = undefined;
  }
  
  Object.defineProperties(TileCoordinatesImageryProvider.prototype, {
    /**
     * Gets the proxy used by this provider.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Proxy}
     * @readonly
     */
    proxy: {
      get: function () {
        return undefined;
      },
    },
  
    /**
     * Gets the width of each tile, in pixels. This function should
     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Number}
     * @readonly
     */
    tileWidth: {
      get: function () {
        return this._tileWidth;
      },
    },
  
    /**
     * Gets the height of each tile, in pixels.  This function should
     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Number}
     * @readonly
     */
    tileHeight: {
      get: function () {
        return this._tileHeight;
      },
    },
  
    /**
     * Gets the maximum level-of-detail that can be requested.  This function should
     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Number|undefined}
     * @readonly
     */
    maximumLevel: {
      get: function () {
        return undefined;
      },
    },
  
    /**
     * Gets the minimum level-of-detail that can be requested.  This function should
     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Number}
     * @readonly
     */
    minimumLevel: {
      get: function () {
        return undefined;
      },
    },
  
    /**
     * Gets the tiling scheme used by this provider.  This function should
     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {TilingScheme}
     * @readonly
     */
    tilingScheme: {
      get: function () {
        return this._tilingScheme;
      },
    },
  
    /**
     * Gets the rectangle, in radians, of the imagery provided by this instance.  This function should
     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Rectangle}
     * @readonly
     */
    rectangle: {
      get: function () {
        return this._tilingScheme.rectangle;
      },
    },
  
    /**
     * Gets the tile discard policy.  If not undefined, the discard policy is responsible
     * for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
     * returns undefined, no tiles are filtered.  This function should
     * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {TileDiscardPolicy}
     * @readonly
     */
    tileDiscardPolicy: {
      get: function () {
        return undefined;
      },
    },
  
    /**
     * Gets an event that is raised when the imagery provider encounters an asynchronous error.  By subscribing
     * to the event, you will be notified of the error and can potentially recover from it.  Event listeners
     * are passed an instance of {@link TileProviderError}.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Event}
     * @readonly
     */
    errorEvent: {
      get: function () {
        return this._errorEvent;
      },
    },
  
    /**
     * Gets a value indicating whether or not the provider is ready for use.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Boolean}
     * @readonly
     */
    ready: {
      get: function () {
        return true;
      },
    },
  
    /**
     * Gets a promise that resolves to true when the provider is ready for use.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Promise.<Boolean>}
     * @readonly
     */
    readyPromise: {
      get: function () {
        return this._readyPromise;
      },
    },
  
    /**
     * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
     * the source of the imagery.  This function should not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Credit}
     * @readonly
     */
    credit: {
      get: function () {
        return undefined;
      },
    },
  
    /**
     * Gets a value indicating whether or not the images provided by this imagery provider
     * include an alpha channel.  If this property is false, an alpha channel, if present, will
     * be ignored.  If this property is true, any images without an alpha channel will be treated
     * as if their alpha is 1.0 everywhere.  Setting this property to false reduces memory usage
     * and texture upload time.
     * @memberof TileCoordinatesImageryProvider.prototype
     * @type {Boolean}
     * @readonly
     */
    hasAlphaChannel: {
      get: function () {
        return true;
      },
    },
  });
  
  /**
   * Gets the credits to be displayed when a given tile is displayed.
   *
   * @param {Number} x The tile X coordinate.
   * @param {Number} y The tile Y coordinate.
   * @param {Number} level The tile level;
   * @returns {Credit[]} The credits to be displayed when the tile is displayed.
   *
   * @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
   */
  TileCoordinatesImageryProvider.prototype.getTileCredits = function (
    x,
    y,
    level
  ) {
    return undefined;
  };
  
  /**
   * Requests the image for a given tile.  This function should
   * not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
   *
   * @param {Number} x The tile X coordinate.
   * @param {Number} y The tile Y coordinate.
   * @param {Number} level The tile level.
   * @param {Request} [request] The request object. Intended for internal use only.
   * @returns {Promise.<HTMLImageElement|HTMLCanvasElement>|undefined} A promise for the image that will resolve when the image is available, or
   *          undefined if there are too many active requests to the server, and the request
   *          should be retried later.  The resolved image may be either an
   *          Image or a Canvas DOM object.
   */
  TileCoordinatesImageryProvider.prototype.requestImage = function (
    x,
    y,
    level,
    request
  ) {
    const canvas = document.createElement("canvas");
    canvas.width = 256;
    canvas.height = 256;
    const context = canvas.getContext("2d");
  
    const cssColor = this._color.toCssColorString();
  
    context.strokeStyle = cssColor;
    context.lineWidth = 2;
    context.strokeRect(1, 1, 255, 255);
  
    context.font = "bold 25px Arial";
    context.textAlign = "center";
    context.fillStyle = cssColor;
    context.fillText(`L: ${level}`, 124, 86);
    context.fillText(`X: ${x}`, 124, 136);
    context.fillText(`Y: ${y}`, 124, 186);
  
    return canvas;
  };
  
  /**
   * Picking features is not currently supported by this imagery provider, so this function simply returns
   * undefined.
   *
   * @param {Number} x The tile X coordinate.
   * @param {Number} y The tile Y coordinate.
   * @param {Number} level The tile level.
   * @param {Number} longitude The longitude at which to pick features.
   * @param {Number} latitude  The latitude at which to pick features.
   * @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
   *                   picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}
   *                   instances.  The array may be empty if no features are found at the given location.
   *                   It may also be undefined if picking is not supported.
   */
  TileCoordinatesImageryProvider.prototype.pickFeatures = function (
    x,
    y,
    level,
    longitude,
    latitude
  ) {
    return undefined;
  };
  export default TileCoordinatesImageryProvider;
  