/**
 * @license
 * Copyright The Closure Library Authors.
 * SPDX-License-Identifier: Apache-2.0
 */


/**
 * @fileoverview Represents a path used with a Graphics implementation.
 */

goog.provide('goog.math.Path');
goog.provide('goog.math.Path.Segment');

goog.require('goog.array');
goog.require('goog.math');
goog.require('goog.math.AffineTransform');



/**
 * Creates a path object. A path is a sequence of segments and may be open or
 * closed. Path uses the EVEN-ODD fill rule for determining the interior of the
 * path. A path must start with a moveTo command.
 *
 * A "simple" path does not contain any arcs and may be transformed using
 * the `transform` method.
 *
 * @struct
 * @constructor
 * @final
 */
goog.math.Path = function() {
  'use strict';
  /**
   * The segment types that constitute this path.
   * @private {!Array<goog.math.Path.Segment>}
   */
  this.segments_ = [];

  /**
   * The number of repeated segments of the current type.
   * @type {!Array<number>}
   * @private
   */
  this.count_ = [];

  /**
   * The arguments corresponding to each of the segments.
   * @type {!Array<number>}
   * @private
   */
  this.arguments_ = [];

  /**
   * The coordinates of the point which closes the path (the point of the
   * last moveTo command).
   * @type {Array<number>?}
   * @private
   */
  this.closePoint_ = null;

  /**
   * The coordinates most recently added to the end of the path.
   * @type {Array<number>?}
   * @private
   */
  this.currentPoint_ = null;

  /**
   * Flag for whether this is a simple path (contains no arc segments).
   * @type {boolean}
   * @private
   */
  this.simple_ = true;
};


/**
 * Path segment types.
 * @enum {number}
 */
goog.math.Path.Segment = {
  MOVETO: 0,
  LINETO: 1,
  CURVETO: 2,
  ARCTO: 3,
  CLOSE: 4
};


/**
 * The number of points for each segment type.
 * @type {!Array<number>}
 * @private
 */
goog.math.Path.segmentArgCounts_ = (function() {
  'use strict';
  var counts = [];
  counts[goog.math.Path.Segment.MOVETO] = 2;
  counts[goog.math.Path.Segment.LINETO] = 2;
  counts[goog.math.Path.Segment.CURVETO] = 6;
  counts[goog.math.Path.Segment.ARCTO] = 6;
  counts[goog.math.Path.Segment.CLOSE] = 0;
  return counts;
})();


/**
 * Returns an array of the segment types in this path, in the order of their
 * appearance. Adjacent segments of the same type are collapsed into a single
 * entry in the array. The returned array is a copy; modifications are not
 * reflected in the Path object.
 * @return {!Array<number>}
 */
goog.math.Path.prototype.getSegmentTypes = function() {
  'use strict';
  return this.segments_.concat();
};


/**
 * Returns an array of the number of times each segment type repeats in this
 * path, in order. The returned array is a copy; modifications are not reflected
 * in the Path object.
 * @return {!Array<number>}
 */
goog.math.Path.prototype.getSegmentCounts = function() {
  'use strict';
  return this.count_.concat();
};


/**
 * Returns an array of all arguments for the segments of this path object, in
 * order. The returned array is a copy; modifications are not reflected in the
 * Path object.
 * @return {!Array<number>}
 */
goog.math.Path.prototype.getSegmentArgs = function() {
  'use strict';
  return this.arguments_.concat();
};


/**
 * Returns the number of points for a segment type.
 *
 * @param {number} segment The segment type.
 * @return {number} The number of points.
 */
goog.math.Path.getSegmentCount = function(segment) {
  'use strict';
  return goog.math.Path.segmentArgCounts_[segment];
};


/**
 * Appends another path to the end of this path.
 *
 * @param {!goog.math.Path} path The path to append.
 * @return {!goog.math.Path} This path.
 */
goog.math.Path.prototype.appendPath = function(path) {
  'use strict';
  if (path.currentPoint_) {
    Array.prototype.push.apply(this.segments_, path.segments_);
    Array.prototype.push.apply(this.count_, path.count_);
    Array.prototype.push.apply(this.arguments_, path.arguments_);
    this.currentPoint_ = path.currentPoint_.concat();
    this.closePoint_ = path.closePoint_.concat();
    this.simple_ = this.simple_ && path.simple_;
  }
  return this;
};


