/*
--- CSU213 Fall 2006 Lecture Notes ---------
Copyright 2006 Viera K. Proulx

Lecture 10: September 27, 2006
Abstracting over data Definitions
Part 1: The original program
*/

/*
                    +---------------------------------+                    
                    | IShape                          |                    
                    +---------------------------------+                    
                    +---------------------------------+                    
                    | double area()                   |                    
                    | double distTo0()                |                    
                    | boolean biggerThan(IShape that) |                    
                     +---------------------------------+                    
                                   |                                    
                                  / \                                   
                                  ---                                   
                                   |                                    
                 -------------------------------------                  
                 |                                   |                  
  +---------------------------------+    +---------------------------------+  
  | Circle                          |    | Square                          |  
  +---------------------------------+    +---------------------------------+  
+-| CartPt center                   |  +-| CartPt nw                       |  
| | int radius                      |  | | int size                        |  
| | String color                    |  | | String color                    |  
| +---------------------------------+  | +---------------------------------+  
| | double area()                   |  | | double area()                   |  
| | double distTo0()                |  | | double distTo0()                |  
| | boolean biggerThan(IShape that) |  | | boolean biggerThan(IShape that) |  
| +---------------------------------+  | +---------------------------------+  
+----+ +-------------------------------+
     | |
     v v                                                                     
+--------+
| CartPt |
+--------+
| int x  |
| int y  |
+--------+                                                                     

*/

// to represent a geometric shape
interface IShape {
  // to compute the area of this shape
  double area();

  // to compute the distance form this shape to the origin
  double distTo0();

  // is the area of this shape is bigger than the area of the given shape?
  boolean biggerThan(IShape that);
}

// to represent a circle
class Circle implements IShape {
  CartPt center;
  int radius;
  String color;

  Circle(CartPt center, int radius, String color) {
    this.center = center;
    this.radius = radius;
    this.color = color;
  }

/*
  // ** TEMPLATE ** 
  public returnType methodName() {
    ... this.center ...              -- CartPt
    ... this.radius ...              -- int
    ... this.color ...               -- String

    ... this.area() ...                  -- double 
    ... this.distTo0() ...               -- double 
    ... this.biggerThan(IShape that) ... -- boolean
*/
  // to compute the area of this shape
  double area(){
    return Math.PI * this.radius * this.radius;
  }

  // to compute the distance form this shape to the origin
  double distTo0(){
    return this.center.distTo0() - this.radius;
  }

  // is the area of this shape is bigger than the area of the given shape?
  boolean biggerThan(IShape that){
  /*-----------------------------------------------------------
  // ** TEMPLATE ** 
  public returnType methodName() {
    ... this.center ...     ... that.center ...     -- CartPt
    ... this.radius ...     ... that.radius ...     -- int
    ... this.color ...      ... that.color ...      -- String

    ... this.area() ...     ... that.area() ...     -- double 
    ... this.distTo0() ...  ... that.distTo0() ...  -- double 
  ------------------------------------------------------------*/
    return this.area() >= that.area();
  }
}

// to represent a square
class Square implements IShape {
  CartPt nw;
  int size;
  String color;

  Square(CartPt nw, int size, String color) {
    this.nw = nw;
    this.size = size;
    this.color = color;
  }

/*
  // ** TEMPLATE ** 
  returnType methodName() {
    ... this.nw ...              -- CartPt
    ... this.size ...            -- int
    ... this.color ...           -- String

    ... this.area() ...                  -- double 
    ... this.distTo0() ...               -- double 
    ... this.biggerThan(IShape that) ... -- boolean
  }
*/

  // to compute the area of this shape
  double area(){
    return this.size * this.size;
  }

  // to compute the distance form this shape to the origin
  double distTo0(){
    return this.nw.distTo0();
  }

  // is the area of this shape is bigger than the area of the given shape?
  boolean biggerThan(IShape that){
  /*----------------------------------------------------------
  // ** TEMPLATE ** 
  public returnType methodName() {
    ... this.nw ...         ... that.nw ...         -- CartPt
    ... this.size ...       ... that.size ...       -- int
    ... this.color ...      ... that.color ...      -- String

    ... this.area() ...     ... that.area() ...     -- double 
    ... this.distTo0() ...  ... that.distTo0() ...  -- double 
  -----------------------------------------------------------*/
    return this.area() >= that.area();
  }
}

/*
+--------+
| CartPt |
+--------+
| int x  |
| int y  |
+--------+

*/

// to represent a Cartesian point
class CartPt {
  int x;
  int y;

  CartPt(int x, int y) {
    this.x = x;
    this.y = y;
  }

  // to compute the distance form this point to the origin
  double distTo0(){
    return Math.sqrt(this.x * this.x + this.y * this.y);
  }

  // to compute the distance form this point to the given point
  double distTo(CartPt pt){
    return Math.sqrt((this.x - pt.x) * (this.x - pt.x) + 
                     (this.y - pt.y) * (this.y - pt.y));
  }
}

class Examples {
  Examples() {}

  CartPt pt1 = new CartPt(0, 0);
  CartPt pt2 = new CartPt(3, 4);
  CartPt pt3 = new CartPt(7, 1);

  IShape c1 = new Circle(new CartPt(50, 50), 10, "red");
  IShape c2 = new Circle(new CartPt(50, 50), 30, "red");
  IShape c3 = new Circle(new CartPt(30, 100), 30, "blue");

  IShape s1 = new Square(new CartPt(50, 50), 30, "red");
  IShape s2 = new Square(new CartPt(50, 50), 50, "red");
  IShape s3 = new Square(new CartPt(20, 40), 10, "green");

  // test the method distTo0 in the class CartPt
  boolean testDistTo0 = 
    (check this.pt1.distTo0() expect 0 within 0.001) &&
    (check this.pt2.distTo0() expect 5 within 0.001);
 
  // test the method distTo in the class CartPt
  boolean testDistTo = 
    (check this.pt1.distTo(this.pt2) expect 5 within 0.001) &&
    (check this.pt2.distTo(this.pt3) expect 5 within 0.001);
                        
  // test the method area in the class Circle
  boolean testCircleArea = 
    check this.c1.area() expect 314.15 within 0.01;
 
  // test the method grow in the class Circle
  boolean testSquareArea = 
    check this.s1.area() expect 900 within 0.01;

  // test the method distTo0 in the class Circle
  boolean testCircleDistTo0 = 
    (check this.c1.distTo0() expect 60.71 within 0.01) &&
    (check this.c3.distTo0() expect 74.40 within 0.01);
 
  // test the methdod distTo in the class Circle
  boolean testSquareDistTo0 = 
    (check this.s1.distTo0() expect 70.71 within 0.01) &&
    (check this.s3.distTo0() expect 44.72 within 0.01);

  // test the method biggerThan in the class Circle
  boolean testCircleBiggerThan = 
    (check this.c1.biggerThan(this.c2) expect false) && 
    (check this.c2.biggerThan(this.c1) expect true) && 
    (check this.c1.biggerThan(this.s1) expect false) && 
    (check this.c1.biggerThan(this.s3) expect true);
    
  // test the method biggerThan in the class Square
  boolean testSquareBiggerThan = 
    (check this.s1.biggerThan(this.s2) expect false) && 
    (check this.s2.biggerThan(this.s1) expect true) && 
    (check this.s1.biggerThan(this.c1) expect true) && 
    (check this.s3.biggerThan(this.c1) expect false);
}