/**
 * Cesium - https://github.com/CesiumGS/cesium
 *
 * Copyright 2011-2020 Cesium Contributors
 *
 * 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.
 *
 * Columbus View (Pat. Pend.)
 *
 * Portions licensed separately.
 * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
 */

define(['exports', './Matrix2-265d9610', './RuntimeError-5b082e8f', './when-4bbc8319', './Transforms-8b90e17c'], (function (exports, Matrix2, RuntimeError, when, Transforms) { 'use strict';

  /**
   * A bounding rectangle given by a corner, width and height.
   * @alias BoundingRectangle
   * @constructor
   *
   * @param {Number} [x=0.0] The x coordinate of the rectangle.
   * @param {Number} [y=0.0] The y coordinate of the rectangle.
   * @param {Number} [width=0.0] The width of the rectangle.
   * @param {Number} [height=0.0] The height of the rectangle.
   *
   * @see BoundingSphere
   * @see Packable
   */
  function BoundingRectangle(x, y, width, height) {
    /**
     * The x coordinate of the rectangle.
     * @type {Number}
     * @default 0.0
     */
    this.x = when.defaultValue(x, 0.0);

    /**
     * The y coordinate of the rectangle.
     * @type {Number}
     * @default 0.0
     */
    this.y = when.defaultValue(y, 0.0);

    /**
     * The width of the rectangle.
     * @type {Number}
     * @default 0.0
     */
    this.width = when.defaultValue(width, 0.0);

    /**
     * The height of the rectangle.
     * @type {Number}
     * @default 0.0
     */
    this.height = when.defaultValue(height, 0.0);
  }

  /**
   * The number of elements used to pack the object into an array.
   * @type {Number}
   */
  BoundingRectangle.packedLength = 4;

  /**
   * Stores the provided instance into the provided array.
   *
   * @param {BoundingRectangle} value The value to pack.
   * @param {Number[]} array The array to pack into.
   * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
   *
   * @returns {Number[]} The array that was packed into
   */
  BoundingRectangle.pack = function (value, array, startingIndex) {
    //>>includeStart('debug', pragmas.debug);
    RuntimeError.Check.typeOf.object("value", value);
    RuntimeError.Check.defined("array", array);
    //>>includeEnd('debug');

    startingIndex = when.defaultValue(startingIndex, 0);

    array[startingIndex++] = value.x;
    array[startingIndex++] = value.y;
    array[startingIndex++] = value.width;
    array[startingIndex] = value.height;

    return array;
  };

  /**
   * Retrieves an instance from a packed array.
   *
   * @param {Number[]} array The packed array.
   * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
   * @param {BoundingRectangle} [result] The object into which to store the result.
   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
   */
  BoundingRectangle.unpack = function (array, startingIndex, result) {
    //>>includeStart('debug', pragmas.debug);
    RuntimeError.Check.defined("array", array);
    //>>includeEnd('debug');

    startingIndex = when.defaultValue(startingIndex, 0);

    if (!when.defined(result)) {
      result = new BoundingRectangle();
    }
    result.x = array[startingIndex++];
    result.y = array[startingIndex++];
    result.width = array[startingIndex++];
    result.height = array[startingIndex];
    return result;
  };

  /**
   * Computes a bounding rectangle enclosing the list of 2D points.
   * The rectangle is oriented with the corner at the bottom left.
   *
   * @param {Cartesian2[]} positions List of points that the bounding rectangle will enclose.  Each point must have <code>x</code> and <code>y</code> properties.
   * @param {BoundingRectangle} [result] The object onto which to store the result.
   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
   */
  BoundingRectangle.fromPoints = function (positions, result) {
    if (!when.defined(result)) {
      result = new BoundingRectangle();
    }

    if (!when.defined(positions) || positions.length === 0) {
      result.x = 0;
      result.y = 0;
      result.width = 0;
      result.height = 0;
      return result;
    }

    const length = positions.length;

    let minimumX = positions[0].x;
    let minimumY = positions[0].y;

    let maximumX = positions[0].x;
    let maximumY = positions[0].y;

    for (let i = 1; i < length; i++) {
      const p = positions[i];
      const x = p.x;
      const y = p.y;

      minimumX = Math.min(x, minimumX);
      maximumX = Math.max(x, maximumX);
      minimumY = Math.min(y, minimumY);
      maximumY = Math.max(y, maximumY);
    }

    result.x = minimumX;
    result.y = minimumY;
    result.width = maximumX - minimumX;
    result.height = maximumY - minimumY;
    return result;
  };

  const defaultProjection = new Transforms.GeographicProjection();
  const fromRectangleLowerLeft = new Matrix2.Cartographic();
  const fromRectangleUpperRight = new Matrix2.Cartographic();
  /**
   * Computes a bounding rectangle from a rectangle.
   *
   * @param {Rectangle} rectangle The valid rectangle used to create a bounding rectangle.
   * @param {Object} [projection=GeographicProjection] The projection used to project the rectangle into 2D.
   * @param {BoundingRectangle} [result] The object onto which to store the result.
   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
   */
  BoundingRectangle.fromRectangle = function (rectangle, projection, result) {
    if (!when.defined(result)) {
      result = new BoundingRectangle();
    }

    if (!when.defined(rectangle)) {
      result.x = 0;
      result.y = 0;
      result.width = 0;
      result.height = 0;
      return result;
    }

    projection = when.defaultValue(projection, defaultProjection);

    const lowerLeft = projection.project(
      Matrix2.Rectangle.southwest(rectangle, fromRectangleLowerLeft)
    );
    const upperRight = projection.project(
      Matrix2.Rectangle.northeast(rectangle, fromRectangleUpperRight)
    );

    Matrix2.Cartesian2.subtract(upperRight, lowerLeft, upperRight);

    result.x = lowerLeft.x;
    result.y = lowerLeft.y;
    result.width = upperRight.x;
    result.height = upperRight.y;
    return result;
  };

  /**
   * Duplicates a BoundingRectangle instance.
   *
   * @param {BoundingRectangle} rectangle The bounding rectangle to duplicate.
   * @param {BoundingRectangle} [result] The object onto which to store the result.
   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided. (Returns undefined if rectangle is undefined)
   */
  BoundingRectangle.clone = function (rectangle, result) {
    if (!when.defined(rectangle)) {
      return undefined;
    }

    if (!when.defined(result)) {
      return new BoundingRectangle(
        rectangle.x,
        rectangle.y,
        rectangle.width,
        rectangle.height
      );
    }

    result.x = rectangle.x;
    result.y = rectangle.y;
    result.width = rectangle.width;
    result.height = rectangle.height;
    return result;
  };

  /**
   * Computes a bounding rectangle that is the union of the left and right bounding rectangles.
   *
   * @param {BoundingRectangle} left A rectangle to enclose in bounding rectangle.
   * @param {BoundingRectangle} right A rectangle to enclose in a bounding rectangle.
   * @param {BoundingRectangle} [result] The object onto which to store the result.
   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
   */
  BoundingRectangle.union = function (left, right, result) {
    //>>includeStart('debug', pragmas.debug);
    RuntimeError.Check.typeOf.object("left", left);
    RuntimeError.Check.typeOf.object("right", right);
    //>>includeEnd('debug');

    if (!when.defined(result)) {
      result = new BoundingRectangle();
    }

    const lowerLeftX = Math.min(left.x, right.x);
    const lowerLeftY = Math.min(left.y, right.y);
    const upperRightX = Math.max(left.x + left.width, right.x + right.width);
    const upperRightY = Math.max(left.y + left.height, right.y + right.height);

    result.x = lowerLeftX;
    result.y = lowerLeftY;
    result.width = upperRightX - lowerLeftX;
    result.height = upperRightY - lowerLeftY;
    return result;
  };

  /**
   * Computes a bounding rectangle by enlarging the provided rectangle until it contains the provided point.
   *
   * @param {BoundingRectangle} rectangle A rectangle to expand.
   * @param {Cartesian2} point A point to enclose in a bounding rectangle.
   * @param {BoundingRectangle} [result] The object onto which to store the result.
   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
   */
  BoundingRectangle.expand = function (rectangle, point, result) {
    //>>includeStart('debug', pragmas.debug);
    RuntimeError.Check.typeOf.object("rectangle", rectangle);
    RuntimeError.Check.typeOf.object("point", point);
    //>>includeEnd('debug');

    result = BoundingRectangle.clone(rectangle, result);

    const width = point.x - result.x;
    const height = point.y - result.y;

    if (width > result.width) {
      result.width = width;
    } else if (width < 0) {
      result.width -= width;
      result.x = point.x;
    }

    if (height > result.height) {
      result.height = height;
    } else if (height < 0) {
      result.height -= height;
      result.y = point.y;
    }

    return result;
  };

  /**
   * Determines if two rectangles intersect.
   *
   * @param {BoundingRectangle} left A rectangle to check for intersection.
   * @param {BoundingRectangle} right The other rectangle to check for intersection.
   * @returns {Intersect} <code>Intersect.INTERSECTING</code> if the rectangles intersect, <code>Intersect.OUTSIDE</code> otherwise.
   */
  BoundingRectangle.intersect = function (left, right) {
    //>>includeStart('debug', pragmas.debug);
    RuntimeError.Check.typeOf.object("left", left);
    RuntimeError.Check.typeOf.object("right", right);
    //>>includeEnd('debug');

    const leftX = left.x;
    const leftY = left.y;
    const rightX = right.x;
    const rightY = right.y;
    if (
      !(
        leftX > rightX + right.width ||
        leftX + left.width < rightX ||
        leftY + left.height < rightY ||
        leftY > rightY + right.height
      )
    ) {
      return Transforms.Intersect.INTERSECTING;
    }

    return Transforms.Intersect.OUTSIDE;
  };

  /**
   * Compares the provided BoundingRectangles componentwise and returns
   * <code>true</code> if they are equal, <code>false</code> otherwise.
   *
   * @param {BoundingRectangle} [left] The first BoundingRectangle.
   * @param {BoundingRectangle} [right] The second BoundingRectangle.
   * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
   */
  BoundingRectangle.equals = function (left, right) {
    return (
      left === right ||
      (when.defined(left) &&
        when.defined(right) &&
        left.x === right.x &&
        left.y === right.y &&
        left.width === right.width &&
        left.height === right.height)
    );
  };

  /**
   * Duplicates this BoundingRectangle instance.
   *
   * @param {BoundingRectangle} [result] The object onto which to store the result.
   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
   */
  BoundingRectangle.prototype.clone = function (result) {
    return BoundingRectangle.clone(this, result);
  };

  /**
   * Determines if this rectangle intersects with another.
   *
   * @param {BoundingRectangle} right A rectangle to check for intersection.
   * @returns {Intersect} <code>Intersect.INTERSECTING</code> if the rectangles intersect, <code>Intersect.OUTSIDE</code> otherwise.
   */
  BoundingRectangle.prototype.intersect = function (right) {
    return BoundingRectangle.intersect(this, right);
  };

  /**
   * Compares this BoundingRectangle against the provided BoundingRectangle componentwise and returns
   * <code>true</code> if they are equal, <code>false</code> otherwise.
   *
   * @param {BoundingRectangle} [right] The right hand side BoundingRectangle.
   * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
   */
  BoundingRectangle.prototype.equals = function (right) {
    return BoundingRectangle.equals(this, right);
  };

  exports.BoundingRectangle = BoundingRectangle;

}));
//# sourceMappingURL=BoundingRectangle-8f2409a1.js.map