/**
 * Clears the path.
 *
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.clear = function() {
  'use strict';
  this.segments_.length = 0;
  this.count_.length = 0;
  this.arguments_.length = 0;
  this.closePoint_ = null;
  this.currentPoint_ = null;
  this.simple_ = true;
  return this;
};


/**
 * Adds a point to the path by moving to the specified point. Repeated moveTo
 * commands are collapsed into a single moveTo.
 *
 * @param {number} x X coordinate of destination point.
 * @param {number} y Y coordinate of destination point.
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.moveTo = function(x, y) {
  'use strict';
  if (goog.array.peek(this.segments_) == goog.math.Path.Segment.MOVETO) {
    this.arguments_.length -= 2;
  } else {
    this.segments_.push(goog.math.Path.Segment.MOVETO);
    this.count_.push(1);
  }
  this.arguments_.push(x, y);
  this.currentPoint_ = this.closePoint_ = [x, y];
  return this;
};


/**
 * Adds points to the path by drawing a straight line to each point.
 *
 * @param {...number} var_args The coordinates of each destination point as x, y
 *     value pairs.
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.lineTo = function(var_args) {
  'use strict';
  return this.lineTo_(arguments);
};


/**
 * Adds points to the path by drawing a straight line to each point.
 *
 * @param {!Array<number>} coordinates The coordinates of each
 *     destination point as x, y value pairs.
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.lineToFromArray = function(coordinates) {
  'use strict';
  return this.lineTo_(coordinates);
};


/**
 * Adds points to the path by drawing a straight line to each point.
 *
 * @param {!Array<number>|Arguments} coordinates The coordinates of each
 *     destination point as x, y value pairs.
 * @return {!goog.math.Path} The path itself.
 * @private
 */
goog.math.Path.prototype.lineTo_ = function(coordinates) {
  'use strict';
  var lastSegment = goog.array.peek(this.segments_);
  if (lastSegment == null) {
    throw new Error('Path cannot start with lineTo');
  }
  if (lastSegment != goog.math.Path.Segment.LINETO) {
    this.segments_.push(goog.math.Path.Segment.LINETO);
    this.count_.push(0);
  }
  for (var i = 0; i < coordinates.length; i += 2) {
    var x = coordinates[i];
    var y = coordinates[i + 1];
    this.arguments_.push(x, y);
  }
  this.count_[this.count_.length - 1] += i / 2;
  this.currentPoint_ = [x, y];
  return this;
};


/**
 * Adds points to the path by drawing cubic Bezier curves. Each curve is
 * specified using 3 points (6 coordinates) - two control points and the end
 * point of the curve.
 *
 * @param {...number} var_args The coordinates specifying each curve in sets of
 *     6 points: {@code [x1, y1]} the first control point, {@code [x2, y2]} the
 *     second control point and {@code [x, y]} the end point.
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.curveTo = function(var_args) {
  'use strict';
  return this.curveTo_(arguments);
};


/**
 * Adds points to the path by drawing cubic Bezier curves. Each curve is
 * specified using 3 points (6 coordinates) - two control points and the end
 * point of the curve.
 *
 * @param {!Array<number>} coordinates The coordinates specifying
 *     each curve in sets of 6 points: {@code [x1, y1]} the first control point,
 *     {@code [x2, y2]} the second control point and {@code [x, y]} the end
 *     point.
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.curveToFromArray = function(coordinates) {
  'use strict';
  return this.curveTo_(coordinates);
};


/**
 * Adds points to the path by drawing cubic Bezier curves. Each curve is
 * specified using 3 points (6 coordinates) - two control points and the end
 * point of the curve.
 *
 * @param {!Array<number>|Arguments} coordinates The coordinates specifying
 *     each curve in sets of 6 points: {@code [x1, y1]} the first control point,
 *     {@code [x2, y2]} the second control point and {@code [x, y]} the end
 *     point.
 * @return {!goog.math.Path} The path itself.
 * @private
 */
goog.math.Path.prototype.curveTo_ = function(coordinates) {
  'use strict';
  var lastSegment = goog.array.peek(this.segments_);
  if (lastSegment == null) {
    throw new Error('Path cannot start with curve');
  }
  if (lastSegment != goog.math.Path.Segment.CURVETO) {
    this.segments_.push(goog.math.Path.Segment.CURVETO);
    this.count_.push(0);
  }
  for (var i = 0; i < coordinates.length; i += 6) {
    var x = coordinates[i + 4];
    var y = coordinates[i + 5];
    this.arguments_.push(
        coordinates[i], coordinates[i + 1], coordinates[i + 2],
        coordinates[i + 3], x, y);
  }
  this.count_[this.count_.length - 1] += i / 6;
  this.currentPoint_ = [x, y];
  return this;
};


