// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

part of html;

/**
 * A base class for representing two-dimensional rectangles. This will hopefully
 * be moved merged with the dart:math Rect.
 */
// TODO(efortuna): Merge with Math rect after finalizing with Florian.
abstract class RectBase {
  //  Not used, but keeps the VM from complaining about Rect having a const
  // constructor and this one not.
  const RectBase();

  num get left;
  num get top;
  num get width;
  num get height;

  num get right => left + width;
  num get bottom => top + height;

  // NOTE! All code below should be common with Rect.

  String toString() {
    return '($left, $top, $width, $height)';
  }

  bool operator ==(other) {
    if (other is !Rect) return false;
    return left == other.left && top == other.top && width == other.width &&
        height == other.height;
  }

  int get hashCode => JenkinsSmiHash.hash4(left.hashCode, top.hashCode,
      width.hashCode, height.hashCode);

  /**
   * Computes the intersection of this rectangle and the rectangle parameter.
   * Returns null if there is no intersection.
   */
  Rect intersection(Rect rect) {
    var x0 = max(left, rect.left);
    var x1 = min(left + width, rect.left + rect.width);

    if (x0 <= x1) {
      var y0 = max(top, rect.top);
      var y1 = min(top + height, rect.top + rect.height);

      if (y0 <= y1) {
        return new Rect(x0, y0, x1 - x0, y1 - y0);
      }
    }
    return null;
  }


  /**
   * Returns whether a rectangle intersects this rectangle.
   */
  bool intersects(Rect other) {
    return (left <= other.left + other.width && other.left <= left + width &&
        top <= other.top + other.height && other.top <= top + height);
  }

  /**
   * Returns a new rectangle which completely contains this rectangle and the
   * input rectangle.
   */
  Rect union(Rect rect) {
    var right = max(this.left + this.width, rect.left + rect.width);
    var bottom = max(this.top + this.height, rect.top + rect.height);

    var left = min(this.left, rect.left);
    var top = min(this.top, rect.top);

    return new Rect(left, top, right - left, bottom - top);
  }

  /**
   * Tests whether this rectangle entirely contains another rectangle.
   */
  bool containsRect(Rect another) {
    return left <= another.left &&
           left + width >= another.left + another.width &&
           top <= another.top &&
           top + height >= another.top + another.height;
  }

  /**
   * Tests whether this rectangle entirely contains a point.
   */
  bool containsPoint(Point another) {
    return another.x >= left &&
           another.x <= left + width &&
           another.y >= top &&
           another.y <= top + height;
  }

  Rect ceil() => new Rect(left.ceil(), top.ceil(), width.ceil(), height.ceil());
  Rect floor() => new Rect(left.floor(), top.floor(), width.floor(),
      height.floor());
  Rect round() => new Rect(left.round(), top.round(), width.round(),
      height.round());

  /**
   * Truncates coordinates to integers and returns the result as a new
   * rectangle.
   */
  Rect toInt() => new Rect(left.toInt(), top.toInt(), width.toInt(),
      height.toInt());

  Point get topLeft => new Point(this.left, this.top);
  Point get bottomRight => new Point(this.left + this.width,
      this.top + this.height);
}


/**
 * A class for representing two-dimensional rectangles.
 *
 * This class is distinctive from RectBase in that it enforces that its
 * properties are immutable.
 */
class Rect extends RectBase {
  final num left;
  final num top;
  final num width;
  final num height;

  const Rect(this.left, this.top, this.width, this.height): super();

  factory Rect.fromPoints(Point a, Point b) {
    var left;
    var width;
    if (a.x < b.x) {
      left = a.x;
      width = b.x - left;
    } else {
      left = b.x;
      width = a.x - left;
    }
    var top;
    var height;
    if (a.y < b.y) {
      top = a.y;
      height = b.y - top;
    } else {
      top = b.y;
      height = a.y - top;
    }

    return new Rect(left, top, width, height);
  }
}