package algs12;

import java.awt.Color;
import stdlib.*;

/**
 * For this assignment, you must do two things:
 *
 * 1. Complete the MyRectangle class at the bottom of this file. It is not a
 * public class, but don't worry about that. I've put two classes in one file so
 * that you need only hand in a single file.
 *
 * In particular, you should get the testEquals method to work without throwing
 * any exceptions.
 *
 * 2. Modify the draw method of MyRecursiveRectangles so that it behaves as
 * demonstrated here:
 *
 * <pre>
 * http://fpl.cs.depaul.edu/jriely/ds1/extras/RecursiveRectangles.mp4
 * </pre>
 *
 * To do this only requires very minor modifications to the function.
 *
 * It is not necessary, but if you want to learn more about the drawing classes,
 * see here:
 *
 * <pre>
 * http://fpl.cs.depaul.edu/jriely/ds1/code/doc-public/stdlib/StdDraw.html
 * http://introcs.cs.princeton.edu/java/15inout/
 * </pre>
 */

public class MyRecursiveRectangles {
  public static Color randomColor () {
    int r = StdRandom.uniform (256);
    int g = StdRandom.uniform (256);
    int b = StdRandom.uniform (256);
    return new Color (r, g, b);
  }
  public static final int VARIANCE = 60;
  public static int randomByteAbove (int i) {
    return StdRandom.uniform (Math.max (0, i - 1), Math.min (i + VARIANCE, 256));
  }
  public static int randomByteBelow (int i) {
    return StdRandom.uniform (Math.max (0, i - VARIANCE), Math.min (i + 1, 256));
  }
  public static Color randomColorLight (Color c) {
    int r = randomByteAbove (c.getRed ());
    int g = randomByteAbove (c.getGreen ());
    int b = randomByteAbove (c.getBlue ());
    return new Color (r, g, b);
  }
  public static Color randomColorDark (Color c) {
    int r = randomByteBelow (c.getRed ());
    int g = randomByteBelow (c.getGreen ());
    int b = randomByteBelow (c.getBlue ());
    return new Color (r, g, b);
  }
  public static void draw (MyRect rect, int level, Color c) {
    // TODO:
    // edit this function so that it recursively draws levels from here down to level 0,
    //   decrementing by 1 each time
    // Optionally, you can also stop recursing if the area of the rectangle is less than 0.1

    // The following line might help while debugging:
    //StdOut.format ("rect=%s, height=%f width=%f area=%f xmid=%f ymid=%f\n", rect, rect.height (), rect.width (), rect.area (), rect.xmid (), rect.ymid ());
    StdDraw.setPenColor (c);
    rect.drawEllipse ();
    StdDraw.show (50);
    if (level % 2 == 0) {
      double xmid = StdRandom.uniform (rect.xmin (), rect.xmax ());
      StdDraw.setPenColor (StdDraw.BLACK);
      StdDraw.line (xmid, rect.ymin (), xmid, rect.ymax ());
      MyRect left = new MyRect (rect.xmin (), rect.ymin (), xmid, rect.ymax ());
      MyRect right = new MyRect (xmid, rect.ymin (), rect.xmax (), rect.ymax ());
      StdDraw.setPenColor (randomColorLight (c));
      left.drawEllipse ();
      StdDraw.setPenColor (randomColorDark (c));
      right.drawEllipse ();
    } else {
      double ymid = StdRandom.uniform (rect.ymin (), rect.ymax ());
      StdDraw.setPenColor (StdDraw.BLACK);
      StdDraw.line (rect.xmin (), ymid, rect.xmax (), ymid);
      MyRect below = new MyRect (rect.xmin (), rect.ymin (), rect.xmax (), ymid);
      MyRect above = new MyRect (rect.xmin (), ymid, rect.xmax (), rect.ymax ());
      StdDraw.setPenColor (randomColorLight (c));
      below.drawEllipse ();
      StdDraw.setPenColor (randomColorDark (c));
      above.drawEllipse ();
    }
  }
  public static void testEquals () {
    // this method should not throw any exceptions!
    MyRect r1 = new MyRect (1, 1, 2, 2);
    if (!r1.equals (r1)) {
      throw new Error ();
    }
    if (!r1.equals (new MyRect (1, 1, 2, 2))) {
      throw new Error ();
    }
    if (r1.equals (null)) {
      throw new Error ();
    }
    if (r1.equals (new Object ())) {
      throw new Error ();
    }
    if (r1.equals (new MyRect (0, 1, 2, 2))) {
      throw new Error ();
    }
    if (r1.equals (new MyRect (1, 0, 2, 2))) {
      throw new Error ();
    }
    if (r1.equals (new MyRect (1, 1, 3, 2))) {
      throw new Error ();
    }
    if (r1.equals (new MyRect (1, 1, 2, 3))) {
      throw new Error ();
    }
  }

  public static final double DIM = 1.0;
  public static void main (String[] args) {
    testEquals();

    StdDraw.setCanvasSize (800, 800); // in pixels
    StdDraw.setXscale (-DIM, DIM);
    StdDraw.setYscale (-DIM, DIM);
    MyRect rect = new MyRect (-DIM, -DIM, DIM, DIM);

    //StdRandom.setSeed (0); // uncomment this if you want the same behavior every time you run the program
    Color initialColor = randomColor (); //new Color(127,127,127)
    //long seed = StdRandom.getSeed ();
    for (int numLevels = 1; numLevels < 8; numLevels += 1) {
      //StdRandom.setSeed (seed);
      StdDraw.clear ();
      draw (rect, numLevels, initialColor);
      StdDraw.show (1000);
    }
  }
}

// An axis aligned rectangle
class MyRect {
  // TODO: add fields

  // construct the axis-aligned rectangle "[xmin, xmax] x [ymin, ymax]"
  public MyRect (double xmin, double ymin, double xmax, double ymax) {
    if (xmax < xmin || ymax < ymin) {
      throw new IllegalArgumentException ("Invalid rectangle");
    }
    // TODO: set the fields
  }

  // accessor methods for 4 coordinates
  public double xmin () {
    return /* TODO */0;
  }
  public double ymin () {
    return /* TODO */0;
  }
  public double xmax () {
    return /* TODO */0;
  }
  public double ymax () {
    return /* TODO */0;
  }

  // width, height, area of rectangle
  public double width () {
    return /* TODO */0;
  }
  public double height () {
    return /* TODO */0;
  }
  public double area () {
    return /* TODO */0;
  }

  // halfway between xmin and xmax
  public double xmid () {
    return /* TODO */0;
  }
  // halfway between ymin and ymax
  public double ymid () {
    return /* TODO */0;
  }

  // follow the recipe given in the textbook (pp 102-103) to implement equals
  public boolean equals (Object y) {
    return /* TODO */false;
  }

  public void drawEllipse () {
    StdDraw.filledEllipse (xmid (), ymid (), width () / 2, height () / 2);
  }
  public void drawRectangle () {
    StdDraw.filledRectangle (xmid (), ymid (), width () / 2, height () / 2);
  }
  public String toString () {
    return "[" + xmin () + ", " + xmax () + "] x [" + ymin () + ", " + ymax () + "]";
  }
}