/**
 * Adds a path command to close the path by connecting the
 * last point to the first point.
 *
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.close = function() {
  'use strict';
  var lastSegment = goog.array.peek(this.segments_);
  if (lastSegment == null) {
    throw new Error('Path cannot start with close');
  }
  if (lastSegment != goog.math.Path.Segment.CLOSE) {
    this.segments_.push(goog.math.Path.Segment.CLOSE);
    this.count_.push(1);
    this.currentPoint_ = this.closePoint_;
  }
  return this;
};


/**
 * Adds a path command to draw an arc centered at the point {@code (cx, cy)}
 * with radius `rx` along the x-axis and `ry` along the y-axis from
 * `startAngle` through `extent` degrees. Positive rotation is in
 * the direction from positive x-axis to positive y-axis.
 *
 * @param {number} cx X coordinate of center of ellipse.
 * @param {number} cy Y coordinate of center of ellipse.
 * @param {number} rx Radius of ellipse on x axis.
 * @param {number} ry Radius of ellipse on y axis.
 * @param {number} fromAngle Starting angle measured in degrees from the
 *     positive x-axis.
 * @param {number} extent The span of the arc in degrees.
 * @param {boolean} connect If true, the starting point of the arc is connected
 *     to the current point.
 * @return {!goog.math.Path} The path itself.
 * @deprecated Use `arcTo` or `arcToAsCurves` instead.
 */
goog.math.Path.prototype.arc = function(
    cx, cy, rx, ry, fromAngle, extent, connect) {
  'use strict';
  var startX = cx + goog.math.angleDx(fromAngle, rx);
  var startY = cy + goog.math.angleDy(fromAngle, ry);
  if (connect) {
    if (!this.currentPoint_ || startX != this.currentPoint_[0] ||
        startY != this.currentPoint_[1]) {
      this.lineTo(startX, startY);
    }
  } else {
    this.moveTo(startX, startY);
  }
  return this.arcTo(rx, ry, fromAngle, extent);
};


/**
 * Adds a path command to draw an arc starting at the path's current point,
 * with radius `rx` along the x-axis and `ry` along the y-axis from
 * `startAngle` through `extent` degrees. Positive rotation is in
 * the direction from positive x-axis to positive y-axis.
 *
 * This method makes the path non-simple.
 *
 * @param {number} rx Radius of ellipse on x axis.
 * @param {number} ry Radius of ellipse on y axis.
 * @param {number} fromAngle Starting angle measured in degrees from the
 *     positive x-axis.
 * @param {number} extent The span of the arc in degrees.
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.arcTo = function(rx, ry, fromAngle, extent) {
  'use strict';
  var cx = this.currentPoint_[0] - goog.math.angleDx(fromAngle, rx);
  var cy = this.currentPoint_[1] - goog.math.angleDy(fromAngle, ry);
  var ex = cx + goog.math.angleDx(fromAngle + extent, rx);
  var ey = cy + goog.math.angleDy(fromAngle + extent, ry);
  this.segments_.push(goog.math.Path.Segment.ARCTO);
  this.count_.push(1);
  this.arguments_.push(rx, ry, fromAngle, extent, ex, ey);
  this.simple_ = false;
  this.currentPoint_ = [ex, ey];
  return this;
};


/**
 * Same as `arcTo`, but approximates the arc using bezier curves.
.* As a result, this method does not affect the simplified status of this path.
 * The algorithm is adapted from `java.awt.geom.ArcIterator`.
 *
 * @param {number} rx Radius of ellipse on x axis.
 * @param {number} ry Radius of ellipse on y axis.
 * @param {number} fromAngle Starting angle measured in degrees from the
 *     positive x-axis.
 * @param {number} extent The span of the arc in degrees.
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.arcToAsCurves = function(rx, ry, fromAngle, extent) {
  'use strict';
  var cx = this.currentPoint_[0] - goog.math.angleDx(fromAngle, rx);
  var cy = this.currentPoint_[1] - goog.math.angleDy(fromAngle, ry);
  var extentRad = goog.math.toRadians(extent);
  var arcSegs = Math.ceil(Math.abs(extentRad) / Math.PI * 2);
  var inc = extentRad / arcSegs;
  var angle = goog.math.toRadians(fromAngle);
  for (var j = 0; j < arcSegs; j++) {
    var relX = Math.cos(angle);
    var relY = Math.sin(angle);
    var z = 4 / 3 * Math.sin(inc / 2) / (1 + Math.cos(inc / 2));
    var c0 = cx + (relX - z * relY) * rx;
    var c1 = cy + (relY + z * relX) * ry;
    angle += inc;
    relX = Math.cos(angle);
    relY = Math.sin(angle);
    this.curveTo(
        c0, c1, cx + (relX + z * relY) * rx, cy + (relY - z * relX) * ry,
        cx + relX * rx, cy + relY * ry);
  }
  return this;
};


/**
 * Iterates over the path calling the supplied callback once for each path
 * segment. The arguments to the callback function are the segment type and
 * an array of its arguments.
 *
 * The `LINETO` and `CURVETO` arrays can contain multiple
 * segments of the same type. The number of segments is the length of the
 * array divided by the segment length (2 for lines, 6 for  curves).
 *
 * As a convenience the `ARCTO` segment also includes the end point as the
 * last two arguments: {@code rx, ry, fromAngle, extent, x, y}.
 *
 * @param {function(!goog.math.Path.Segment, !Array<number>)} callback
 *     The function to call with each path segment.
 */
goog.math.Path.prototype.forEachSegment = function(callback) {
  'use strict';
  var points = this.arguments_;
  var index = 0;
  for (var i = 0, length = this.segments_.length; i < length; i++) {
    var seg = this.segments_[i];
    var n = goog.math.Path.segmentArgCounts_[seg] * this.count_[i];
    callback(seg, points.slice(index, index + n));
    index += n;
  }
};


/**
 * Returns the coordinates most recently added to the end of the path.
 *
 * @return {Array<number>?} An array containing the ending coordinates of the
 *     path of the form {@code [x, y]}.
 */
goog.math.Path.prototype.getCurrentPoint = function() {
  'use strict';
  return this.currentPoint_ && this.currentPoint_.concat();
};


/**
 * @return {!goog.math.Path} A copy of this path.
 */
goog.math.Path.prototype.clone = function() {
  'use strict';
  var path = new goog.math.Path();
  path.segments_ = this.segments_.concat();
  path.count_ = this.count_.concat();
  path.arguments_ = this.arguments_.concat();
  path.closePoint_ = this.closePoint_ && this.closePoint_.concat();
  path.currentPoint_ = this.currentPoint_ && this.currentPoint_.concat();
  path.simple_ = this.simple_;
  return path;
};


/**
 * Returns true if this path contains no arcs. Simplified paths can be
 * created using `createSimplifiedPath`.
 *
 * @return {boolean} True if the path contains no arcs.
 */
goog.math.Path.prototype.isSimple = function() {
  'use strict';
  return this.simple_;
};


/**
 * A map from segment type to the path function to call to simplify a path.
 * @private {!Object<goog.math.Path.Segment, function(this: goog.math.Path)>}
 */
goog.math.Path.simplifySegmentMap_ = (function() {
  'use strict';
  var map = {};
  map[goog.math.Path.Segment.MOVETO] = goog.math.Path.prototype.moveTo;
  map[goog.math.Path.Segment.LINETO] = goog.math.Path.prototype.lineTo;
  map[goog.math.Path.Segment.CLOSE] = goog.math.Path.prototype.close;
  map[goog.math.Path.Segment.CURVETO] = goog.math.Path.prototype.curveTo;
  map[goog.math.Path.Segment.ARCTO] = goog.math.Path.prototype.arcToAsCurves;
  return map;
})();


/**
 * Creates a copy of the given path, replacing `arcTo` with
 * `arcToAsCurves`. The resulting path is simplified and can
 * be transformed.
 *
 * @param {!goog.math.Path} src The path to simplify.
 * @return {!goog.math.Path} A new simplified path.
 */
goog.math.Path.createSimplifiedPath = function(src) {
  'use strict';
  if (src.isSimple()) {
    return src.clone();
  }
  var path = new goog.math.Path();
  src.forEachSegment(function(segment, args) {
    'use strict';
    goog.math.Path.simplifySegmentMap_[segment].apply(path, args);
  });
  return path;
};


// TODO(chrisn): Delete this method
/**
 * Creates a transformed copy of this path. The path is simplified
 * {@see #createSimplifiedPath} prior to transformation.
 *
 * @param {!goog.math.AffineTransform} tx The transformation to perform.
 * @return {!goog.math.Path} A new, transformed path.
 */
goog.math.Path.prototype.createTransformedPath = function(tx) {
  'use strict';
  var path = goog.math.Path.createSimplifiedPath(this);
  path.transform(tx);
  return path;
};


/**
 * Transforms the path. Only simple paths are transformable. Attempting
 * to transform a non-simple path will throw an error.
 *
 * @param {!goog.math.AffineTransform} tx The transformation to perform.
 * @return {!goog.math.Path} The path itself.
 */
goog.math.Path.prototype.transform = function(tx) {
  'use strict';
  if (!this.isSimple()) {
    throw new Error('Non-simple path');
  }
  tx.transform(
      this.arguments_, 0, this.arguments_, 0, this.arguments_.length / 2);
  if (this.closePoint_) {
    tx.transform(this.closePoint_, 0, this.closePoint_, 0, 1);
  }
  if (this.currentPoint_ && this.closePoint_ != this.currentPoint_) {
    tx.transform(this.currentPoint_, 0, this.currentPoint_, 0, 1);
  }
  return this;
};


/**
 * @return {boolean} Whether the path is empty.
 */
goog.math.Path.prototype.isEmpty = function() {
  'use strict';
  return this.segments_.length == 0;
};
